GNU bug report logs - #58310
[PATCH] Add coq-mathcomp-analysis

Please note: This is a static page, with minimal formatting, updated once a day.
Click here to see this page with the latest information and nicer formatting.

Package: guix-patches; Reported by: Garek Dyszel <garekdyszel@HIDDEN>; Keywords: patch; dated Wed, 5 Oct 2022 17:22:02 UTC; Maintainer for guix-patches is guix-patches@HIDDEN.

Message received at 58310 <at> debbugs.gnu.org:


Received: (at 58310) by debbugs.gnu.org; 13 Nov 2022 18:54:21 +0000
From debbugs-submit-bounces <at> debbugs.gnu.org Sun Nov 13 13:54:21 2022
Received: from localhost ([127.0.0.1]:48356 helo=debbugs.gnu.org)
	by debbugs.gnu.org with esmtp (Exim 4.84_2)
	(envelope-from <debbugs-submit-bounces <at> debbugs.gnu.org>)
	id 1ouI7Z-0002si-FP
	for submit <at> debbugs.gnu.org; Sun, 13 Nov 2022 13:54:21 -0500
Received: from knopi.disroot.org ([178.21.23.139]:36664)
 by debbugs.gnu.org with esmtp (Exim 4.84_2)
 (envelope-from <garekdyszel@HIDDEN>) id 1ouI7X-0002sZ-8W
 for 58310 <at> debbugs.gnu.org; Sun, 13 Nov 2022 13:54:20 -0500
Received: from localhost (localhost [127.0.0.1])
 by disroot.org (Postfix) with ESMTP id 5DA464109F;
 Sun, 13 Nov 2022 19:54:17 +0100 (CET)
X-Virus-Scanned: SPAM Filter at disroot.org
Received: from knopi.disroot.org ([127.0.0.1])
 by localhost (disroot.org [127.0.0.1]) (amavisd-new, port 10024)
 with ESMTP id tsR6Dc4vqlPE; Sun, 13 Nov 2022 19:54:16 +0100 (CET)
From: Garek Dyszel <garekdyszel@HIDDEN>
DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=disroot.org; s=mail;
 t=1668365656; bh=7owb286lg1W+KRlDux9HwDBAsNVSSlcMbNEXDPRA1SA=;
 h=From:To:Cc:Subject:In-Reply-To:References:Date:From;
 b=TmC1ecQ4pjpLKHg2hGkOCIFQDO6auhAs9nGI39CBgUWaVE6IHzPV03vXbwMnFmtu2
 9Uc/01AV7xNH2cIuLos1ujvmL5tSABdr9rwONFy7L1uRNmLwRNx+1enRYUNiJJBqGe
 5w7R3+QW5gfWd2OfpceaefjR3V/fTiSkG0/9VcoVXsDxDmtAPPQJwTa00lHUWN1XdN
 AbgWPdJA9em0XBC0ZEYSMF+t9DpglxX97g9K5iZvhd2LWCIMud10TxxRhx96j/S1q2
 KPMaXMEvZb7SdXGChHbv3PLviRrgApaa9Eyt4gXASSq3xiLeTZw56FCbAC69glYr9E
 VnVQr6c6Rs66A==
To: Julien Lepiller <julien@HIDDEN>, zimoun <zimon.toutoune@HIDDEN>,
 58310 <at> debbugs.gnu.org
Subject: Re: [bug#58310] Manifest for coq-mathcomp-analysis
In-Reply-To: <20221113115303.66ccb071@HIDDEN>
References: <87h70iqji2.fsf@HIDDEN>
 <handler.58310.B.166499048624567.ack <at> debbugs.gnu.org>
 <87v8njspi5.fsf@HIDDEN>
 <A2D9782B-4542-4403-B078-51C3A2BD7640@HIDDEN>
 <20221113115303.66ccb071@HIDDEN>
Date: Sun, 13 Nov 2022 13:54:03 -0500
Message-ID: <87tu32eldg.fsf@HIDDEN>
MIME-Version: 1.0
Content-Type: text/plain
X-Spam-Score: 0.0 (/)
X-Debbugs-Envelope-To: 58310
Cc: pukkamustard <pukkamustard@HIDDEN>
X-BeenThere: debbugs-submit <at> debbugs.gnu.org
X-Mailman-Version: 2.1.18
Precedence: list
List-Id: <debbugs-submit.debbugs.gnu.org>
List-Unsubscribe: <https://debbugs.gnu.org/cgi-bin/mailman/options/debbugs-submit>, 
 <mailto:debbugs-submit-request <at> debbugs.gnu.org?subject=unsubscribe>
List-Archive: <https://debbugs.gnu.org/cgi-bin/mailman/private/debbugs-submit/>
List-Post: <mailto:debbugs-submit <at> debbugs.gnu.org>
List-Help: <mailto:debbugs-submit-request <at> debbugs.gnu.org?subject=help>
List-Subscribe: <https://debbugs.gnu.org/cgi-bin/mailman/listinfo/debbugs-submit>, 
 <mailto:debbugs-submit-request <at> debbugs.gnu.org?subject=subscribe>
Errors-To: debbugs-submit-bounces <at> debbugs.gnu.org
Sender: "Debbugs-submit" <debbugs-submit-bounces <at> debbugs.gnu.org>
X-Spam-Score: -1.0 (-)

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".





Information forwarded to guix-patches@HIDDEN:
bug#58310; Package guix-patches. Full text available.

Message received at 58310 <at> debbugs.gnu.org:


Received: (at 58310) by debbugs.gnu.org; 13 Nov 2022 10:53:13 +0000
From debbugs-submit-bounces <at> debbugs.gnu.org Sun Nov 13 05:53:13 2022
Received: from localhost ([127.0.0.1]:50143 helo=debbugs.gnu.org)
	by debbugs.gnu.org with esmtp (Exim 4.84_2)
	(envelope-from <debbugs-submit-bounces <at> debbugs.gnu.org>)
	id 1ouAbv-0006DY-DA
	for submit <at> debbugs.gnu.org; Sun, 13 Nov 2022 05:53:13 -0500
Received: from lepiller.eu ([89.234.186.109]:52356)
 by debbugs.gnu.org with esmtp (Exim 4.84_2)
 (envelope-from <julien@HIDDEN>) id 1ouAbr-0006DN-Fx
 for 58310 <at> debbugs.gnu.org; Sun, 13 Nov 2022 05:53:09 -0500
Received: from lepiller.eu (localhost [127.0.0.1])
 by lepiller.eu (OpenSMTPD) with ESMTP id 8e22513e;
 Sun, 13 Nov 2022 10:53:05 +0000 (UTC)
DKIM-Signature: v=1; a=rsa-sha256; c=relaxed; d=lepiller.eu; h=date:from
 :to:cc:subject:message-id:in-reply-to:references:mime-version
 :content-type; s=dkim; bh=zNKTkLYwymzgcLGWfjpkKqJWP/+TGKKLnP4bLQ
 OR2uA=; b=IMBfajCtl4MttgLcgjZ18wR4y6Bgza9JY51X2hfxvB2hdgxRL84axw
 kWdcoGYe2x6joveUsvVDOi2go7POC23PobQl5oiXD3Yavozj9oyoKCIBTBJ2qzv5
 vJPW7vOH/Eml83CBuktTMU4SI0U4zgox40qhyRvpB0dJ8syP8NE/yb4W6ZsnJPOQ
 iT/aP5Jg2ympvHv+oCuxD4+TwRyw5v/vfkdYYKDYajQ2Ze0/H42h7f4PCjOTXM0m
 5fn3uSrB4Gx1gsDYZNmld15cK7TkFL3le/Rui91X2yA5ADkyAniiTJxMgzoas6iQ
 2OWhzhlNIpn/rEqDzDhrS6kfyO9pmO5Q==
Received: by lepiller.eu (OpenSMTPD) with ESMTPSA id 0f3d1e8f
 (TLSv1.3:AEAD-AES256-GCM-SHA384:256:NO); 
 Sun, 13 Nov 2022 10:53:04 +0000 (UTC)
Date: Sun, 13 Nov 2022 11:53:03 +0100
From: Julien Lepiller <julien@HIDDEN>
To: Garek Dyszel <garekdyszel@HIDDEN>, zimoun
 <zimon.toutoune@HIDDEN>, 58310 <at> debbugs.gnu.org
Subject: Re: [bug#58310] Manifest for coq-mathcomp-analysis
Message-ID: <20221113115303.66ccb071@HIDDEN>
In-Reply-To: <A2D9782B-4542-4403-B078-51C3A2BD7640@HIDDEN>
References: <87h70iqji2.fsf@HIDDEN>
 <handler.58310.B.166499048624567.ack <at> debbugs.gnu.org>
 <87v8njspi5.fsf@HIDDEN>
 <A2D9782B-4542-4403-B078-51C3A2BD7640@HIDDEN>
X-Mailer: Claws Mail 4.1.1 (GTK 3.24.30; x86_64-pc-linux-gnu)
MIME-Version: 1.0
Content-Type: multipart/mixed; boundary="MP_/uvRhSCMl/XdMwbzM4kqo_=n"
X-Spam-Score: -0.0 (/)
X-Debbugs-Envelope-To: 58310
Cc: pukkamustard <pukkamustard@HIDDEN>
X-BeenThere: debbugs-submit <at> debbugs.gnu.org
X-Mailman-Version: 2.1.18
Precedence: list
List-Id: <debbugs-submit.debbugs.gnu.org>
List-Unsubscribe: <https://debbugs.gnu.org/cgi-bin/mailman/options/debbugs-submit>, 
 <mailto:debbugs-submit-request <at> debbugs.gnu.org?subject=unsubscribe>
List-Archive: <https://debbugs.gnu.org/cgi-bin/mailman/private/debbugs-submit/>
List-Post: <mailto:debbugs-submit <at> debbugs.gnu.org>
List-Help: <mailto:debbugs-submit-request <at> debbugs.gnu.org?subject=help>
List-Subscribe: <https://debbugs.gnu.org/cgi-bin/mailman/listinfo/debbugs-submit>, 
 <mailto:debbugs-submit-request <at> debbugs.gnu.org?subject=subscribe>
Errors-To: debbugs-submit-bounces <at> debbugs.gnu.org
Sender: "Debbugs-submit" <debbugs-submit-bounces <at> debbugs.gnu.org>
X-Spam-Score: -1.0 (-)

--MP_/uvRhSCMl/XdMwbzM4kqo_=n
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: quoted-printable
Content-Disposition: inline

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@HIDDEN> a =C3=A9crit :

> Hi!
>=20
> I tried building your file (it's technically not a manifest) and
> indeed it's failing in the chack-findlib-path.
>=20
> 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.
>=20
> Le 13 novembre 2022 00:48:50 GMT+01:00, Garek Dyszel
> <garekdyszel@HIDDEN> a =C3=A9crit=C2=A0:
> >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?=20
> >
> >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.)
> > =20


--MP_/uvRhSCMl/XdMwbzM4kqo_=n
Content-Type: text/x-scheme
Content-Transfer-Encoding: quoted-printable
Content-Disposition: attachment; filename=coq-mathcomp-analysis.scm

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

;; To build directly from this file, use the following command.
;; guix build --with-patch=3Docaml-elpi=3Dpatches/ocaml-elpi-fix-yojson.pat=
ch -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-buil=
d.scm
                  python-pathspec-0.10.1
                  ;; Below from python-xyz.scm, can be moved to python-buil=
d.scm
                  python-pluggy-1.0
                  python-tomli))
    (build-system pyproject-build-system)
    (arguments
     `( ;Tests depend on module python-hatch, which would result in circula=
r 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-b=
uild.scm
;;                   python-pathspec-0.10.1
;;                   ;; Below from python-xyz.scm, can be moved to python-b=
uild.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 speci=
fic
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 t=
his,
                      ;; 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=3DTrue)"
                              "test_end_to_end.py")
                      (chdir "../")))
                  ;; XXX: PEP 517 manual build/install procedures copied fr=
om
                  ;; 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 styl=
ing
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.=20
;; 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@HIDDEN
              ;; See <https://github.com/LPCIC/elpi/pull/167>.
              (patches (search-patches "ocaml-elpi-fix-yojson.patch"))
              ;(patches '("/home/chips/home/code/guix_packages/built/patche=
s/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 =CE=BBProlog Interpreter")
    (description
     "ELPI is an extension language for OCaml.  It implements a variant of
=CE=BBProlog enriched with Constraint Handling Rules, a programming languag=
e 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))=20
    (arguments
     `(#:test-target "test"
       ;; From the repo: "COQBIN=3D%{bin}%/" "ELPIDIR=3D%{prefix}%/lib/elpi=
" "OCAMLWARN=3D"
       #:make-flags ,#~(list (string-append "COQBIN=3D"
                                            #$(this-package-input "coq-core=
")
                                            "/bin/")
                             (string-append "ELPIDIR=3D"
                                            #$(this-package-input "ocaml-el=
pi")
                                            "/lib/ocaml/site-lib/elpi")
                             (string-append "COQLIBINSTALL=3D"
                                            #$output
                                            "/lib/coq/user-contrib")
                             (string-append "COQMF_COQLIB=3D"
                                            #$output
                                            "/lib/ocaml/site-lib/coq")
                             (string-append "COQPLUGININSTALL=3D"
                                            #$output
                                            "/lib/ocaml/site-lib")
                             "OCAMLWARN=3D")
       #: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 =CE=BBProlog.  It also provides a wa=
y to
embed Coq's terms into =CE=BBProlog 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 comma=
nds
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=3D"
                                            #$(this-package-input "coq-elpi=
")
                                            "/lib/coq/user-contrib/elpi/")
                             (string-append "DESTDIR=3D"
                                            (assoc-ref %outputs "out"))
                             (string-append "COQLIBINSTALL=3D"
                                            #$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 alternat=
ive
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=3D"
                                            #$(this-package-input "coq-core=
")
                                            "/bin/")
                             (string-append "COQBININSTALL=3D"
                                            (assoc-ref %outputs "out") "/bi=
n/")
                             (string-append "COQMF_COQLIB=3D"
                                            (assoc-ref %outputs "out")
                                            "/lib/ocaml/site-lib/coq")
                             (string-append "COQLIBINSTALL=3D"
                                            (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

--MP_/uvRhSCMl/XdMwbzM4kqo_=n--




Information forwarded to guix-patches@HIDDEN:
bug#58310; Package guix-patches. Full text available.

Message received at 58310 <at> debbugs.gnu.org:


Received: (at 58310) by debbugs.gnu.org; 13 Nov 2022 09:17:16 +0000
From debbugs-submit-bounces <at> debbugs.gnu.org Sun Nov 13 04:17:16 2022
Received: from localhost ([127.0.0.1]:50065 helo=debbugs.gnu.org)
	by debbugs.gnu.org with esmtp (Exim 4.84_2)
	(envelope-from <debbugs-submit-bounces <at> debbugs.gnu.org>)
	id 1ou975-0003o7-Or
	for submit <at> debbugs.gnu.org; Sun, 13 Nov 2022 04:17:16 -0500
Received: from lepiller.eu ([89.234.186.109]:36142)
 by debbugs.gnu.org with esmtp (Exim 4.84_2)
 (envelope-from <julien@HIDDEN>) id 1ou973-0003nv-19
 for 58310 <at> debbugs.gnu.org; Sun, 13 Nov 2022 04:17:14 -0500
Received: from lepiller.eu (localhost [127.0.0.1])
 by lepiller.eu (OpenSMTPD) with ESMTP id 1f3cc262;
 Sun, 13 Nov 2022 09:17:10 +0000 (UTC)
DKIM-Signature: v=1; a=rsa-sha256; c=relaxed; d=lepiller.eu; h=date:from
 :to:cc:subject:in-reply-to:references:message-id:mime-version
 :content-type:content-transfer-encoding; s=dkim; bh=J8pvBhghCTBa
 24YuOcA2hwXeCjP29Rpy25j19HpNMoY=; b=K2GvhwuDI/xW7v1H05cAWH2dWAkk
 XVHYUIac4oIu2Csj5g1Pi5Ha9Qk0ijR4+FzhsVaEvDTVeQOx7H+F2HV96EP7nb0Q
 nCQXt5jFGY7QSuLfKmtdKZAO80uzaET7UcX/rg4w4ubrRagPwzYSeIwgwtieGN6v
 y6BtYDOsNeQdQtLAkb/rrtkwvvXZQAb+fU7TZYyGc3KDMXh1LwAgxJjan16nl+4K
 cDxnSjHylH7JWryXNqsLZSe5TvXv7tnpRtXuDvB26I7ze2N0nxCHlWfCOVjEW8gc
 ERjfB1Krx26LVGmW2908ubML7Th0D9Bk90BVon7rxBUcJ8G/1BAYCz2p/g==
Received: by lepiller.eu (OpenSMTPD) with ESMTPSA id 5db1b513
 (TLSv1.3:AEAD-AES256-GCM-SHA384:256:NO); 
 Sun, 13 Nov 2022 09:17:10 +0000 (UTC)
Date: Sun, 13 Nov 2022 10:17:07 +0100
From: Julien Lepiller <julien@HIDDEN>
To: Garek Dyszel <garekdyszel@HIDDEN>, zimoun <zimon.toutoune@HIDDEN>, 
 58310 <at> debbugs.gnu.org
Subject: Re: Manifest for coq-mathcomp-analysis
User-Agent: K-9 Mail for Android
In-Reply-To: <87v8njspi5.fsf@HIDDEN>
References: <87h70iqji2.fsf@HIDDEN>
 <handler.58310.B.166499048624567.ack <at> debbugs.gnu.org>
 <87v8njspi5.fsf@HIDDEN>
Message-ID: <A2D9782B-4542-4403-B078-51C3A2BD7640@HIDDEN>
MIME-Version: 1.0
Content-Type: multipart/alternative;
 boundary=----VEXPOYMVGO9M0GJPBXQXP1DBARXM2G
Content-Transfer-Encoding: 7bit
X-Spam-Score: -0.0 (/)
X-Debbugs-Envelope-To: 58310
Cc: pukkamustard <pukkamustard@HIDDEN>
X-BeenThere: debbugs-submit <at> debbugs.gnu.org
X-Mailman-Version: 2.1.18
Precedence: list
List-Id: <debbugs-submit.debbugs.gnu.org>
List-Unsubscribe: <https://debbugs.gnu.org/cgi-bin/mailman/options/debbugs-submit>, 
 <mailto:debbugs-submit-request <at> debbugs.gnu.org?subject=unsubscribe>
List-Archive: <https://debbugs.gnu.org/cgi-bin/mailman/private/debbugs-submit/>
List-Post: <mailto:debbugs-submit <at> debbugs.gnu.org>
List-Help: <mailto:debbugs-submit-request <at> debbugs.gnu.org?subject=help>
List-Subscribe: <https://debbugs.gnu.org/cgi-bin/mailman/listinfo/debbugs-submit>, 
 <mailto:debbugs-submit-request <at> debbugs.gnu.org?subject=subscribe>
Errors-To: debbugs-submit-bounces <at> debbugs.gnu.org
Sender: "Debbugs-submit" <debbugs-submit-bounces <at> debbugs.gnu.org>
X-Spam-Score: -1.0 (-)

------VEXPOYMVGO9M0GJPBXQXP1DBARXM2G
Content-Type: text/plain;
 charset=utf-8
Content-Transfer-Encoding: quoted-printable

Hi!

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

Why do you want to run it? There's no way it could work at this point, rig=
ht after the check phase, since the package is not even installed yet=2E Al=
so, the OCAMLPATH that would allow findlib to find it is not set to the out=
puts, only to the inputs=2E

Le 13 novembre 2022 00:48:50 GMT+01:00, Garek Dyszel <garekdyszel@disroot=
=2Eorg> a =C3=A9crit=C2=A0:
>Hi,
>
>CC: ocaml team
>
>I am including a manifest file instead of sending patches for now=2E It
>seems like a good idea to stick with that until these packages are ready
>to be put into the Guix source tree=2E I'm refactoring them too often=2E
>
>After opening an issue on Github [1] [2], it seems that coq-elpi is the
>package that is not building properly=2E It is clear that ocamlfind (from
>ocaml-findlib) can't find coq-elpi after coq-elpi's install phase=2E
>[1]: https://github=2Ecom/math-comp/hierarchy-builder/issues/320
>[2]: https://github=2Ecom/LPCIC/coq-elpi/issues/384
>
>It looks like the META file is not being installed by coq-elpi either=2E
>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)=2E
>
>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=2E
>
>The later package coq-mathcomp-hierarchy-builder runs ocamlfind to find
>coq-elpi, too=2E
>
>What would be a way to ensure that coq-elpi is found by ocamlfind?=20
>
>Thanks!
>Garek
>
>(Manifest attached with an ocaml-elpi patch=2E You will need to change th=
e path for
>the ocaml-elpi (patches) field to match your directory structure, but oth=
erwise
>this manifest should work=2E)
>

------VEXPOYMVGO9M0GJPBXQXP1DBARXM2G
Content-Type: text/html;
 charset=utf-8
Content-Transfer-Encoding: quoted-printable

<html><head></head><body>Hi!<br><br>I tried building your file (it's techni=
cally not a manifest) and indeed it's failing in the chack-findlib-path=2E<=
br><br>Why do you want to run it? There's no way it could work at this poin=
t, right after the check phase, since the package is not even installed yet=
=2E Also, the OCAMLPATH that would allow findlib to find it is not set to t=
he outputs, only to the inputs=2E<br><br><div class=3D"gmail_quote">Le 13 n=
ovembre 2022 00:48:50 GMT+01:00, Garek Dyszel &lt;garekdyszel@disroot=2Eorg=
&gt; a =C3=A9crit=C2=A0:<blockquote class=3D"gmail_quote" style=3D"margin: =
0pt 0pt 0pt 0=2E8ex; border-left: 1px solid rgb(204, 204, 204); padding-lef=
t: 1ex;">
<pre dir=3D"auto" class=3D"k9mail">Hi,<br><br>CC: ocaml team<br><br>I am i=
ncluding a manifest file instead of sending patches for now=2E It<br>seems =
like a good idea to stick with that until these packages are ready<br>to be=
 put into the Guix source tree=2E I'm refactoring them too often=2E<br><br>=
After opening an issue on Github [1] [2], it seems that coq-elpi is the<br>=
package that is not building properly=2E It is clear that ocamlfind (from<b=
r>ocaml-findlib) can't find coq-elpi after coq-elpi's install phase=2E<br>[=
1]: <a href=3D"https://github=2Ecom/math-comp/hierarchy-builder/issues/320"=
>https://github=2Ecom/math-comp/hierarchy-builder/issues/320</a><br>[2]: <a=
 href=3D"https://github=2Ecom/LPCIC/coq-elpi/issues/384">https://github=2Ec=
om/LPCIC/coq-elpi/issues/384</a><br><br>It looks like the META file is not =
being installed by coq-elpi either=2E<br>I'm not sure whether that's releva=
nt, since ocamlfind couldn't find<br>coq-elpi even when META was present (i=
n a much older revision of this<br>manifest; I can dig for it but just toda=
y don't have time)=2E<br><br>The problem seems to be something in the build=
 process itself; if the<br>extra phase 'check-findlib-path' is omitted then=
 coq-elpi's build is<br>reported as a success=2E<br><br>The later package c=
oq-mathcomp-hierarchy-builder runs ocamlfind to find<br>coq-elpi, too=2E<br=
><br>What would be a way to ensure that coq-elpi is found by ocamlfind? <br=
><br>Thanks!<br>Garek<br><br>(Manifest attached with an ocaml-elpi patch=2E=
 You will need to change the path for<br>the ocaml-elpi (patches) field to =
match your directory structure, but otherwise<br>this manifest should work=
=2E)<br><br></pre></blockquote></div></body></html>
------VEXPOYMVGO9M0GJPBXQXP1DBARXM2G--




Information forwarded to guix-patches@HIDDEN:
bug#58310; Package guix-patches. Full text available.

Message received at 58310 <at> debbugs.gnu.org:


Received: (at 58310) by debbugs.gnu.org; 13 Nov 2022 08:28:07 +0000
From debbugs-submit-bounces <at> debbugs.gnu.org Sun Nov 13 03:28:07 2022
Received: from localhost ([127.0.0.1]:49997 helo=debbugs.gnu.org)
	by debbugs.gnu.org with esmtp (Exim 4.84_2)
	(envelope-from <debbugs-submit-bounces <at> debbugs.gnu.org>)
	id 1ou8LW-0002XJ-Jt
	for submit <at> debbugs.gnu.org; Sun, 13 Nov 2022 03:28:07 -0500
Received: from knopi.disroot.org ([178.21.23.139]:48714)
 by debbugs.gnu.org with esmtp (Exim 4.84_2)
 (envelope-from <garekdyszel@HIDDEN>) id 1ou0Fz-0001pn-G6
 for 58310 <at> debbugs.gnu.org; Sat, 12 Nov 2022 18:49:53 -0500
Received: from localhost (localhost [127.0.0.1])
 by disroot.org (Postfix) with ESMTP id 0F65E410CB;
 Sun, 13 Nov 2022 00:49:50 +0100 (CET)
X-Virus-Scanned: SPAM Filter at disroot.org
Received: from knopi.disroot.org ([127.0.0.1])
 by localhost (disroot.org [127.0.0.1]) (amavisd-new, port 10024)
 with ESMTP id 6u7rYSL7UNQD; Sun, 13 Nov 2022 00:49:36 +0100 (CET)
From: Garek Dyszel <garekdyszel@HIDDEN>
DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=disroot.org; s=mail;
 t=1668296975; bh=/sIBGRbV4cx1aQOQl/KhML0jDieMVDPykoWToKx6fmY=;
 h=From:To:Cc:Subject:In-Reply-To:References:Date:From;
 b=GqwOaq8kwnIBVNWUzf8S74a9XfooW7pxLg5GKaBwsRw6/xH1ZTvMnsEuOYxJO5u2m
 e9taFx5k+S+X/ukfRDdyDwxPn9mVZtyTgFNxCo4mcQ53oNuqOTTg7sNr/rHxR2gRH2
 IxF2xNExHEDT2N/rzXgC4c69AAeMZ+jR5uIyIbquIpw4cDCcCGmIt6CuoO/F0d0kac
 M0n4X39kNNxGUHNMwEDpUI15lltYsODR3Ca6FbFiaYWZ1rfkj7/nHXQYhCFziy7PFg
 KlqEaS+kqkKf2+OW+xTTjc8XdWBFXGR9ExuTTF1/Zh9Ep53+azb2LJTC37SQZ/z1vQ
 CFU57om0+aSEw==
To: zimoun <zimon.toutoune@HIDDEN>, 58310 <at> debbugs.gnu.org
Subject: Manifest for coq-mathcomp-analysis
In-Reply-To: <handler.58310.B.166499048624567.ack <at> debbugs.gnu.org>
References: <87h70iqji2.fsf@HIDDEN>
 <handler.58310.B.166499048624567.ack <at> debbugs.gnu.org>
Date: Sat, 12 Nov 2022 18:48:50 -0500
Message-ID: <87v8njspi5.fsf@HIDDEN>
MIME-Version: 1.0
Content-Type: multipart/mixed; boundary="=-=-="
X-Debbugs-Envelope-To: 58310
X-Mailman-Approved-At: Sun, 13 Nov 2022 03:27:59 -0500
Cc: pukkamustard <pukkamustard@HIDDEN>,
 Julien Lepiller <julien@HIDDEN>
X-BeenThere: debbugs-submit <at> debbugs.gnu.org
X-Mailman-Version: 2.1.18
Precedence: list
List-Id: <debbugs-submit.debbugs.gnu.org>
List-Unsubscribe: <https://debbugs.gnu.org/cgi-bin/mailman/options/debbugs-submit>, 
 <mailto:debbugs-submit-request <at> debbugs.gnu.org?subject=unsubscribe>
List-Archive: <https://debbugs.gnu.org/cgi-bin/mailman/private/debbugs-submit/>
List-Post: <mailto:debbugs-submit <at> debbugs.gnu.org>
List-Help: <mailto:debbugs-submit-request <at> debbugs.gnu.org?subject=help>
List-Subscribe: <https://debbugs.gnu.org/cgi-bin/mailman/listinfo/debbugs-submit>, 
 <mailto:debbugs-submit-request <at> debbugs.gnu.org?subject=subscribe>
Errors-To: debbugs-submit-bounces <at> debbugs.gnu.org
Sender: "Debbugs-submit" <debbugs-submit-bounces <at> debbugs.gnu.org>

--=-=-=
Content-Type: text/plain

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.)


--=-=-=
Content-Type: application/octet-stream
Content-Disposition: attachment; filename=coq-mathcomp-analysis.scm
Content-Transfer-Encoding: base64
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--=-=-=
Content-Type: text/x-patch; charset=utf-8
Content-Disposition: inline; filename=ocaml-elpi-fix-yojson.patch
Content-Transfer-Encoding: quoted-printable

From 998dc654e5acd66d5d0c8ebe79ed04dd424eb698 Mon Sep 17 00:00:00 2001
From: Julien Puydt <julien.puydt@HIDDEN>
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 =3D
=20
   let cards =3D Trace.cards steps ~stack_frames ~aggregated_goal_success ~=
goal_text ~goal_attempts in
=20
-  let ob =3D Bi_outbuf.create_channel_writer stdout in
-  write_trace ob cards;
-  Bi_outbuf.flush_channel_writer ob
+  let buf =3D 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_t=
race1.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:)] =3D>\n main\n  [const-decl _ \n    (som=
e\n      (app\n        [global (const =C2=ABIsSelfA'.phant_Build=C2=BB), gl=
obal (indt =C2=ABnat=C2=BB), \n         global (indc =C2=ABO=C2=BB), 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:)] =3D>\n main\n  [const-decl _=
 \n    (some\n      (app\n        [global (const =C2=ABIsSelfA'.phant_Build=
=C2=BB), global (indt =C2=ABnat=C2=BB), \n         global (indc =C2=ABO=C2=
=BB), 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:)] =3D>\n main\n  [const-decl _ \n    (som=
e\n      (app\n        [global (const =C2=ABIsSelfA'.phant_Build=C2=BB), gl=
obal (indt =C2=ABnat=C2=BB), \n         global (indc =C2=ABO=C2=BB), 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:)] =3D>\n main\n  [cons=
t-decl _ \n    (some\n      (app\n        [global (const =C2=ABIsSelfA'.pha=
nt_Build=C2=BB), global (indt =C2=ABnat=C2=BB), \n         global (indc =C2=
=ABO=C2=BB), fun `x` X0 c0 \\ c0])) (arity X1)]",
         "current_goal_predicate": "=3D>",
         "failed_attempts": [],
         "successful_attempts": [
@@ -31,8 +29,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "main\n [const-decl _ \n   (some\n     (app\n       [glo=
bal (const =C2=ABIsSelfA'.phant_Build=C2=BB), global (indt =C2=ABnat=C2=BB)=
, \n        global (indc =C2=ABO=C2=BB), fun `x` X0 c0 \\ c0])) (arity X1)]=
",
+                "goal_text": "main\n [const-decl _ \n   (some\n     (app\n=
       [global (const =C2=ABIsSelfA'.phant_Build=C2=BB), global (indt =C2=
=ABnat=C2=BB), \n        global (indc =C2=ABO=C2=BB), 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 (con=
st =C2=ABIsSelfA'.phant_Build=C2=BB), global (indt =C2=ABnat=C2=BB), \n    =
    global (indc =C2=ABO=C2=BB), fun `x` X0 c0 \\ c0])) (arity X1)]",
+        "current_goal_text": "main\n [const-decl _ \n   (some\n     (app\n=
       [global (const =C2=ABIsSelfA'.phant_Build=C2=BB), global (indt =C2=
=ABnat=C2=BB), \n        global (indc =C2=ABO=C2=BB), 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-c=
onst _ \n     (app\n       [global (const =C2=ABIsSelfA'.phant_Build=C2=BB)=
, global (indt =C2=ABnat=C2=BB), \n        global (indc =C2=ABO=C2=BB), fun=
 `x` X0 c0 \\ c0]) (arity X1) _))",
+                "goal_text": "with-attributes\n (with-logging\n   (instanc=
e.declare-const _ \n     (app\n       [global (const =C2=ABIsSelfA'.phant_B=
uild=C2=BB), global (indt =C2=ABnat=C2=BB), \n        global (indc =C2=ABO=
=C2=BB), 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-at=
tributes (with-logging (instance.declare-const A0 A1 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       [globa=
l (const =C2=ABIsSelfA'.phant_Build=C2=BB), global (indt =C2=ABnat=C2=BB), =
\n        global (indc =C2=ABO=C2=BB), fun `x` X0 c0 \\ c0])) (arity X1)]",
+              "goal_text": "main\n [const-decl _ \n   (some\n     (app\n  =
     [global (const =C2=ABIsSelfA'.phant_Build=C2=BB), global (indt =C2=ABn=
at=C2=BB), \n        global (indc =C2=ABO=C2=BB), fun `x` X0 c0 \\ c0])) (a=
rity 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 (instanc=
e.declare-existing A0 A1))).",
+              "rule_text": "(main [A0, A1]) :- (!), \n (coq.warning HB HB.=
deprecated \n   The syntax \"HB.instance Key FactoryInstance\" is deprecate=
d, use \"HB.instance Definition\" instead), \n (with-attributes (with-loggi=
ng (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       [globa=
l (const =C2=ABIsSelfA'.phant_Build=C2=BB), global (indt =C2=ABnat=C2=BB), =
\n        global (indc =C2=ABO=C2=BB), fun `x` X0 c0 \\ c0])) (arity X1)]",
+              "goal_text": "main\n [const-decl _ \n   (some\n     (app\n  =
     [global (const =C2=ABIsSelfA'.phant_Build=C2=BB), global (indt =C2=ABn=
at=C2=BB), \n        global (indc =C2=ABO=C2=BB), fun `x` X0 c0 \\ c0])) (a=
rity X1)]",
               "goal_id": 1122
             },
             "cut_branch": {
-              "rule_text":
-                "(main _) :- (coq.error\n              Usage: HB.instance =
Definition <Name> :=3D <Builder> T ...).",
+              "rule_text": "(main _) :- (coq.error\n              Usage: H=
B.instance Definition <Name> :=3D <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 =C2=ABIsSelfA'.phant_Build=C2=BB), global=
 (indt =C2=ABnat=C2=BB), \n        global (indc =C2=ABO=C2=BB), fun `x` X0 =
c0 \\ c0]) (arity X1) _))",
+        "current_goal_text": "with-attributes\n (with-logging\n   (instanc=
e.declare-const _ \n     (app\n       [global (const =C2=ABIsSelfA'.phant_B=
uild=C2=BB), global (indt =C2=ABnat=C2=BB), \n        global (indc =C2=ABO=
=C2=BB), 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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n =
                   (supported-attribute (att c7 attmap)) (!) \n            =
        (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (s=
upported-attribute (att c8 string) :- !)) =3D>\n                      parse=
-attributes.aux c1  c6) \n                    (std.append c5 [get-option c7=
 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbos=
e bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type=
 string, att short.pack string, att infer attmap, \n     att key string, at=
t arg_sort bool, att log bool, att log.raw bool, \n     att compress_coerci=
ons bool, att export bool, att skip string, \n     att local bool, att fail=
 bool, att doc string, \n     att primitive_class bool, att primitive bool,=
 \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                  "rule_text": "(with-attributes A0) :- (attributes A1), \=
n (pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (=
pi (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (=
pi (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) |=
 c2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ .=
 ^ c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n =
                   (parse-attributes.aux c2 c3 c5) \n                    (p=
i (c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                =
      parse-attributes.aux c1  c6) \n                    (std.append c5 [ge=
t-option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    =
[att verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att=
 short.type string, att short.pack string, att infer attmap, \n     att key=
 string, att arg_sort bool, att log bool, att log.raw bool, \n     att comp=
ress_coercions bool, att export bool, att skip string, \n     att local boo=
l, att fail bool, att doc string, \n     att primitive_class bool, att prim=
itive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (=
!), \n (A2 =3D> (save-docstring , A0)).",
                   "rule_loc": [
                     "File",
                     {
-                      "filename":
-                        "/home/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-attribut=
es.aux [attribute c0 (node c1) | c2] c3 c4 :-\n         , (if (c3 =3D ) (c7=
 =3D c0) (c7 is c3 ^ . ^ c0)) \n          (supported-attribute (att c7 attm=
ap)) (!) \n          (parse-attributes.aux c2 c3 c5) \n          (pi c8 \\ =
supported-attribute (att c8 string) :- ! =3D>\n            parse-attributes=
.aux c1  c6) \n          (std.append c5 [get-option c7 c6] c4) =3D>\n coq.p=
arse-attributes X2 \n  [att verbose bool, att mathcomp bool, att mathcomp.a=
xiom string, \n   att short.type string, att short.pack string, att infer a=
ttmap, \n   att key string, att arg_sort bool, att log bool, att log.raw bo=
ol, \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        par=
se-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n         , (if (c=
3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n          (supported-attribute (=
att c7 attmap)) (!) \n          (parse-attributes.aux c2 c3 c5) \n         =
 (pi c8 \\ supported-attribute (att c8 string) :- ! =3D>\n            parse=
-attributes.aux c1  c6) \n          (std.append c5 [get-option c7 c6] c4) =
=3D>\n coq.parse-attributes X2 \n  [att verbose bool, att mathcomp bool, at=
t mathcomp.axiom string, \n   att short.type string, att short.pack string,=
 att infer attmap, \n   att key string, att arg_sort bool, att log bool, at=
t 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, at=
t hnf bool] X3",
                 "goal_id": 1126
               },
               { "goal_text": "!", "goal_id": 1127 },
               {
-                "goal_text":
-                  "X3 =3D>\n (save-docstring ,\n   with-logging\n    (inst=
ance.declare-const _ \n      (app\n        [global (const =C2=ABIsSelfA'.ph=
ant_Build=C2=BB), global (indt =C2=ABnat=C2=BB), \n         global (indc =
=C2=ABO=C2=BB), fun `x` X0 c0 \\ c0]) (arity X1) _))",
+                "goal_text": "X3 =3D>\n (save-docstring ,\n   with-logging=
\n    (instance.declare-const _ \n      (app\n        [global (const =C2=AB=
IsSelfA'.phant_Build=C2=BB), global (indt =C2=ABnat=C2=BB), \n         glob=
al (indc =C2=ABO=C2=BB), 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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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 Fi=
le \"(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    (le=
af-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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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 =3D ) (c7 =3D c0)=
 (c7 is c3 ^ . ^ c0)) \n          (supported-attribute (att c7 attmap)) (!)=
 \n          (parse-attributes.aux c2 c3 c5) \n          (pi c8 \\ supporte=
d-attribute (att c8 string) :- ! =3D>\n            parse-attributes.aux c1 =
 c6) \n          (std.append c5 [get-option c7 c6] c4) =3D>\n coq.parse-att=
ributes\n  [attribute elpi.loc \n    (leaf-loc File \"(stdin)\", line 1, co=
lumn 2, character 3:)] \n  [att verbose bool, att mathcomp bool, att mathco=
mp.axiom string, \n   att short.type string, att short.pack string, att inf=
er attmap, \n   att key string, att arg_sort bool, att log bool, att log.ra=
w 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 bo=
ol, \n   att primitive bool, att non_forgetful_inheritance bool, att hnf bo=
ol] 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        par=
se-attributes.aux [attribute c0 (node c1) | c2] c3 c4 :-\n         , (if (c=
3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n          (supported-attribute (=
att c7 attmap)) (!) \n          (parse-attributes.aux c2 c3 c5) \n         =
 (pi c8 \\ supported-attribute (att c8 string) :- ! =3D>\n            parse=
-attributes.aux c1  c6) \n          (std.append c5 [get-option c7 c6] c4) =
=3D>\n coq.parse-attributes\n  [attribute elpi.loc \n    (leaf-loc File \"(=
stdin)\", line 1, column 2, character 3:)] \n  [att verbose bool, att mathc=
omp bool, att mathcomp.axiom string, \n   att short.type string, att short.=
pack string, att infer attmap, \n   att key string, att arg_sort bool, att =
log bool, att log.raw bool, \n   att compress_coercions bool, att export bo=
ol, att skip string, \n   att local bool, att fail bool, att doc string, at=
t primitive_class bool, \n   att primitive bool, att non_forgetful_inherita=
nce bool, att hnf bool] X3",
         "current_goal_predicate": "=3D>",
         "failed_attempts": [],
         "successful_attempts": [
@@ -410,8 +385,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "coq.parse-attributes\n [attribute elpi.loc \n   (leaf-l=
oc File \"(stdin)\", line 1, column 2, character 3:)] \n [att verbose bool,=
 att mathcomp bool, att mathcomp.axiom string, \n  att short.type string, a=
tt short.pack string, att infer attmap, \n  att key string, att arg_sort bo=
ol, att log bool, att log.raw bool, \n  att compress_coercions bool, att ex=
port bool, att skip string, \n  att local bool, att fail bool, att doc stri=
ng, att primitive_class bool, \n  att primitive bool, att non_forgetful_inh=
eritance 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 ve=
rbose bool, att mathcomp bool, att mathcomp.axiom string, \n  att short.typ=
e string, att short.pack string, att infer attmap, \n  att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n  att compress_coercions b=
ool, att export bool, att skip string, \n  att local bool, att fail bool, a=
tt doc string, att primitive_class bool, \n  att primitive bool, att non_fo=
rgetful_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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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 mat=
hcomp bool, att mathcomp.axiom string, \n  att short.type string, att short=
.pack string, att infer attmap, \n  att key string, att arg_sort bool, att =
log bool, att log.raw bool, \n  att compress_coercions bool, att export boo=
l, 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 ve=
rbose bool, att mathcomp bool, att mathcomp.axiom string, \n  att short.typ=
e string, att short.pack string, att infer attmap, \n  att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n  att compress_coercions b=
ool, att export bool, att skip string, \n  att local bool, att fail bool, a=
tt doc string, att primitive_class bool, \n  att primitive bool, att non_fo=
rgetful_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 =3D supported-attribute c=
0))) A3), \n (A3 =3D> parse-attributes.aux A0  A2), (!).",
+                  "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.ma=
p A1 (c0 \\ (c1 \\\n                                     (c1 =3D supported-=
attribute c0))) A3), \n (A3 =3D> 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 mat=
hcomp.axiom string, \n  att short.type string, att short.pack string, att i=
nfer attmap, \n  att key string, att arg_sort bool, att log bool, att log.r=
aw 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 boo=
l, \n  att primitive bool, att non_forgetful_inheritance bool, att hnf bool=
] (c0 \\\n c1 \\ c1 =3D supported-attribute c0) X4",
+                "goal_text": "std.map\n [att verbose bool, att mathcomp bo=
ol, att mathcomp.axiom string, \n  att short.type string, att short.pack st=
ring, att infer attmap, \n  att key string, att arg_sort bool, att log bool=
, att log.raw bool, \n  att compress_coercions bool, att export bool, att s=
kip string, \n  att local bool, att fail bool, att doc string, att primitiv=
e_class bool, \n  att primitive bool, att non_forgetful_inheritance bool, a=
tt hnf bool] (c0 \\\n c1 \\ c1 =3D supported-attribute c0) X4",
                 "goal_id": 1130
               },
               {
-                "goal_text":
-                  "X4 =3D>\n parse-attributes.aux\n  [attribute elpi.loc \=
n    (leaf-loc File \"(stdin)\", line 1, column 2, character 3:)]  X3",
+                "goal_text": "X4 =3D>\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 =3D supported-attribute c0)=
)) A3), \n (A3 =3D> parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map =
A1 (c0 \\ (c1 \\\n                                     (c1 =3D supported-at=
tribute c0))) A3), \n (A3 =3D> 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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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.ax=
iom string, \n  att short.type string, att short.pack string, att infer att=
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  a=
tt primitive bool, att non_forgetful_inheritance bool, att hnf bool] (c0 \\=
\n c1 \\ c1 =3D supported-attribute c0) X4",
+        "current_goal_text": "std.map\n [att verbose bool, att mathcomp bo=
ol, att mathcomp.axiom string, \n  att short.type string, att short.pack st=
ring, att infer attmap, \n  att key string, att arg_sort bool, att log bool=
, att log.raw bool, \n  att compress_coercions bool, att export bool, att s=
kip string, \n  att local bool, att fail bool, att doc string, att primitiv=
e_class bool, \n  att primitive bool, att non_forgetful_inheritance bool, a=
tt hnf bool] (c0 \\\n c1 \\ c1 =3D 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 k=
ey string, \n  att arg_sort bool, att log bool, att log.raw bool, \n  att c=
ompress_coercions bool, att export bool, att skip string, \n  att local boo=
l, att fail bool, att doc string, att primitive_class bool, \n  att primiti=
ve bool, att non_forgetful_inheritance bool, att hnf bool] (c0 \\\n c1 \\ c=
1 =3D supported-attribute c0) X6",
+                "goal_text": "std.map\n [att mathcomp bool, att mathcomp.a=
xiom string, att short.type string, \n  att short.pack string, att infer at=
tmap, 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  at=
t 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 =3D 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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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 =3D supported-attribute c0)=
)) A3), \n (A3 =3D> parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map =
A1 (c0 \\ (c1 \\\n                                     (c1 =3D supported-at=
tribute c0))) A3), \n (A3 =3D> 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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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 =3D supported-attribute c0)=
)) A3), \n (A3 =3D> parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map =
A1 (c0 \\ (c1 \\\n                                     (c1 =3D supported-at=
tribute c0))) A3), \n (A3 =3D> 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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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 sh=
ort.type string, \n  att short.pack string, att infer attmap, att key strin=
g, \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 f=
ail bool, att doc string, att primitive_class bool, \n  att primitive bool,=
 att non_forgetful_inheritance bool, att hnf bool] (c0 \\\n c1 \\ c1 =3D su=
pported-attribute c0) X6",
+        "current_goal_text": "std.map\n [att mathcomp bool, att mathcomp.a=
xiom string, att short.type string, \n  att short.pack string, att infer at=
tmap, 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  at=
t 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 =3D 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 st=
ring, 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 d=
oc string, \n  att primitive_class bool, att primitive bool, \n  att non_fo=
rgetful_inheritance bool, att hnf bool] (c0 \\ c1 \\\n c1 =3D supported-att=
ribute c0) X8",
+                "goal_text": "std.map\n [att mathcomp.axiom string, att sh=
ort.type string, att short.pack string, \n  att infer attmap, att key strin=
g, att arg_sort bool, att log bool, \n  att log.raw bool, att compress_coer=
cions 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 =3D su=
pported-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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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 =3D supported-attribute c0)=
)) A3), \n (A3 =3D> parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map =
A1 (c0 \\ (c1 \\\n                                     (c1 =3D supported-at=
tribute c0))) A3), \n (A3 =3D> 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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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 =3D supported-attribute c0)=
)) A3), \n (A3 =3D> parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map =
A1 (c0 \\ (c1 \\\n                                     (c1 =3D supported-at=
tribute c0))) A3), \n (A3 =3D> 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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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, at=
t short.pack string, \n  att infer attmap, att key string, att arg_sort boo=
l, att log bool, \n  att log.raw bool, att compress_coercions bool, att exp=
ort bool, \n  att skip string, att local bool, att fail bool, att doc strin=
g, \n  att primitive_class bool, att primitive bool, \n  att non_forgetful_=
inheritance bool, att hnf bool] (c0 \\ c1 \\\n c1 =3D supported-attribute c=
0) X8",
+        "current_goal_text": "std.map\n [att mathcomp.axiom string, att sh=
ort.type string, att short.pack string, \n  att infer attmap, att key strin=
g, att arg_sort bool, att log bool, \n  att log.raw bool, att compress_coer=
cions 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 =3D su=
pported-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 =3D supported-attribute (att mathcomp.axiom string)",
+                "goal_text": "X9 =3D supported-attribute (att mathcomp.axi=
om 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, at=
t 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_cl=
ass bool, \n  att primitive bool, att non_forgetful_inheritance bool, att h=
nf bool] (c0 \\\n c1 \\ c1 =3D 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 l=
og bool, att 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 p=
rimitive_class bool, \n  att primitive bool, att non_forgetful_inheritance =
bool, att hnf bool] (c0 \\\n c1 \\ c1 =3D 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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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 =3D supported-attribute c0)=
)) A3), \n (A3 =3D> parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map =
A1 (c0 \\ (c1 \\\n                                     (c1 =3D supported-at=
tribute c0))) A3), \n (A3 =3D> 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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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 =3D supported-attribute (att mathcomp.axiom string)",
+        "current_goal_text": "X9 =3D supported-attribute (att mathcomp.axi=
om string)",
         "current_goal_predicate": "=3D",
         "failed_attempts": [],
         "successful_attempts": [
@@ -1442,8 +1365,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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 =3D supported-attribute c0)=
)) A3), \n (A3 =3D> parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map =
A1 (c0 \\ (c1 \\\n                                     (c1 =3D supported-at=
tribute c0))) A3), \n (A3 =3D> 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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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 in=
fer attmap, \n  att key string, att arg_sort bool, att log bool, att log.ra=
w 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 =3D 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 l=
og bool, att 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 p=
rimitive_class bool, \n  att primitive bool, att non_forgetful_inheritance =
bool, att hnf bool] (c0 \\\n c1 \\ c1 =3D 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 =3D supported-attribute (att short.type string)",
+                "goal_text": "X11 =3D 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 b=
ool, att fail bool, att doc string, att primitive_class bool, \n  att primi=
tive bool, att non_forgetful_inheritance bool, att hnf bool] (c0 \\\n c1 \\=
 c1 =3D 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 bo=
ol, \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 =3D 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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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 =3D supported-attribute c0)=
)) A3), \n (A3 =3D> parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map =
A1 (c0 \\ (c1 \\\n                                     (c1 =3D supported-at=
tribute c0))) A3), \n (A3 =3D> 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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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 =3D supported-attribute (att short.type string)",
+        "current_goal_text": "X11 =3D supported-attribute (att short.type =
string)",
         "current_goal_predicate": "=3D",
         "failed_attempts": [],
         "successful_attempts": [
@@ -1826,8 +1729,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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 =3D supported-attribute c0)=
)) A3), \n (A3 =3D> parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map =
A1 (c0 \\ (c1 \\\n                                     (c1 =3D supported-at=
tribute c0))) A3), \n (A3 =3D> 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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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 str=
ing, \n  att arg_sort bool, att log bool, att log.raw bool, \n  att compres=
s_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 boo=
l, att non_forgetful_inheritance bool, att hnf bool] (c0 \\\n c1 \\ c1 =3D =
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 bo=
ol, \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 =3D 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 =3D supported-attribute (att short.pack string)",
+                "goal_text": "X13 =3D supported-attribute (att short.pack =
string)",
                 "goal_id": 1141
               },
               {
-                "goal_text":
-                  "std.map\n [att infer attmap, att key string, att arg_so=
rt bool, att log bool, \n  att log.raw bool, att compress_coercions bool, a=
tt 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_forg=
etful_inheritance bool, att hnf bool] (c0 \\ c1 \\\n c1 =3D supported-attri=
bute 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_coerci=
ons bool, att export bool, \n  att skip string, att local bool, att fail bo=
ol, att doc string, \n  att primitive_class bool, att primitive bool, \n  a=
tt non_forgetful_inheritance bool, att hnf bool] (c0 \\ c1 \\\n c1 =3D supp=
orted-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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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 =3D supported-attribute c0)=
)) A3), \n (A3 =3D> parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map =
A1 (c0 \\ (c1 \\\n                                     (c1 =3D supported-at=
tribute c0))) A3), \n (A3 =3D> 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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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 =3D supported-attribute (att short.pack string)",
+        "current_goal_text": "X13 =3D supported-attribute (att short.pack =
string)",
         "current_goal_predicate": "=3D",
         "failed_attempts": [],
         "successful_attempts": [
@@ -2250,8 +2131,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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 =3D supported-attribute c0)=
)) A3), \n (A3 =3D> parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map =
A1 (c0 \\ (c1 \\\n                                     (c1 =3D supported-at=
tribute c0))) A3), \n (A3 =3D> 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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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 expor=
t 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_in=
heritance bool, att hnf bool] (c0 \\ c1 \\\n c1 =3D 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_coerci=
ons bool, att export bool, \n  att skip string, att local bool, att fail bo=
ol, att doc string, \n  att primitive_class bool, att primitive bool, \n  a=
tt non_forgetful_inheritance bool, att hnf bool] (c0 \\ c1 \\\n c1 =3D supp=
orted-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 b=
ool, att log.raw bool, \n  att compress_coercions bool, att export bool, at=
t skip string, \n  att local bool, att fail bool, att doc string, att primi=
tive_class bool, \n  att primitive bool, att non_forgetful_inheritance bool=
, att hnf bool] (c0 \\\n c1 \\ c1 =3D 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 expo=
rt 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_inher=
itance bool, att hnf bool] (c0 \\\n c1 \\ c1 =3D supported-attribute c0) X1=
6",
                 "goal_id": 1144
               }
             ],
@@ -2484,8 +2353,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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 =3D supported-attribute c0)=
)) A3), \n (A3 =3D> parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map =
A1 (c0 \\ (c1 \\\n                                     (c1 =3D supported-at=
tribute c0))) A3), \n (A3 =3D> 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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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 =3D supported-attribute c0)=
)) A3), \n (A3 =3D> parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map =
A1 (c0 \\ (c1 \\\n                                     (c1 =3D supported-at=
tribute c0))) A3), \n (A3 =3D> 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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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 s=
tring, \n  att local bool, att fail bool, att doc string, att primitive_cla=
ss bool, \n  att primitive bool, att non_forgetful_inheritance bool, att hn=
f bool] (c0 \\\n c1 \\ c1 =3D 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 expo=
rt 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_inher=
itance bool, att hnf bool] (c0 \\\n c1 \\ c1 =3D supported-attribute c0) X1=
6",
         "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 =3D 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 ski=
p 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 =3D 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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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 =3D supported-attribute c0)=
)) A3), \n (A3 =3D> parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map =
A1 (c0 \\ (c1 \\\n                                     (c1 =3D supported-at=
tribute c0))) A3), \n (A3 =3D> 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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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 =3D supported-attribute c0)=
)) A3), \n (A3 =3D> parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map =
A1 (c0 \\ (c1 \\\n                                     (c1 =3D supported-at=
tribute c0))) A3), \n (A3 =3D> 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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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 l=
ocal 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 =3D 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 ski=
p 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 =3D 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 =
=3D supported-attribute c0) X20",
+                "goal_text": "std.map\n [att log bool, att log.raw bool, a=
tt 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 pri=
mitive bool, \n  att non_forgetful_inheritance bool, att hnf bool] (c0 \\ c=
1 \\\n c1 =3D 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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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 =3D supported-attribute c0)=
)) A3), \n (A3 =3D> parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map =
A1 (c0 \\ (c1 \\\n                                     (c1 =3D supported-at=
tribute c0))) A3), \n (A3 =3D> 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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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 =3D supported-attribute c0)=
)) A3), \n (A3 =3D> parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map =
A1 (c0 \\ (c1 \\\n                                     (c1 =3D supported-at=
tribute c0))) A3), \n (A3 =3D> 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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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_coercio=
ns bool, \n  att export bool, att skip string, att local bool, att fail boo=
l, \n  att doc string, att primitive_class bool, att primitive bool, \n  at=
t non_forgetful_inheritance bool, att hnf bool] (c0 \\ c1 \\\n c1 =3D suppo=
rted-attribute c0) X20",
+        "current_goal_text": "std.map\n [att log bool, att log.raw bool, a=
tt 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 pri=
mitive bool, \n  att non_forgetful_inheritance bool, att hnf bool] (c0 \\ c=
1 \\\n c1 =3D 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 boo=
l, 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 =3D supported-a=
ttribute c0) X22",
+                "goal_text": "std.map\n [att log.raw bool, att compress_co=
ercions bool, att export bool, \n  att skip string, att local bool, att fai=
l 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 =3D =
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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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 =3D supported-attribute c0)=
)) A3), \n (A3 =3D> parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map =
A1 (c0 \\ (c1 \\\n                                     (c1 =3D supported-at=
tribute c0))) A3), \n (A3 =3D> 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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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 =3D supported-attribute c0)=
)) A3), \n (A3 =3D> parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map =
A1 (c0 \\ (c1 \\\n                                     (c1 =3D supported-at=
tribute c0))) A3), \n (A3 =3D> 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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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 e=
xport bool, \n  att skip string, att local bool, att fail bool, att doc str=
ing, \n  att primitive_class bool, att primitive bool, \n  att non_forgetfu=
l_inheritance bool, att hnf bool] (c0 \\ c1 \\\n c1 =3D supported-attribute=
 c0) X22",
+        "current_goal_text": "std.map\n [att log.raw bool, att compress_co=
ercions bool, att export bool, \n  att skip string, att local bool, att fai=
l 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 =3D =
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 p=
rimitive_class bool, \n  att primitive bool, att non_forgetful_inheritance =
bool, att hnf bool] (c0 \\\n c1 \\ c1 =3D 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 st=
ring, att primitive_class bool, \n  att primitive bool, att non_forgetful_i=
nheritance bool, att hnf bool] (c0 \\\n c1 \\ c1 =3D 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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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 =3D supported-attribute c0)=
)) A3), \n (A3 =3D> parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map =
A1 (c0 \\ (c1 \\\n                                     (c1 =3D supported-at=
tribute c0))) A3), \n (A3 =3D> 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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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 =3D supported-attribute c0)=
)) A3), \n (A3 =3D> parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map =
A1 (c0 \\ (c1 \\\n                                     (c1 =3D supported-at=
tribute c0))) A3), \n (A3 =3D> 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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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 sk=
ip string, \n  att local bool, att fail bool, att doc string, att primitive=
_class bool, \n  att primitive bool, att non_forgetful_inheritance bool, at=
t hnf bool] (c0 \\\n c1 \\ c1 =3D 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 st=
ring, att primitive_class bool, \n  att primitive bool, att non_forgetful_i=
nheritance bool, att hnf bool] (c0 \\\n c1 \\ c1 =3D 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 =3D supported-attribute (att compress_coercions boo=
l)",
+                "goal_text": "X25 =3D supported-attribute (att compress_co=
ercions 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 prim=
itive bool, \n  att non_forgetful_inheritance bool, att hnf bool] (c0 \\ c1=
 \\\n c1 =3D 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 boo=
l, att primitive bool, \n  att non_forgetful_inheritance bool, att hnf bool=
] (c0 \\ c1 \\\n c1 =3D 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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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 =3D supported-attribute c0)=
)) A3), \n (A3 =3D> parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map =
A1 (c0 \\ (c1 \\\n                                     (c1 =3D supported-at=
tribute c0))) A3), \n (A3 =3D> 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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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 =3D supported-attribute (att compress_coercions bool)",
+        "current_goal_text": "X25 =3D supported-attribute (att compress_co=
ercions bool)",
         "current_goal_predicate": "=3D",
         "failed_attempts": [],
         "successful_attempts": [
@@ -5611,8 +5328,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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 =3D supported-attribute c0)=
)) A3), \n (A3 =3D> parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map =
A1 (c0 \\ (c1 \\\n                                     (c1 =3D supported-at=
tribute c0))) A3), \n (A3 =3D> 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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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, at=
t fail bool, \n  att doc string, att primitive_class bool, att primitive bo=
ol, \n  att non_forgetful_inheritance bool, att hnf bool] (c0 \\ c1 \\\n c1=
 =3D 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 boo=
l, att primitive bool, \n  att non_forgetful_inheritance bool, att hnf bool=
] (c0 \\ c1 \\\n c1 =3D 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 bo=
ol, att doc string, \n  att primitive_class bool, att primitive bool, \n  a=
tt non_forgetful_inheritance bool, att hnf bool] (c0 \\ c1 \\\n c1 =3D supp=
orted-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 =3D 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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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 =3D supported-attribute c0)=
)) A3), \n (A3 =3D> parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map =
A1 (c0 \\ (c1 \\\n                                     (c1 =3D supported-at=
tribute c0))) A3), \n (A3 =3D> 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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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 =3D supported-attribute c0)=
)) A3), \n (A3 =3D> parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map =
A1 (c0 \\ (c1 \\\n                                     (c1 =3D supported-at=
tribute c0))) A3), \n (A3 =3D> 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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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_f=
orgetful_inheritance bool, att hnf bool] (c0 \\ c1 \\\n c1 =3D supported-at=
tribute 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 =3D 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 strin=
g, att primitive_class bool, \n  att primitive bool, att non_forgetful_inhe=
ritance bool, att hnf bool] (c0 \\\n c1 \\ c1 =3D supported-attribute c0) X=
30",
+                "goal_text": "std.map\n [att local bool, att fail bool, at=
t doc string, att primitive_class bool, \n  att primitive bool, att non_for=
getful_inheritance bool, att hnf bool] (c0 \\\n c1 \\ c1 =3D supported-attr=
ibute c0) X30",
                 "goal_id": 1158
               }
             ],
@@ -6684,8 +6348,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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 =3D supported-attribute c0)=
)) A3), \n (A3 =3D> parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map =
A1 (c0 \\ (c1 \\\n                                     (c1 =3D supported-at=
tribute c0))) A3), \n (A3 =3D> 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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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 =3D supported-attribute c0)=
)) A3), \n (A3 =3D> parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map =
A1 (c0 \\ (c1 \\\n                                     (c1 =3D supported-at=
tribute c0))) A3), \n (A3 =3D> 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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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 p=
rimitive_class bool, \n  att primitive bool, att non_forgetful_inheritance =
bool, att hnf bool] (c0 \\\n c1 \\ c1 =3D supported-attribute c0) X30",
+        "current_goal_text": "std.map\n [att local bool, att fail bool, at=
t doc string, att primitive_class bool, \n  att primitive bool, att non_for=
getful_inheritance bool, att hnf bool] (c0 \\\n c1 \\ c1 =3D supported-attr=
ibute 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, at=
t hnf bool] (c0 \\\n c1 \\ c1 =3D supported-attribute c0) X32",
+                "goal_text": "std.map\n [att fail bool, att doc string, at=
t primitive_class bool, \n  att primitive bool, att non_forgetful_inheritan=
ce bool, att hnf bool] (c0 \\\n c1 \\ c1 =3D 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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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 =3D supported-attribute c0)=
)) A3), \n (A3 =3D> parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map =
A1 (c0 \\ (c1 \\\n                                     (c1 =3D supported-at=
tribute c0))) A3), \n (A3 =3D> 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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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 =3D supported-attribute c0)=
)) A3), \n (A3 =3D> parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map =
A1 (c0 \\ (c1 \\\n                                     (c1 =3D supported-at=
tribute c0))) A3), \n (A3 =3D> 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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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 b=
ool, \n  att primitive bool, att non_forgetful_inheritance bool, att hnf bo=
ol] (c0 \\\n c1 \\ c1 =3D supported-attribute c0) X32",
+        "current_goal_text": "std.map\n [att fail bool, att doc string, at=
t primitive_class bool, \n  att primitive bool, att non_forgetful_inheritan=
ce bool, att hnf bool] (c0 \\\n c1 \\ c1 =3D 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, at=
t primitive bool, \n  att non_forgetful_inheritance bool, att hnf bool] (c0=
 \\ c1 \\\n c1 =3D supported-attribute c0) X34",
+                "goal_text": "std.map\n [att doc string, att primitive_cla=
ss bool, att primitive bool, \n  att non_forgetful_inheritance bool, att hn=
f bool] (c0 \\ c1 \\\n c1 =3D 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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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 =3D supported-attribute c0)=
)) A3), \n (A3 =3D> parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map =
A1 (c0 \\ (c1 \\\n                                     (c1 =3D supported-at=
tribute c0))) A3), \n (A3 =3D> 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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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 =3D supported-attribute c0)=
)) A3), \n (A3 =3D> parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map =
A1 (c0 \\ (c1 \\\n                                     (c1 =3D supported-at=
tribute c0))) A3), \n (A3 =3D> 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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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 primit=
ive bool, \n  att non_forgetful_inheritance bool, att hnf bool] (c0 \\ c1 \=
\\n c1 =3D supported-attribute c0) X34",
+        "current_goal_text": "std.map\n [att doc string, att primitive_cla=
ss bool, att primitive bool, \n  att non_forgetful_inheritance bool, att hn=
f bool] (c0 \\ c1 \\\n c1 =3D 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 =
=3D supported-attribute c0) X36",
+                "goal_text": "std.map\n [att primitive_class bool, att pri=
mitive bool, \n  att non_forgetful_inheritance bool, att hnf bool] (c0 \\ c=
1 \\\n c1 =3D 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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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 =3D supported-attribute c0)=
)) A3), \n (A3 =3D> parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map =
A1 (c0 \\ (c1 \\\n                                     (c1 =3D supported-at=
tribute c0))) A3), \n (A3 =3D> 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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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 =3D supported-attribute c0)=
)) A3), \n (A3 =3D> parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map =
A1 (c0 \\ (c1 \\\n                                     (c1 =3D supported-at=
tribute c0))) A3), \n (A3 =3D> 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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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  at=
t non_forgetful_inheritance bool, att hnf bool] (c0 \\ c1 \\\n c1 =3D suppo=
rted-attribute c0) X36",
+        "current_goal_text": "std.map\n [att primitive_class bool, att pri=
mitive bool, \n  att non_forgetful_inheritance bool, att hnf bool] (c0 \\ c=
1 \\\n c1 =3D 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 =3D supported-attribute (att primitive_class bool)",
+                "goal_text": "X37 =3D supported-attribute (att primitive_c=
lass bool)",
                 "goal_id": 1165
               },
               {
-                "goal_text":
-                  "std.map\n [att primitive bool, att non_forgetful_inheri=
tance bool, att hnf bool] (c0 \\\n c1 \\ c1 =3D supported-attribute c0) X38=
",
+                "goal_text": "std.map\n [att primitive bool, att non_forge=
tful_inheritance bool, att hnf bool] (c0 \\\n c1 \\ c1 =3D supported-attrib=
ute c0) X38",
                 "goal_id": 1166
               }
             ],
@@ -9961,8 +9464,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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 =3D supported-attribute c0)=
)) A3), \n (A3 =3D> parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map =
A1 (c0 \\ (c1 \\\n                                     (c1 =3D supported-at=
tribute c0))) A3), \n (A3 =3D> 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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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 =3D supported-attribute (att primitive_class bool)",
+        "current_goal_text": "X37 =3D supported-attribute (att primitive_c=
lass bool)",
         "current_goal_predicate": "=3D",
         "failed_attempts": [],
         "successful_attempts": [
@@ -10410,8 +9891,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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 =3D supported-attribute c0)=
)) A3), \n (A3 =3D> parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map =
A1 (c0 \\ (c1 \\\n                                     (c1 =3D supported-at=
tribute c0))) A3), \n (A3 =3D> 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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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 bo=
ol, att hnf bool] (c0 \\\n c1 \\ c1 =3D supported-attribute c0) X38",
+        "current_goal_text": "std.map\n [att primitive bool, att non_forge=
tful_inheritance bool, att hnf bool] (c0 \\\n c1 \\ c1 =3D supported-attrib=
ute 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 bo=
ol] (c0 \\ c1 \\\n c1 =3D supported-attribute c0) X40",
+                "goal_text": "std.map [att non_forgetful_inheritance bool,=
 att hnf bool] (c0 \\ c1 \\\n c1 =3D 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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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 =3D supported-attribute c0)=
)) A3), \n (A3 =3D> parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map =
A1 (c0 \\ (c1 \\\n                                     (c1 =3D supported-at=
tribute c0))) A3), \n (A3 =3D> 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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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 =3D supported-attribute c0)=
)) A3), \n (A3 =3D> parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map =
A1 (c0 \\ (c1 \\\n                                     (c1 =3D supported-at=
tribute c0))) A3), \n (A3 =3D> 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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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 =3D supported-attribute c0) X40",
+        "current_goal_text": "std.map [att non_forgetful_inheritance bool,=
 att hnf bool] (c0 \\ c1 \\\n c1 =3D 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 =3D supported-attribute (att non_forgetful_inherita=
nce bool)",
+                "goal_text": "X41 =3D supported-attribute (att non_forgetf=
ul_inheritance bool)",
                 "goal_id": 1169
               },
               {
-                "goal_text":
-                  "std.map [att hnf bool] (c0 \\ c1 \\ c1 =3D supported-at=
tribute c0) X42",
+                "goal_text": "std.map [att hnf bool] (c0 \\ c1 \\ c1 =3D s=
upported-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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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 =3D supported-attribute c0)=
)) A3), \n (A3 =3D> parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map =
A1 (c0 \\ (c1 \\\n                                     (c1 =3D supported-at=
tribute c0))) A3), \n (A3 =3D> 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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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 =3D supported-attribute (att non_forgetful_inheritance bool=
)",
+        "current_goal_text": "X41 =3D supported-attribute (att non_forgetf=
ul_inheritance bool)",
         "current_goal_predicate": "=3D",
         "failed_attempts": [],
         "successful_attempts": [
@@ -12332,8 +11717,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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 =3D supported-attribute c0)=
)) A3), \n (A3 =3D> parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map =
A1 (c0 \\ (c1 \\\n                                     (c1 =3D supported-at=
tribute c0))) A3), \n (A3 =3D> 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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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 =3D supported-attribute =
c0) X42",
+        "current_goal_text": "std.map [att hnf bool] (c0 \\ c1 \\ c1 =3D s=
upported-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 =3D supported-attribute c0) =
X44",
+                "goal_text": "std.map [] (c0 \\ c1 \\ c1 =3D supported-att=
ribute c0) X44",
                 "goal_id": 1172
               }
             ],
@@ -12843,8 +12202,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A3), (std.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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 =3D supported-attribute c0)=
)) A3), \n (A3 =3D> parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map =
A1 (c0 \\ (c1 \\\n                                     (c1 =3D supported-at=
tribute c0))) A3), \n (A3 =3D> 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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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 =3D supported-attribute c0)=
)) A3), \n (A3 =3D> parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map =
A1 (c0 \\ (c1 \\\n                                     (c1 =3D supported-at=
tribute c0))) A3), \n (A3 =3D> 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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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 =3D supported-attribute c0) X44",
+        "current_goal_text": "std.map [] (c0 \\ c1 \\ c1 =3D supported-att=
ribute 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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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.ma=
p A1 A2 A4).",
+                "rule_text": "(std.map [A0 | A1] A2 [A3 | A4]) :- (A2 A0 A=
3), (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 =3D supported-attribute c0)=
)) A3), \n (A3 =3D> parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map =
A1 (c0 \\ (c1 \\\n                                     (c1 =3D supported-at=
tribute c0))) A3), \n (A3 =3D> 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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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-attrib=
ute (att export bool), \n supported-attribute (att skip string), \n support=
ed-attribute (att local bool), supported-attribute (att fail bool), \n supp=
orted-attribute (att doc string), \n supported-attribute (att primitive_cla=
ss bool), \n supported-attribute (att primitive bool), \n supported-attribu=
te (att non_forgetful_inheritance bool), \n supported-attribute (att hnf bo=
ol)] =3D>\n parse-attributes.aux\n  [attribute elpi.loc \n    (leaf-loc Fil=
e \"(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 mathco=
mp.axiom string), \n supported-attribute (att short.type string), \n suppor=
ted-attribute (att short.pack string), \n supported-attribute (att infer at=
tmap), \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-at=
tribute (att hnf bool)] =3D>\n parse-attributes.aux\n  [attribute elpi.loc =
\n    (leaf-loc File \"(stdin)\", line 1, column 2, character 3:)]  X3",
         "current_goal_predicate": "=3D>",
         "failed_attempts": [],
         "successful_attempts": [
@@ -14371,8 +13656,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "parse-attributes.aux\n [attribute elpi.loc \n   (leaf-l=
oc 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 =3D supported-attribute c0)=
)) A3), \n (A3 =3D> parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map =
A1 (c0 \\ (c1 \\\n                                     (c1 =3D supported-at=
tribute c0))) A3), \n (A3 =3D> 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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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 =3D ) \n                                                    =
            (A5 =3D 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 (at=
t c0 string) :- !)) =3D>\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 =3D ) \n                                         =
                       (A5 =3D A0) \n                                      =
                          (A5 is\n                                         =
                         A3 ^ . ^ A0)), \n (supported-attribute (att A5 att=
map)), (!), \n (parse-attributes.aux A2 A3 A6), \n (pi (c0 \\ (supported-at=
tribute (att c0 string) :- !)) =3D>\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 =3D ) (A6 =3D 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 =3D )=
 (A6 =3D 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 =3D ) (A5 =3D A0) (A5 is A3 ^ . ^ A0)), \n (coq.=
valid-str-attribute A5 A1 A6 A7), \n (if (A7 =3D error A8) (coq.error A8) t=
rue), \n (if (A6 =3D some A9) (A4 =3D [get-option A5 A9 | A10]) (A4 =3D A10=
)), \n (parse-attributes.aux A2 A3 A10).",
+                "rule_text": "(parse-attributes.aux [attribute A0 (leaf-st=
r A1) | A2] A3 A4) :- (!), \n (if (A3 =3D ) (A5 =3D A0) (A5 is A3 ^ . ^ A0)=
), \n (coq.valid-str-attribute A5 A1 A6 A7), \n (if (A7 =3D error A8) (coq.=
error A8) true), \n (if (A6 =3D some A9) (A4 =3D [get-option A5 A9 | A10]) =
(A4 =3D 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 =3D ) (A5 =3D A0) (A5 is A3 ^ . ^ A0)), \n (coq.=
valid-loc-attribute A5 A1 A6), \n (if (A6 =3D error A7) (coq.error A7) true=
), (A4 =3D [get-option A5 A1 | A8]), \n (parse-attributes.aux A2 A3 A8).",
+                "rule_text": "(parse-attributes.aux [attribute A0 (leaf-lo=
c A1) | A2] A3 A4) :- (!), \n (if (A3 =3D ) (A5 =3D A0) (A5 is A3 ^ . ^ A0)=
), \n (coq.valid-loc-attribute A5 A1 A6), \n (if (A6 =3D error A7) (coq.err=
or A7) true), (A4 =3D [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] A=
3 A4) :- (if (A3 =3D ) \n                                                  =
              (A7 =3D 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) :- !)) =3D>\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 =3D ) \n                                       =
                         (A7 =3D A0) \n                                    =
                            (A7 is\n                                       =
                           A3 ^ . ^ A0)), \n (supported-attribute (att A7 a=
ttmap)), (!), \n (parse-attributes.aux A2 A3 A5), \n (pi (c0 \\ (supported-=
attribute (att c0 string) :- !)) =3D>\n   parse-attributes.aux A1  A6), (st=
d.append A5 [get-option A7 A6] A4).",
                   "rule_loc": [ "Context", 6 ]
                 }
               ],
@@ -14599,13 +13873,11 @@
             "siblings": [
               { "goal_text": "!", "goal_id": 1174 },
               {
-                "goal_text":
-                  "if ( =3D ) (X45 =3D elpi.loc) (X45 is  ^ . ^ elpi.loc)",
+                "goal_text": "if ( =3D ) (X45 =3D elpi.loc) (X45 is  ^ . ^=
 elpi.loc)",
                 "goal_id": 1175
               },
               {
-                "goal_text":
-                  "coq.valid-loc-attribute X45 File \"(stdin)\", line 1, c=
olumn 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 =3D [get-option X45 File \"(stdin)\", line 1, column=
 2, character 3: | X48]",
+                "goal_text": "X3 =3D [get-option X45 File \"(stdin)\", lin=
e 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 =3D ) \n                                                    =
            (A7 =3D 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 (at=
t c0 string) :- !)) =3D>\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 =3D ) \n                                         =
                       (A7 =3D A0) \n                                      =
                          (A7 is\n                                         =
                         A3 ^ . ^ A0)), \n (supported-attribute (att A7 att=
map)), (!), \n (parse-attributes.aux A2 A3 A5), \n (pi (c0 \\ (supported-at=
tribute (att c0 string) :- !)) =3D>\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 =3D supported-attribute c0)=
)) A3), \n (A3 =3D> parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map =
A1 (c0 \\ (c1 \\\n                                     (c1 =3D supported-at=
tribute c0))) A3), \n (A3 =3D> 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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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 ( =3D ) (X45 =3D elpi.loc) (X45 is  ^ . ^ elpi.loc)",
+        "current_goal_text": "if ( =3D ) (X45 =3D 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 =3D ) \n                                                    =
            (A7 =3D 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 (at=
t c0 string) :- !)) =3D>\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 =3D ) \n                                         =
                       (A7 =3D A0) \n                                      =
                          (A7 is\n                                         =
                         A3 ^ . ^ A0)), \n (supported-attribute (att A7 att=
map)), (!), \n (parse-attributes.aux A2 A3 A5), \n (pi (c0 \\ (supported-at=
tribute (att c0 string) :- !)) =3D>\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 =3D supported-attribute c0)=
)) A3), \n (A3 =3D> parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map =
A1 (c0 \\ (c1 \\\n                                     (c1 =3D supported-at=
tribute c0))) A3), \n (A3 =3D> 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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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 =3D ) \n                                                    =
            (A7 =3D 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 (at=
t c0 string) :- !)) =3D>\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 =3D ) \n                                         =
                       (A7 =3D A0) \n                                      =
                          (A7 is\n                                         =
                         A3 ^ . ^ A0)), \n (supported-attribute (att A7 att=
map)), (!), \n (parse-attributes.aux A2 A3 A5), \n (pi (c0 \\ (supported-at=
tribute (att c0 string) :- !)) =3D>\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 =3D supported-attribute c0)=
)) A3), \n (A3 =3D> parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map =
A1 (c0 \\ (c1 \\\n                                     (c1 =3D supported-at=
tribute c0))) A3), \n (A3 =3D> 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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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 ( =3D ) (X45 =3D elpi.loc) (X45 is  ^ . ^ elpi.loc)",
+              "goal_text": "if ( =3D ) (X45 =3D elpi.loc) (X45 is  ^ . ^ e=
lpi.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 =3D ) \n                                                    =
            (A7 =3D 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 (at=
t c0 string) :- !)) =3D>\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 =3D ) \n                                         =
                       (A7 =3D A0) \n                                      =
                          (A7 is\n                                         =
                         A3 ^ . ^ A0)), \n (supported-attribute (att A7 att=
map)), (!), \n (parse-attributes.aux A2 A3 A5), \n (pi (c0 \\ (supported-at=
tribute (att c0 string) :- !)) =3D>\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 =3D supported-attribute c0)=
)) A3), \n (A3 =3D> parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map =
A1 (c0 \\ (c1 \\\n                                     (c1 =3D supported-at=
tribute c0))) A3), \n (A3 =3D> 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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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, c=
olumn 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 (prim=
itive? A1 Loc.t) (A2 =3D ok) \n                                          ((=
std.any->string A1 A4 ,\n                                             calc\=
n                                              (Attribute  ^ A0 ^\n        =
                                         takes a loc, got  ^ A4) A5)\n     =
                                       , A2 =3D error A5)) \n              =
                          (if\n                                          (s=
upported-attribute\n                                            att-ignore-=
unknown) (A2 =3D ok) \n                                          (calc\n   =
                                         (Attribute  ^ A0 ^\n              =
                                 is not supported) A3 ,\n                  =
                          A2 =3D error A3))).",
+                  "rule_text": "(coq.valid-loc-attribute A0 A1 A2) :- (if =
(supported-attribute (att A0 loc)) \n                                      =
  (if (primitive? A1 Loc.t) (A2 =3D ok) \n                                 =
         ((std.any->string A1 A4 ,\n                                       =
      calc\n                                              (Attribute  ^ A0 =
^\n                                                 takes a loc, got  ^ A4)=
 A5)\n                                            , A2 =3D error A5)) \n   =
                                     (if\n                                 =
         (supported-attribute\n                                            =
att-ignore-unknown) (A2 =3D ok) \n                                         =
 (calc\n                                            (Attribute  ^ A0 ^\n   =
                                            is not supported) A3 ,\n       =
                                     A2 =3D error A3))).",
                   "rule_loc": [
                     "File",
                     {
@@ -15233,8 +14480,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "if (supported-attribute (att elpi.loc loc)) \n (if (pri=
mitive? File \"(stdin)\", line 1, column 2, character 3: Loc.t) \n   (X46 =
=3D ok) \n   ((std.any->string File \"(stdin)\", line 1, column 2, characte=
r 3: X49 ,\n      calc (Attribute  ^ elpi.loc ^  takes a loc, got  ^ X49) X=
50) ,\n     X46 =3D error X50)) \n (if (supported-attribute att-ignore-unkn=
own) (X46 =3D ok) \n   (calc (Attribute  ^ elpi.loc ^  is not supported) X5=
1 , X46 =3D 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 =3D 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 =3D error X50)) \n (if (supported-attribute att-i=
gnore-unknown) (X46 =3D ok) \n   (calc (Attribute  ^ elpi.loc ^  is not sup=
ported) X51 , X46 =3D error X51))",
                 "goal_id": 1183
               }
             ],
@@ -15247,8 +14493,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.valid-loc-attribute A0 A1 A2) :- (if (supported-at=
tribute (att A0 loc)) \n                                        (if (primit=
ive? A1 Loc.t) (A2 =3D ok) \n                                          ((st=
d.any->string A1 A4 ,\n                                             calc\n =
                                             (Attribute  ^ A0 ^\n          =
                                       takes a loc, got  ^ A4) A5)\n       =
                                     , A2 =3D error A5)) \n                =
                        (if\n                                          (sup=
ported-attribute\n                                            att-ignore-un=
known) (A2 =3D ok) \n                                          (calc\n     =
                                       (Attribute  ^ A0 ^\n                =
                               is not supported) A3 ,\n                    =
                        A2 =3D error A3))).",
+                "rule_text": "(coq.valid-loc-attribute A0 A1 A2) :- (if (s=
upported-attribute (att A0 loc)) \n                                        =
(if (primitive? A1 Loc.t) (A2 =3D ok) \n                                   =
       ((std.any->string A1 A4 ,\n                                         =
    calc\n                                              (Attribute  ^ A0 ^\=
n                                                 takes a loc, got  ^ A4) A=
5)\n                                            , A2 =3D error A5)) \n     =
                                   (if\n                                   =
       (supported-attribute\n                                            at=
t-ignore-unknown) (A2 =3D ok) \n                                          (=
calc\n                                            (Attribute  ^ A0 ^\n     =
                                          is not supported) A3 ,\n         =
                                   A2 =3D 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 =3D ) \n                                                    =
            (A7 =3D 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 (at=
t c0 string) :- !)) =3D>\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 =3D ) \n                                         =
                       (A7 =3D A0) \n                                      =
                          (A7 is\n                                         =
                         A3 ^ . ^ A0)), \n (supported-attribute (att A7 att=
map)), (!), \n (parse-attributes.aux A2 A3 A5), \n (pi (c0 \\ (supported-at=
tribute (att c0 string) :- !)) =3D>\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 =3D supported-attribute c0)=
)) A3), \n (A3 =3D> parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map =
A1 (c0 \\ (c1 \\\n                                     (c1 =3D supported-at=
tribute c0))) A3), \n (A3 =3D> 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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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 =3D 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 =3D error X50)) \n (if (supported-attribute att-ignore-unknown) (X46=
 =3D ok) \n   (calc (Attribute  ^ elpi.loc ^  is not supported) X51 , X46 =
=3D 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 =3D 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 =3D error X50)) \n (if (supported-attribute att-i=
gnore-unknown) (X46 =3D ok) \n   (calc (Attribute  ^ elpi.loc ^  is not sup=
ported) X51 , X46 =3D 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, char=
acter 3: Loc.t) \n (X46 =3D 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 =3D error X50)",
+                "goal_text": "if (primitive? File \"(stdin)\", line 1, col=
umn 2, character 3: Loc.t) \n (X46 =3D ok) \n ((std.any->string File \"(std=
in)\", line 1, column 2, character 3: X49 ,\n    calc (Attribute  ^ elpi.lo=
c ^  takes a loc, got  ^ X49) X50) ,\n   X46 =3D error X50)",
                 "goal_id": 1186
               }
             ],
@@ -15433,8 +14671,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.valid-loc-attribute A0 A1 A2) :- (if (supported-at=
tribute (att A0 loc)) \n                                        (if (primit=
ive? A1 Loc.t) (A2 =3D ok) \n                                          ((st=
d.any->string A1 A4 ,\n                                             calc\n =
                                             (Attribute  ^ A0 ^\n          =
                                       takes a loc, got  ^ A4) A5)\n       =
                                     , A2 =3D error A5)) \n                =
                        (if\n                                          (sup=
ported-attribute\n                                            att-ignore-un=
known) (A2 =3D ok) \n                                          (calc\n     =
                                       (Attribute  ^ A0 ^\n                =
                               is not supported) A3 ,\n                    =
                        A2 =3D error A3))).",
+                "rule_text": "(coq.valid-loc-attribute A0 A1 A2) :- (if (s=
upported-attribute (att A0 loc)) \n                                        =
(if (primitive? A1 Loc.t) (A2 =3D ok) \n                                   =
       ((std.any->string A1 A4 ,\n                                         =
    calc\n                                              (Attribute  ^ A0 ^\=
n                                                 takes a loc, got  ^ A4) A=
5)\n                                            , A2 =3D error A5)) \n     =
                                   (if\n                                   =
       (supported-attribute\n                                            at=
t-ignore-unknown) (A2 =3D ok) \n                                          (=
calc\n                                            (Attribute  ^ A0 ^\n     =
                                          is not supported) A3 ,\n         =
                                   A2 =3D 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 =3D ) \n                                                    =
            (A7 =3D 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 (at=
t c0 string) :- !)) =3D>\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 =3D ) \n                                         =
                       (A7 =3D A0) \n                                      =
                          (A7 is\n                                         =
                         A3 ^ . ^ A0)), \n (supported-attribute (att A7 att=
map)), (!), \n (parse-attributes.aux A2 A3 A5), \n (pi (c0 \\ (supported-at=
tribute (att c0 string) :- !)) =3D>\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 =3D supported-attribute c0)=
)) A3), \n (A3 =3D> parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map =
A1 (c0 \\ (c1 \\\n                                     (c1 =3D supported-at=
tribute c0))) A3), \n (A3 =3D> 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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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 str=
ing)) :- .",
                 "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 bo=
ol)) :- .",
                 "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 boo=
l)) :- .",
+                "rule_text": "(supported-attribute (att non_forgetful_inhe=
ritance 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-at=
tribute (att A0 loc)) \n                                        (if (primit=
ive? A1 Loc.t) (A2 =3D ok) \n                                          ((st=
d.any->string A1 A4 ,\n                                             calc\n =
                                             (Attribute  ^ A0 ^\n          =
                                       takes a loc, got  ^ A4) A5)\n       =
                                     , A2 =3D error A5)) \n                =
                        (if\n                                          (sup=
ported-attribute\n                                            att-ignore-un=
known) (A2 =3D ok) \n                                          (calc\n     =
                                       (Attribute  ^ A0 ^\n                =
                               is not supported) A3 ,\n                    =
                        A2 =3D error A3))).",
+                "rule_text": "(coq.valid-loc-attribute A0 A1 A2) :- (if (s=
upported-attribute (att A0 loc)) \n                                        =
(if (primitive? A1 Loc.t) (A2 =3D ok) \n                                   =
       ((std.any->string A1 A4 ,\n                                         =
    calc\n                                              (Attribute  ^ A0 ^\=
n                                                 takes a loc, got  ^ A4) A=
5)\n                                            , A2 =3D error A5)) \n     =
                                   (if\n                                   =
       (supported-attribute\n                                            at=
t-ignore-unknown) (A2 =3D ok) \n                                          (=
calc\n                                            (Attribute  ^ A0 ^\n     =
                                          is not supported) A3 ,\n         =
                                   A2 =3D 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 =3D ) \n                                                    =
            (A7 =3D 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 (at=
t c0 string) :- !)) =3D>\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 =3D ) \n                                         =
                       (A7 =3D A0) \n                                      =
                          (A7 is\n                                         =
                         A3 ^ . ^ A0)), \n (supported-attribute (att A7 att=
map)), (!), \n (parse-attributes.aux A2 A3 A5), \n (pi (c0 \\ (supported-at=
tribute (att c0 string) :- !)) =3D>\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 =3D supported-attribute c0)=
)) A3), \n (A3 =3D> parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map =
A1 (c0 \\ (c1 \\\n                                     (c1 =3D supported-at=
tribute c0))) A3), \n (A3 =3D> 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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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 (primi=
tive? File \"(stdin)\", line 1, column 2, character 3: Loc.t) \n   (X46 =3D=
 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 =3D error X50)) \n (if (supported-attribute att-ignore-unknown=
) (X46 =3D ok) \n   (calc (Attribute  ^ elpi.loc ^  is not supported) X51 ,=
 X46 =3D 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 =3D 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 =3D error X50)) \n (if (supported-attribute att-ign=
ore-unknown) (X46 =3D ok) \n   (calc (Attribute  ^ elpi.loc ^  is not suppo=
rted) X51 , X46 =3D 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 =3D ok) \n ((std.any->string File \"(stdin)\", line 1, colu=
mn 2, character 3: X49 ,\n    calc (Attribute  ^ elpi.loc ^  takes a loc, g=
ot  ^ X49) X50) ,\n   X46 =3D error X50)",
+        "current_goal_text": "if (primitive? File \"(stdin)\", line 1, col=
umn 2, character 3: Loc.t) \n (X46 =3D ok) \n ((std.any->string File \"(std=
in)\", line 1, column 2, character 3: X49 ,\n    calc (Attribute  ^ elpi.lo=
c ^  takes a loc, got  ^ X49) X50) ,\n   X46 =3D error X50)",
         "current_goal_predicate": "if",
         "failed_attempts": [],
         "successful_attempts": [
@@ -16072,8 +15287,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "primitive? File \"(stdin)\", line 1, column 2, characte=
r 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-at=
tribute (att A0 loc)) \n                                        (if (primit=
ive? A1 Loc.t) (A2 =3D ok) \n                                          ((st=
d.any->string A1 A4 ,\n                                             calc\n =
                                             (Attribute  ^ A0 ^\n          =
                                       takes a loc, got  ^ A4) A5)\n       =
                                     , A2 =3D error A5)) \n                =
                        (if\n                                          (sup=
ported-attribute\n                                            att-ignore-un=
known) (A2 =3D ok) \n                                          (calc\n     =
                                       (Attribute  ^ A0 ^\n                =
                               is not supported) A3 ,\n                    =
                        A2 =3D error A3))).",
+                "rule_text": "(coq.valid-loc-attribute A0 A1 A2) :- (if (s=
upported-attribute (att A0 loc)) \n                                        =
(if (primitive? A1 Loc.t) (A2 =3D ok) \n                                   =
       ((std.any->string A1 A4 ,\n                                         =
    calc\n                                              (Attribute  ^ A0 ^\=
n                                                 takes a loc, got  ^ A4) A=
5)\n                                            , A2 =3D error A5)) \n     =
                                   (if\n                                   =
       (supported-attribute\n                                            at=
t-ignore-unknown) (A2 =3D ok) \n                                          (=
calc\n                                            (Attribute  ^ A0 ^\n     =
                                          is not supported) A3 ,\n         =
                                   A2 =3D 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 =3D ) \n                                                    =
            (A7 =3D 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 (at=
t c0 string) :- !)) =3D>\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 =3D ) \n                                         =
                       (A7 =3D A0) \n                                      =
                          (A7 is\n                                         =
                         A3 ^ . ^ A0)), \n (supported-attribute (att A7 att=
map)), (!), \n (parse-attributes.aux A2 A3 A5), \n (pi (c0 \\ (supported-at=
tribute (att c0 string) :- !)) =3D>\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 =3D supported-attribute c0)=
)) A3), \n (A3 =3D> parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map =
A1 (c0 \\ (c1 \\\n                                     (c1 =3D supported-at=
tribute c0))) A3), \n (A3 =3D> 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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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-at=
tribute (att A0 loc)) \n                                        (if (primit=
ive? A1 Loc.t) (A2 =3D ok) \n                                          ((st=
d.any->string A1 A4 ,\n                                             calc\n =
                                             (Attribute  ^ A0 ^\n          =
                                       takes a loc, got  ^ A4) A5)\n       =
                                     , A2 =3D error A5)) \n                =
                        (if\n                                          (sup=
ported-attribute\n                                            att-ignore-un=
known) (A2 =3D ok) \n                                          (calc\n     =
                                       (Attribute  ^ A0 ^\n                =
                               is not supported) A3 ,\n                    =
                        A2 =3D error A3))).",
+                "rule_text": "(coq.valid-loc-attribute A0 A1 A2) :- (if (s=
upported-attribute (att A0 loc)) \n                                        =
(if (primitive? A1 Loc.t) (A2 =3D ok) \n                                   =
       ((std.any->string A1 A4 ,\n                                         =
    calc\n                                              (Attribute  ^ A0 ^\=
n                                                 takes a loc, got  ^ A4) A=
5)\n                                            , A2 =3D error A5)) \n     =
                                   (if\n                                   =
       (supported-attribute\n                                            at=
t-ignore-unknown) (A2 =3D ok) \n                                          (=
calc\n                                            (Attribute  ^ A0 ^\n     =
                                          is not supported) A3 ,\n         =
                                   A2 =3D 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 =3D ) \n                                                    =
            (A7 =3D 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 (at=
t c0 string) :- !)) =3D>\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 =3D ) \n                                         =
                       (A7 =3D A0) \n                                      =
                          (A7 is\n                                         =
                         A3 ^ . ^ A0)), \n (supported-attribute (att A7 att=
map)), (!), \n (parse-attributes.aux A2 A3 A5), \n (pi (c0 \\ (supported-at=
tribute (att c0 string) :- !)) =3D>\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 =3D supported-attribute c0)=
)) A3), \n (A3 =3D> parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map =
A1 (c0 \\ (c1 \\\n                                     (c1 =3D supported-at=
tribute c0))) A3), \n (A3 =3D> 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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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: (ctyp=
e 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-at=
tribute (att A0 loc)) \n                                        (if (primit=
ive? A1 Loc.t) (A2 =3D ok) \n                                          ((st=
d.any->string A1 A4 ,\n                                             calc\n =
                                             (Attribute  ^ A0 ^\n          =
                                       takes a loc, got  ^ A4) A5)\n       =
                                     , A2 =3D error A5)) \n                =
                        (if\n                                          (sup=
ported-attribute\n                                            att-ignore-un=
known) (A2 =3D ok) \n                                          (calc\n     =
                                       (Attribute  ^ A0 ^\n                =
                               is not supported) A3 ,\n                    =
                        A2 =3D error A3))).",
+                "rule_text": "(coq.valid-loc-attribute A0 A1 A2) :- (if (s=
upported-attribute (att A0 loc)) \n                                        =
(if (primitive? A1 Loc.t) (A2 =3D ok) \n                                   =
       ((std.any->string A1 A4 ,\n                                         =
    calc\n                                              (Attribute  ^ A0 ^\=
n                                                 takes a loc, got  ^ A4) A=
5)\n                                            , A2 =3D error A5)) \n     =
                                   (if\n                                   =
       (supported-attribute\n                                            at=
t-ignore-unknown) (A2 =3D ok) \n                                          (=
calc\n                                            (Attribute  ^ A0 ^\n     =
                                          is not supported) A3 ,\n         =
                                   A2 =3D 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 =3D ) \n                                                    =
            (A7 =3D 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 (at=
t c0 string) :- !)) =3D>\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 =3D ) \n                                         =
                       (A7 =3D A0) \n                                      =
                          (A7 is\n                                         =
                         A3 ^ . ^ A0)), \n (supported-attribute (att A7 att=
map)), (!), \n (parse-attributes.aux A2 A3 A5), \n (pi (c0 \\ (supported-at=
tribute (att c0 string) :- !)) =3D>\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 =3D supported-attribute c0)=
)) A3), \n (A3 =3D> parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map =
A1 (c0 \\ (c1 \\\n                                     (c1 =3D supported-at=
tribute c0))) A3), \n (A3 =3D> 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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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-at=
tribute (att A0 loc)) \n                                        (if (primit=
ive? A1 Loc.t) (A2 =3D ok) \n                                          ((st=
d.any->string A1 A4 ,\n                                             calc\n =
                                             (Attribute  ^ A0 ^\n          =
                                       takes a loc, got  ^ A4) A5)\n       =
                                     , A2 =3D error A5)) \n                =
                        (if\n                                          (sup=
ported-attribute\n                                            att-ignore-un=
known) (A2 =3D ok) \n                                          (calc\n     =
                                       (Attribute  ^ A0 ^\n                =
                               is not supported) A3 ,\n                    =
                        A2 =3D error A3))).",
+                "rule_text": "(coq.valid-loc-attribute A0 A1 A2) :- (if (s=
upported-attribute (att A0 loc)) \n                                        =
(if (primitive? A1 Loc.t) (A2 =3D ok) \n                                   =
       ((std.any->string A1 A4 ,\n                                         =
    calc\n                                              (Attribute  ^ A0 ^\=
n                                                 takes a loc, got  ^ A4) A=
5)\n                                            , A2 =3D error A5)) \n     =
                                   (if\n                                   =
       (supported-attribute\n                                            at=
t-ignore-unknown) (A2 =3D ok) \n                                          (=
calc\n                                            (Attribute  ^ A0 ^\n     =
                                          is not supported) A3 ,\n         =
                                   A2 =3D 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 =3D ) \n                                                    =
            (A7 =3D 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 (at=
t c0 string) :- !)) =3D>\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 =3D ) \n                                         =
                       (A7 =3D A0) \n                                      =
                          (A7 is\n                                         =
                         A3 ^ . ^ A0)), \n (supported-attribute (att A7 att=
map)), (!), \n (parse-attributes.aux A2 A3 A5), \n (pi (c0 \\ (supported-at=
tribute (att c0 string) :- !)) =3D>\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 =3D supported-attribute c0)=
)) A3), \n (A3 =3D> parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map =
A1 (c0 \\ (c1 \\\n                                     (c1 =3D supported-at=
tribute c0))) A3), \n (A3 =3D> 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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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, charac=
ter 3: Loc.t) \n (X46 =3D 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 =3D error X50)",
+              "goal_text": "if (primitive? File \"(stdin)\", line 1, colum=
n 2, character 3: Loc.t) \n (X46 =3D 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 =3D error X50)",
               "goal_id": 1186
             },
             "cut_branch": {
@@ -16961,8 +16143,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(coq.valid-loc-attribute A0 A1 A2) :- (if (supported-at=
tribute (att A0 loc)) \n                                        (if (primit=
ive? A1 Loc.t) (A2 =3D ok) \n                                          ((st=
d.any->string A1 A4 ,\n                                             calc\n =
                                             (Attribute  ^ A0 ^\n          =
                                       takes a loc, got  ^ A4) A5)\n       =
                                     , A2 =3D error A5)) \n                =
                        (if\n                                          (sup=
ported-attribute\n                                            att-ignore-un=
known) (A2 =3D ok) \n                                          (calc\n     =
                                       (Attribute  ^ A0 ^\n                =
                               is not supported) A3 ,\n                    =
                        A2 =3D error A3))).",
+                "rule_text": "(coq.valid-loc-attribute A0 A1 A2) :- (if (s=
upported-attribute (att A0 loc)) \n                                        =
(if (primitive? A1 Loc.t) (A2 =3D ok) \n                                   =
       ((std.any->string A1 A4 ,\n                                         =
    calc\n                                              (Attribute  ^ A0 ^\=
n                                                 takes a loc, got  ^ A4) A=
5)\n                                            , A2 =3D error A5)) \n     =
                                   (if\n                                   =
       (supported-attribute\n                                            at=
t-ignore-unknown) (A2 =3D ok) \n                                          (=
calc\n                                            (Attribute  ^ A0 ^\n     =
                                          is not supported) A3 ,\n         =
                                   A2 =3D 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 =3D ) \n                                                    =
            (A7 =3D 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 (at=
t c0 string) :- !)) =3D>\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 =3D ) \n                                         =
                       (A7 =3D A0) \n                                      =
                          (A7 is\n                                         =
                         A3 ^ . ^ A0)), \n (supported-attribute (att A7 att=
map)), (!), \n (parse-attributes.aux A2 A3 A5), \n (pi (c0 \\ (supported-at=
tribute (att c0 string) :- !)) =3D>\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 =3D supported-attribute c0)=
)) A3), \n (A3 =3D> parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map =
A1 (c0 \\ (c1 \\\n                                     (c1 =3D supported-at=
tribute c0))) A3), \n (A3 =3D> 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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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 =3D ) \n                                                    =
            (A7 =3D 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 (at=
t c0 string) :- !)) =3D>\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 =3D ) \n                                         =
                       (A7 =3D A0) \n                                      =
                          (A7 is\n                                         =
                         A3 ^ . ^ A0)), \n (supported-attribute (att A7 att=
map)), (!), \n (parse-attributes.aux A2 A3 A5), \n (pi (c0 \\ (supported-at=
tribute (att c0 string) :- !)) =3D>\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 =3D supported-attribute c0)=
)) A3), \n (A3 =3D> parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map =
A1 (c0 \\ (c1 \\\n                                     (c1 =3D supported-at=
tribute c0))) A3), \n (A3 =3D> 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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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 =3D ) \n                                                    =
            (A7 =3D 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 (at=
t c0 string) :- !)) =3D>\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 =3D ) \n                                         =
                       (A7 =3D A0) \n                                      =
                          (A7 is\n                                         =
                         A3 ^ . ^ A0)), \n (supported-attribute (att A7 att=
map)), (!), \n (parse-attributes.aux A2 A3 A5), \n (pi (c0 \\ (supported-at=
tribute (att c0 string) :- !)) =3D>\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 =3D supported-attribute c0)=
)) A3), \n (A3 =3D> parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map =
A1 (c0 \\ (c1 \\\n                                     (c1 =3D supported-at=
tribute c0))) A3), \n (A3 =3D> 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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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 =3D ) \n                                                    =
            (A7 =3D 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 (at=
t c0 string) :- !)) =3D>\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 =3D ) \n                                         =
                       (A7 =3D A0) \n                                      =
                          (A7 is\n                                         =
                         A3 ^ . ^ A0)), \n (supported-attribute (att A7 att=
map)), (!), \n (parse-attributes.aux A2 A3 A5), \n (pi (c0 \\ (supported-at=
tribute (att c0 string) :- !)) =3D>\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 =3D supported-attribute c0)=
)) A3), \n (A3 =3D> parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map =
A1 (c0 \\ (c1 \\\n                                     (c1 =3D supported-at=
tribute c0))) A3), \n (A3 =3D> 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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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 =3D ) \n                                                    =
            (A7 =3D 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 (at=
t c0 string) :- !)) =3D>\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 =3D ) \n                                         =
                       (A7 =3D A0) \n                                      =
                          (A7 is\n                                         =
                         A3 ^ . ^ A0)), \n (supported-attribute (att A7 att=
map)), (!), \n (parse-attributes.aux A2 A3 A5), \n (pi (c0 \\ (supported-at=
tribute (att c0 string) :- !)) =3D>\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 =3D supported-attribute c0)=
)) A3), \n (A3 =3D> parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map =
A1 (c0 \\ (c1 \\\n                                     (c1 =3D supported-at=
tribute c0))) A3), \n (A3 =3D> 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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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 =3D\n [get-option elpi.loc File \"(stdin)\", line 1, column =
2, character 3: | X48]",
+        "current_goal_text": "X3 =3D\n [get-option elpi.loc File \"(stdin)=
\", line 1, column 2, character 3: | X48]",
         "current_goal_predicate": "=3D",
         "failed_attempts": [],
         "successful_attempts": [
@@ -17712,8 +16867,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(parse-attributes.aux [attribute A0 (node A1) | A2] A3 =
A4) :- (if (A3 =3D ) \n                                                    =
            (A7 =3D 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 (at=
t c0 string) :- !)) =3D>\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 =3D ) \n                                         =
                       (A7 =3D A0) \n                                      =
                          (A7 is\n                                         =
                         A3 ^ . ^ A0)), \n (supported-attribute (att A7 att=
map)), (!), \n (parse-attributes.aux A2 A3 A5), \n (pi (c0 \\ (supported-at=
tribute (att c0 string) :- !)) =3D>\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 =3D supported-attribute c0)=
)) A3), \n (A3 =3D> parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map =
A1 (c0 \\ (c1 \\\n                                     (c1 =3D supported-at=
tribute c0))) A3), \n (A3 =3D> 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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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 =3D ) \n                                                    =
            (A7 =3D 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 (at=
t c0 string) :- !)) =3D>\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 =3D ) \n                                         =
                       (A7 =3D A0) \n                                      =
                          (A7 is\n                                         =
                         A3 ^ . ^ A0)), \n (supported-attribute (att A7 att=
map)), (!), \n (parse-attributes.aux A2 A3 A5), \n (pi (c0 \\ (supported-at=
tribute (att c0 string) :- !)) =3D>\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 =3D supported-attribute c0)=
)) A3), \n (A3 =3D> parse-attributes.aux A0  A2), (!).",
+                "rule_text": "(coq.parse-attributes A0 A1 A2) :- (std.map =
A1 (c0 \\ (c1 \\\n                                     (c1 =3D supported-at=
tribute c0))) A3), \n (A3 =3D> 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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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, charac=
ter 3:] =3D>\n (save-docstring ,\n   with-logging\n    (instance.declare-co=
nst _ \n      (app\n        [global (const =C2=ABIsSelfA'.phant_Build=C2=BB=
), global (indt =C2=ABnat=C2=BB), \n         global (indc =C2=ABO=C2=BB), f=
un `x` X0 c0 \\ c0]) (arity X1) _))",
+        "current_goal_text": "[get-option elpi.loc File \"(stdin)\", line =
1, column 2, character 3:] =3D>\n (save-docstring ,\n   with-logging\n    (=
instance.declare-const _ \n      (app\n        [global (const =C2=ABIsSelfA=
'.phant_Build=C2=BB), global (indt =C2=ABnat=C2=BB), \n         global (ind=
c =C2=ABO=C2=BB), fun `x` X0 c0 \\ c0]) (arity X1) _))",
         "current_goal_predicate": "=3D>",
         "failed_attempts": [],
         "successful_attempts": [
@@ -17980,8 +17124,7 @@
             },
             "siblings": [
               {
-                "goal_text":
-                  "save-docstring ,\n with-logging\n  (instance.declare-co=
nst _ \n    (app\n      [global (const =C2=ABIsSelfA'.phant_Build=C2=BB), g=
lobal (indt =C2=ABnat=C2=BB), \n       global (indc =C2=ABO=C2=BB), fun `x`=
 X0 c0 \\ c0]) (arity X1) _)",
+                "goal_text": "save-docstring ,\n with-logging\n  (instance=
.declare-const _ \n    (app\n      [global (const =C2=ABIsSelfA'.phant_Buil=
d=C2=BB), global (indt =C2=ABnat=C2=BB), \n       global (indc =C2=ABO=C2=
=BB), 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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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 =C2=ABIsSelfA'.phant_Build=C2=BB), global (i=
ndt =C2=ABnat=C2=BB), \n       global (indc =C2=ABO=C2=BB), fun `x` X0 c0 \=
\ c0]) (arity X1) _)",
+        "current_goal_text": "save-docstring ,\n with-logging\n  (instance=
.declare-const _ \n    (app\n      [global (const =C2=ABIsSelfA'.phant_Buil=
d=C2=BB), global (indt =C2=ABnat=C2=BB), \n       global (indc =C2=ABO=C2=
=BB), 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 =C2=ABIsSelfA'.phant_Build=C2=BB), global (indt =C2=ABnat=
=C2=BB), \n      global (indc =C2=ABO=C2=BB), fun `x` X0 c0 \\ c0]) (arity =
X1) _)",
+                "goal_text": "with-logging\n (instance.declare-const _ \n =
  (app\n     [global (const =C2=ABIsSelfA'.phant_Build=C2=BB), global (indt=
 =C2=ABnat=C2=BB), \n      global (indc =C2=ABO=C2=BB), 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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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-o=
ption 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 (a=
cc-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-opt=
ion doc A1) \n                    (acc-clause _ (docstring A0 A1)) true).",
+                "rule_text": "save-docstring :- (if (get-option elpi.loc A=
0 , get-option doc A1) \n                    (acc-clause _ (docstring A0 A1=
)) true).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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-claus=
e _ (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-opt=
ion doc A1) \n                    (acc-clause _ (docstring A0 A1)) true).",
+                "rule_text": "save-docstring :- (if (get-option elpi.loc A=
0 , get-option doc A1) \n                    (acc-clause _ (docstring A0 A1=
)) true).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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-opt=
ion doc A1) \n                    (acc-clause _ (docstring A0 A1)) true).",
+                "rule_text": "save-docstring :- (if (get-option elpi.loc A=
0 , get-option doc A1) \n                    (acc-clause _ (docstring A0 A1=
)) true).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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)\", lin=
e 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-opt=
ion doc A1) \n                    (acc-clause _ (docstring A0 A1)) true).",
+                "rule_text": "save-docstring :- (if (get-option elpi.loc A=
0 , get-option doc A1) \n                    (acc-clause _ (docstring A0 A1=
)) true).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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-opt=
ion doc A1) \n                    (acc-clause _ (docstring A0 A1)) true).",
+                "rule_text": "save-docstring :- (if (get-option elpi.loc A=
0 , get-option doc A1) \n                    (acc-clause _ (docstring A0 A1=
)) true).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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-claus=
e _ (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-opt=
ion doc A1) \n                    (acc-clause _ (docstring A0 A1)) true).",
+                "rule_text": "save-docstring :- (if (get-option elpi.loc A=
0 , get-option doc A1) \n                    (acc-clause _ (docstring A0 A1=
)) true).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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-opt=
ion doc A1) \n                    (acc-clause _ (docstring A0 A1)) true).",
+                "rule_text": "save-docstring :- (if (get-option elpi.loc A=
0 , get-option doc A1) \n                    (acc-clause _ (docstring A0 A1=
)) true).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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     [globa=
l (const =C2=ABIsSelfA'.phant_Build=C2=BB), global (indt =C2=ABnat=C2=BB), =
\n      global (indc =C2=ABO=C2=BB), fun `x` X0 c0 \\ c0]) (arity X1) _)",
+        "current_goal_text": "with-logging\n (instance.declare-const _ \n =
  (app\n     [global (const =C2=ABIsSelfA'.phant_Build=C2=BB), global (indt=
 =C2=ABnat=C2=BB), \n      global (indc =C2=ABO=C2=BB), 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 =
=3D tt ;\n                       get-option elpi.hb.log.raw _ , A1 =3D 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.conca=
t \n [, HIERARCHY BUILDER PATCH v1, A4, ] A7), \n (output A6 A7), (close_ou=
t A6), (log.private.logger A8 A1 =3D> A0), \n (log.private.logger-close A8)=
, (std.intersperse coq.pp.spc A8 A9), \n (coq.pp->string (coq.pp.box (coq.p=
p.v 0) A9) A10), (open_append A5 A11), \n (output A11 A10), (close_out A11)=
.",
+                  "rule_text": "(with-logging A0) :- (get-option elpi.hb.l=
og _ , A1 =3D tt ;\n                       get-option elpi.hb.log.raw _ , A=
1 =3D 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.st=
ring.concat \n [, HIERARCHY BUILDER PATCH v1, A4, ] A7), \n (output A6 A7),=
 (close_out A6), (log.private.logger A8 A1 =3D> 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), (clos=
e_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 =3D tt ; get-option elpi=
.hb.log.raw _ , X54 =3D ff",
+                "goal_text": "get-option elpi.hb.log _ , X54 =3D tt ; get-=
option elpi.hb.log.raw _ , X54 =3D 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 PA=
TCH 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 =3D>\n instance.declare-cons=
t _ \n  (app\n    [global (const =C2=ABIsSelfA'.phant_Build=C2=BB), global =
(indt =C2=ABnat=C2=BB), \n     global (indc =C2=ABO=C2=BB), fun `x` X0 c0 \=
\ c0]) (arity X1) _",
+                "goal_text": "log.private.logger X61 X54 =3D>\n instance.d=
eclare-const _ \n  (app\n    [global (const =C2=ABIsSelfA'.phant_Build=C2=
=BB), global (indt =C2=ABnat=C2=BB), \n     global (indc =C2=ABO=C2=BB), fu=
n `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 =3D=
 tt ;\n                       get-option elpi.hb.log.raw _ , A1 =3D ff), (!=
), \n (get-option elpi.loc A2), (loc.fields A2 A3 _ _ _ _), \n (std.any->st=
ring 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 A=
6), (log.private.logger A8 A1 =3D> 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 =3D tt ;\n                       get-option elpi.hb.log.raw _ , A1 =
=3D 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.stri=
ng.concat \n [, HIERARCHY BUILDER PATCH v1, A4, ] A7), \n (output A6 A7), (=
close_out A6), (log.private.logger A8 A1 =3D> A0), \n (log.private.logger-c=
lose A8), (std.intersperse coq.pp.spc A8 A9), \n (coq.pp->string (coq.pp.bo=
x (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/lo=
g.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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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 =3D tt ; get-option elpi.hb.log.=
raw _ , X54 =3D ff",
+        "current_goal_text": "get-option elpi.hb.log _ , X54 =3D tt ; get-=
option elpi.hb.log.raw _ , X54 =3D 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 =3D=
 tt ;\n                       get-option elpi.hb.log.raw _ , A1 =3D ff), (!=
), \n (get-option elpi.loc A2), (loc.fields A2 A3 _ _ _ _), \n (std.any->st=
ring 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 A=
6), (log.private.logger A8 A1 =3D> 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 =3D tt ;\n                       get-option elpi.hb.log.raw _ , A1 =
=3D 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.stri=
ng.concat \n [, HIERARCHY BUILDER PATCH v1, A4, ] A7), \n (output A6 A7), (=
close_out A6), (log.private.logger A8 A1 =3D> A0), \n (log.private.logger-c=
lose A8), (std.intersperse coq.pp.spc A8 A9), \n (coq.pp->string (coq.pp.bo=
x (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/lo=
g.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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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 =3D=
 tt ;\n                       get-option elpi.hb.log.raw _ , A1 =3D ff), (!=
), \n (get-option elpi.loc A2), (loc.fields A2 A3 _ _ _ _), \n (std.any->st=
ring 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 A=
6), (log.private.logger A8 A1 =3D> 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 =3D tt ;\n                       get-option elpi.hb.log.raw _ , A1 =
=3D 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.stri=
ng.concat \n [, HIERARCHY BUILDER PATCH v1, A4, ] A7), \n (output A6 A7), (=
close_out A6), (log.private.logger A8 A1 =3D> A0), \n (log.private.logger-c=
lose A8), (std.intersperse coq.pp.spc A8 A9), \n (coq.pp->string (coq.pp.bo=
x (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/lo=
g.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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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 =3D=
 tt ;\n                       get-option elpi.hb.log.raw _ , A1 =3D ff), (!=
), \n (get-option elpi.loc A2), (loc.fields A2 A3 _ _ _ _), \n (std.any->st=
ring 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 A=
6), (log.private.logger A8 A1 =3D> 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 =3D tt ;\n                       get-option elpi.hb.log.raw _ , A1 =
=3D 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.stri=
ng.concat \n [, HIERARCHY BUILDER PATCH v1, A4, ] A7), \n (output A6 A7), (=
close_out A6), (log.private.logger A8 A1 =3D> A0), \n (log.private.logger-c=
lose A8), (std.intersperse coq.pp.spc A8 A9), \n (coq.pp->string (coq.pp.bo=
x (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/lo=
g.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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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 =3D tt ; get-option elpi.hb.log.=
raw _ , X54 =3D ff",
+        "current_goal_text": "get-option elpi.hb.log _ , X54 =3D tt ; get-=
option elpi.hb.log.raw _ , X54 =3D 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 =3D=
 tt ;\n                       get-option elpi.hb.log.raw _ , A1 =3D ff), (!=
), \n (get-option elpi.loc A2), (loc.fields A2 A3 _ _ _ _), \n (std.any->st=
ring 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 A=
6), (log.private.logger A8 A1 =3D> 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 =3D tt ;\n                       get-option elpi.hb.log.raw _ , A1 =
=3D 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.stri=
ng.concat \n [, HIERARCHY BUILDER PATCH v1, A4, ] A7), \n (output A6 A7), (=
close_out A6), (log.private.logger A8 A1 =3D> A0), \n (log.private.logger-c=
lose A8), (std.intersperse coq.pp.spc A8 A9), \n (coq.pp->string (coq.pp.bo=
x (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/lo=
g.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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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 =3D=
 tt ;\n                       get-option elpi.hb.log.raw _ , A1 =3D ff), (!=
), \n (get-option elpi.loc A2), (loc.fields A2 A3 _ _ _ _), \n (std.any->st=
ring 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 A=
6), (log.private.logger A8 A1 =3D> 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 =3D tt ;\n                       get-option elpi.hb.log.raw _ , A1 =
=3D 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.stri=
ng.concat \n [, HIERARCHY BUILDER PATCH v1, A4, ] A7), \n (output A6 A7), (=
close_out A6), (log.private.logger A8 A1 =3D> A0), \n (log.private.logger-c=
lose A8), (std.intersperse coq.pp.spc A8 A9), \n (coq.pp->string (coq.pp.bo=
x (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/lo=
g.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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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 =3D=
 tt ;\n                       get-option elpi.hb.log.raw _ , A1 =3D ff), (!=
), \n (get-option elpi.loc A2), (loc.fields A2 A3 _ _ _ _), \n (std.any->st=
ring 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 A=
6), (log.private.logger A8 A1 =3D> 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 =3D tt ;\n                       get-option elpi.hb.log.raw _ , A1 =
=3D 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.stri=
ng.concat \n [, HIERARCHY BUILDER PATCH v1, A4, ] A7), \n (output A6 A7), (=
close_out A6), (log.private.logger A8 A1 =3D> A0), \n (log.private.logger-c=
lose A8), (std.intersperse coq.pp.spc A8 A9), \n (coq.pp->string (coq.pp.bo=
x (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/lo=
g.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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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     [globa=
l (const =C2=ABIsSelfA'.phant_Build=C2=BB), global (indt =C2=ABnat=C2=BB), =
\n      global (indc =C2=ABO=C2=BB), fun `x` X0 c0 \\ c0]) (arity X1) _)",
+        "current_goal_text": "with-logging\n (instance.declare-const _ \n =
  (app\n     [global (const =C2=ABIsSelfA'.phant_Build=C2=BB), global (indt=
 =C2=ABnat=C2=BB), \n      global (indc =C2=ABO=C2=BB), 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 =3D tt ;=
\n                       get-option log.raw tt , A1 =3D ff), (!), \n (log.p=
rivate.logger A2 A1 =3D> A0), (log.private.logger-close A2), \n (std.inters=
perse 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 =3D tt ;\n                       get-option log.raw tt , A1 =3D ff), (!)=
, \n (log.private.logger A2 A1 =3D> 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 =3D tt ; get-option log.raw tt =
, X65 =3D ff",
+                "goal_text": "get-option log tt , X65 =3D tt ; get-option =
log.raw tt , X65 =3D ff",
                 "goal_id": 1229
               },
               { "goal_text": "!", "goal_id": 1230 },
               {
-                "goal_text":
-                  "log.private.logger X66 X65 =3D>\n instance.declare-cons=
t _ \n  (app\n    [global (const =C2=ABIsSelfA'.phant_Build=C2=BB), global =
(indt =C2=ABnat=C2=BB), \n     global (indc =C2=ABO=C2=BB), fun `x` X0 c0 \=
\ c0]) (arity X1) _",
+                "goal_text": "log.private.logger X66 X65 =3D>\n instance.d=
eclare-const _ \n  (app\n    [global (const =C2=ABIsSelfA'.phant_Build=C2=
=BB), global (indt =C2=ABnat=C2=BB), \n     global (indc =C2=ABO=C2=BB), fu=
n `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 =3D tt ;\n=
                       get-option log.raw tt , A1 =3D ff), (!), \n (log.pri=
vate.logger A2 A1 =3D> A0), (log.private.logger-close A2), \n (std.interspe=
rse 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=
 =3D tt ;\n                       get-option log.raw tt , A1 =3D ff), (!), =
\n (log.private.logger A2 A1 =3D> A0), (log.private.logger-close A2), \n (s=
td.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/lo=
g.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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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 =3D tt ; get-option log.raw tt , X65 =
=3D ff",
+        "current_goal_text": "get-option log tt , X65 =3D tt ; get-option =
log.raw tt , X65 =3D ff",
         "current_goal_predicate": ";",
         "failed_attempts": [],
         "successful_attempts": [
@@ -20291,13 +19328,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-logging A0) :- (get-option log tt , A1 =3D tt ;\n=
                       get-option log.raw tt , A1 =3D ff), (!), \n (log.pri=
vate.logger A2 A1 =3D> A0), (log.private.logger-close A2), \n (std.interspe=
rse 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=
 =3D tt ;\n                       get-option log.raw tt , A1 =3D ff), (!), =
\n (log.private.logger A2 A1 =3D> A0), (log.private.logger-close A2), \n (s=
td.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/lo=
g.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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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 =3D tt ;\n=
                       get-option log.raw tt , A1 =3D ff), (!), \n (log.pri=
vate.logger A2 A1 =3D> A0), (log.private.logger-close A2), \n (std.interspe=
rse 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=
 =3D tt ;\n                       get-option log.raw tt , A1 =3D ff), (!), =
\n (log.private.logger A2 A1 =3D> A0), (log.private.logger-close A2), \n (s=
td.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/lo=
g.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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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 =3D tt ;\n=
                       get-option log.raw tt , A1 =3D ff), (!), \n (log.pri=
vate.logger A2 A1 =3D> A0), (log.private.logger-close A2), \n (std.interspe=
rse 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=
 =3D tt ;\n                       get-option log.raw tt , A1 =3D ff), (!), =
\n (log.private.logger A2 A1 =3D> A0), (log.private.logger-close A2), \n (s=
td.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/lo=
g.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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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 =3D tt ; get-option log.raw tt , X65 =
=3D ff",
+        "current_goal_text": "get-option log tt , X65 =3D tt ; get-option =
log.raw tt , X65 =3D ff",
         "current_goal_predicate": ";",
         "failed_attempts": [],
         "successful_attempts": [
@@ -20686,13 +19707,11 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(with-logging A0) :- (get-option log tt , A1 =3D tt ;\n=
                       get-option log.raw tt , A1 =3D ff), (!), \n (log.pri=
vate.logger A2 A1 =3D> A0), (log.private.logger-close A2), \n (std.interspe=
rse 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=
 =3D tt ;\n                       get-option log.raw tt , A1 =3D ff), (!), =
\n (log.private.logger A2 A1 =3D> A0), (log.private.logger-close A2), \n (s=
td.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/lo=
g.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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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 =3D tt ;\n=
                       get-option log.raw tt , A1 =3D ff), (!), \n (log.pri=
vate.logger A2 A1 =3D> A0), (log.private.logger-close A2), \n (std.interspe=
rse 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=
 =3D tt ;\n                       get-option log.raw tt , A1 =3D ff), (!), =
\n (log.private.logger A2 A1 =3D> A0), (log.private.logger-close A2), \n (s=
td.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/lo=
g.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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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 =3D tt ;\n=
                       get-option log.raw tt , A1 =3D ff), (!), \n (log.pri=
vate.logger A2 A1 =3D> A0), (log.private.logger-close A2), \n (std.interspe=
rse 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=
 =3D tt ;\n                       get-option log.raw tt , A1 =3D ff), (!), =
\n (log.private.logger A2 A1 =3D> A0), (log.private.logger-close A2), \n (s=
td.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/lo=
g.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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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     [globa=
l (const =C2=ABIsSelfA'.phant_Build=C2=BB), global (indt =C2=ABnat=C2=BB), =
\n      global (indc =C2=ABO=C2=BB), fun `x` X0 c0 \\ c0]) (arity X1) _)",
+        "current_goal_text": "with-logging\n (instance.declare-const _ \n =
  (app\n     [global (const =C2=ABIsSelfA'.phant_Build=C2=BB), global (indt=
 =C2=ABnat=C2=BB), \n      global (indc =C2=ABO=C2=BB), 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 =C2=
=ABIsSelfA'.phant_Build=C2=BB), global (indt =C2=ABnat=C2=BB), \n    global=
 (indc =C2=ABO=C2=BB), fun `x` X0 c0 \\ c0]) (arity X1) _",
+                "goal_text": "instance.declare-const _ \n (app\n   [global=
 (const =C2=ABIsSelfA'.phant_Build=C2=BB), global (indt =C2=ABnat=C2=BB), \=
n    global (indc =C2=ABO=C2=BB), 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/lo=
g.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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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 =C2=ABIsSel=
fA'.phant_Build=C2=BB), global (indt =C2=ABnat=C2=BB), \n    global (indc =
=C2=ABO=C2=BB), fun `x` X0 c0 \\ c0]) (arity X1) _",
+        "current_goal_text": "instance.declare-const _ \n (app\n   [global=
 (const =C2=ABIsSelfA'.phant_Build=C2=BB), global (indt =C2=ABnat=C2=BB), \=
n    global (indc =C2=ABO=C2=BB), 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 =3D arity A7) \n                                            (=
if-verbose\n                                              (coq.say\n       =
                                         HB: skipping section opening)\n   =
                                           , A8 =3D A6) \n                 =
                           (,\n                                            =
  (, (new_int A21) \n                                                (std.a=
ny->string A21 A22) \n                                                (A9 i=
s hb_instance_ ^ A22)) \n                                              (log=
.coq.env.begin-section A9) \n                                              =
(instance.private.postulate-arity\n                                        =
        A4 [] A6 A8 A7)), \n                                           std.=
assert!\n                                            (coq.safe-dest-app A7 =
\n                                              (global A10) A11) \n       =
                                     The type of the instance is not a fact=
ory, \n                                           factory-alias->gref A10 A=
12, \n                                           std.assert!\n             =
                               (factory-nparams A12 A13) \n                =
                            Not a factory synthesized by HB, \n            =
                               instance.private.hack-section-discharging\n =
                                           A8 A14, \n                      =
                     instance.private.optimize-body\n                      =
                      A14 A15, \n                                          =
 if (A0 =3D _) \n                                            (, (new_int A2=
3) \n                                              (std.any->string A23 A24=
) \n                                              (A16 is\n                =
                                HB_unnamed_factory_ ^ A24)) \n             =
                               (A16 =3D A0), \n                            =
               log.coq.env.add-const-noimplicits-failondup\n               =
                             A16 A15 A7 ff A17, \n                         =
                  A18 =3D global (const A17), \n                           =
                std.drop A13 A11 [A19 | _], \n                             =
              instance.private.check-non-forgetful-inheritance\n           =
                                 A19 A12, \n                               =
            instance.private.declare-instance\n                            =
                A12 A19 A18 A20 A3, \n                                     =
      if (A4 =3D arity _) true \n                                          =
  (if-verbose\n                                              (header A25 ,\=
n                                                coq.say A25 \n            =
                                     closing instance section) ,\n         =
                                     log.coq.env.end-section-name A9), \n  =
                                         acc-clauses current A20]).",
+                  "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (s=
td.do!\n                                          [std.assert-ok!\n        =
                                    (coq.elaborate-arity-skeleton A2 \n    =
                                          _ A4) Definition type illtyped, \=
n                                           coq.arity->term A4 A5, \n      =
                                     std.assert-ok!\n                      =
                      (coq.elaborate-skeleton A1 A5 A6) \n                 =
                           Definition illtyped, \n                         =
                  if (A4 =3D arity A7) \n                                  =
          (if-verbose\n                                              (coq.s=
ay\n                                                HB: skipping section op=
ening)\n                                              , A8 =3D A6) \n      =
                                      (,\n                                 =
             (, (new_int A21) \n                                           =
     (std.any->string A21 A22) \n                                          =
      (A9 is hb_instance_ ^ A22)) \n                                       =
       (log.coq.env.begin-section A9) \n                                   =
           (instance.private.postulate-arity\n                             =
                   A4 [] A6 A8 A7)), \n                                    =
       std.assert!\n                                            (coq.safe-d=
est-app A7 \n                                              (global A10) A11=
) \n                                            The type of the instance is=
 not a factory, \n                                           factory-alias-=
>gref A10 A12, \n                                           std.assert!\n  =
                                          (factory-nparams A12 A13) \n     =
                                       Not a factory synthesized by HB, \n =
                                          instance.private.hack-section-dis=
charging\n                                            A8 A14, \n           =
                                instance.private.optimize-body\n           =
                                 A14 A15, \n                               =
            if (A0 =3D _) \n                                            (, =
(new_int A23) \n                                              (std.any->str=
ing A23 A24) \n                                              (A16 is\n     =
                                           HB_unnamed_factory_ ^ A24)) \n  =
                                          (A16 =3D A0), \n                 =
                          log.coq.env.add-const-noimplicits-failondup\n    =
                                        A16 A15 A7 ff A17, \n              =
                             A18 =3D global (const A17), \n                =
                           std.drop A13 A11 [A19 | _], \n                  =
                         instance.private.check-non-forgetful-inheritance\n=
                                            A19 A12, \n                    =
                       instance.private.declare-instance\n                 =
                           A12 A19 A18 A20 A3, \n                          =
                 if (A4 =3D arity _) true \n                               =
             (if-verbose\n                                              (he=
ader A25 ,\n                                                coq.say A25 \n =
                                                closing instance section) ,=
\n                                              log.coq.env.end-section-nam=
e A9), \n                                           acc-clauses current A20=
]).",
                   "rule_loc": [
                     "File",
                     {
-                      "filename":
-                        "/home/gares/MATHCOMP/hierarchy-builder/HB/instanc=
e.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 =C2=ABIsSelfA'.phant_Build=C2=BB), global (indt =C2=ABnat=C2=BB), \n =
       global (indc =C2=ABO=C2=BB), fun `x` X0 c0 \\ c0]) X70 X71) \n   Def=
inition illtyped, \n  if (X69 =3D arity X72) \n   (if-verbose (coq.say HB: =
skipping section opening) , X73 =3D X71) \n   (,\n     (, (new_int X74) (st=
d.any->string X74 X75) (X76 is hb_instance_ ^ X75)) \n     (log.coq.env.beg=
in-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.asse=
rt! (factory-nparams X79 X80) Not a factory synthesized by HB, \n  instance=
.private.hack-section-discharging X73 X81, \n  instance.private.optimize-bo=
dy X81 X82, \n  if (_ =3D _) \n   (, (new_int X83) (std.any->string X83 X84=
) \n     (X85 is HB_unnamed_factory_ ^ X84)) (X85 =3D _), \n  log.coq.env.a=
dd-const-noimplicits-failondup X85 X82 X72 ff X86, \n  X87 =3D global (cons=
t X86), std.drop X80 X78 [X88 | _], \n  instance.private.check-non-forgetfu=
l-inheritance X88 X79, \n  instance.private.declare-instance X79 X88 X87 X8=
9 X90, \n  if (X69 =3D arity _) true \n   (if-verbose (header X91 , coq.say=
 X91 closing instance section) ,\n     log.coq.env.end-section-name X76), a=
cc-clauses current X89]",
+                "goal_text": "std.do!\n [std.assert-ok! (coq.elaborate-ari=
ty-skeleton (arity X1) _ X69) \n   Definition type illtyped, coq.arity->ter=
m X69 X70, \n  std.assert-ok!\n   (coq.elaborate-skeleton\n     (app\n     =
  [global (const =C2=ABIsSelfA'.phant_Build=C2=BB), global (indt =C2=ABnat=
=C2=BB), \n        global (indc =C2=ABO=C2=BB), fun `x` X0 c0 \\ c0]) X70 X=
71) \n   Definition illtyped, \n  if (X69 =3D arity X72) \n   (if-verbose (=
coq.say HB: skipping section opening) , X73 =3D 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 (_ =3D _) \n   (, (new_int X83) (std.any->st=
ring X83 X84) \n     (X85 is HB_unnamed_factory_ ^ X84)) (X85 =3D _), \n  l=
og.coq.env.add-const-noimplicits-failondup X85 X82 X72 ff X86, \n  X87 =3D =
global (const X86), std.drop X80 X78 [X88 | _], \n  instance.private.check-=
non-forgetful-inheritance X88 X79, \n  instance.private.declare-instance X7=
9 X88 X87 X89 X90, \n  if (X69 =3D arity _) true \n   (if-verbose (header X=
91 , 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 =3D arity A7) \n                                            (if=
-verbose\n                                              (coq.say\n         =
                                       HB: skipping section opening)\n     =
                                         , A8 =3D A6) \n                   =
                         (,\n                                              =
(, (new_int A21) \n                                                (std.any=
->string A21 A22) \n                                                (A9 is =
hb_instance_ ^ A22)) \n                                              (log.c=
oq.env.begin-section A9) \n                                              (i=
nstance.private.postulate-arity\n                                          =
      A4 [] A6 A8 A7)), \n                                           std.as=
sert!\n                                            (coq.safe-dest-app A7 \n=
                                              (global A10) A11) \n         =
                                   The type of the instance is not a factor=
y, \n                                           factory-alias->gref A10 A12=
, \n                                           std.assert!\n               =
                             (factory-nparams A12 A13) \n                  =
                          Not a factory synthesized by HB, \n              =
                             instance.private.hack-section-discharging\n   =
                                         A8 A14, \n                        =
                   instance.private.optimize-body\n                        =
                    A14 A15, \n                                           i=
f (A0 =3D _) \n                                            (, (new_int A23)=
 \n                                              (std.any->string A23 A24) =
\n                                              (A16 is\n                  =
                              HB_unnamed_factory_ ^ A24)) \n               =
                             (A16 =3D A0), \n                              =
             log.coq.env.add-const-noimplicits-failondup\n                 =
                           A16 A15 A7 ff A17, \n                           =
                A18 =3D global (const A17), \n                             =
              std.drop A13 A11 [A19 | _], \n                               =
            instance.private.check-non-forgetful-inheritance\n             =
                               A19 A12, \n                                 =
          instance.private.declare-instance\n                              =
              A12 A19 A18 A20 A3, \n                                       =
    if (A4 =3D arity _) true \n                                            =
(if-verbose\n                                              (header A25 ,\n =
                                               coq.say A25 \n              =
                                   closing instance section) ,\n           =
                                   log.coq.env.end-section-name A9), \n    =
                                       acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std=
.do!\n                                          [std.assert-ok!\n          =
                                  (coq.elaborate-arity-skeleton A2 \n      =
                                        _ A4) Definition type illtyped, \n =
                                          coq.arity->term A4 A5, \n        =
                                   std.assert-ok!\n                        =
                    (coq.elaborate-skeleton A1 A5 A6) \n                   =
                         Definition illtyped, \n                           =
                if (A4 =3D arity A7) \n                                    =
        (if-verbose\n                                              (coq.say=
\n                                                HB: skipping section open=
ing)\n                                              , A8 =3D A6) \n        =
                                    (,\n                                   =
           (, (new_int A21) \n                                             =
   (std.any->string A21 A22) \n                                            =
    (A9 is hb_instance_ ^ A22)) \n                                         =
     (log.coq.env.begin-section A9) \n                                     =
         (instance.private.postulate-arity\n                               =
                 A4 [] A6 A8 A7)), \n                                      =
     std.assert!\n                                            (coq.safe-des=
t-app A7 \n                                              (global A10) A11) =
\n                                            The type of the instance is n=
ot a factory, \n                                           factory-alias->g=
ref A10 A12, \n                                           std.assert!\n    =
                                        (factory-nparams A12 A13) \n       =
                                     Not a factory synthesized by HB, \n   =
                                        instance.private.hack-section-disch=
arging\n                                            A8 A14, \n             =
                              instance.private.optimize-body\n             =
                               A14 A15, \n                                 =
          if (A0 =3D _) \n                                            (, (n=
ew_int A23) \n                                              (std.any->strin=
g A23 A24) \n                                              (A16 is\n       =
                                         HB_unnamed_factory_ ^ A24)) \n    =
                                        (A16 =3D A0), \n                   =
                        log.coq.env.add-const-noimplicits-failondup\n      =
                                      A16 A15 A7 ff A17, \n                =
                           A18 =3D global (const A17), \n                  =
                         std.drop A13 A11 [A19 | _], \n                    =
                       instance.private.check-non-forgetful-inheritance\n  =
                                          A19 A12, \n                      =
                     instance.private.declare-instance\n                   =
                         A12 A19 A18 A20 A3, \n                            =
               if (A4 =3D arity _) true \n                                 =
           (if-verbose\n                                              (head=
er A25 ,\n                                                coq.say A25 \n   =
                                              closing instance section) ,\n=
                                              log.coq.env.end-section-name =
A9), \n                                           acc-clauses current A20])=
.",
                 "rule_loc": [
                   "File",
                   {
-                    "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/lo=
g.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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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 =
=C2=ABIsSelfA'.phant_Build=C2=BB), global (indt =C2=ABnat=C2=BB), \n       =
 global (indc =C2=ABO=C2=BB), fun `x` X0 c0 \\ c0]) X70 X71) \n   Definitio=
n illtyped, \n  if (X69 =3D arity X72) \n   (if-verbose (coq.say HB: skippi=
ng section opening) , X73 =3D X71) \n   (,\n     (, (new_int X74) (std.any-=
>string X74 X75) (X76 is hb_instance_ ^ X75)) \n     (log.coq.env.begin-sec=
tion 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! (f=
actory-nparams X79 X80) Not a factory synthesized by HB, \n  instance.priva=
te.hack-section-discharging X73 X81, \n  instance.private.optimize-body X81=
 X82, \n  if (_ =3D _) \n   (, (new_int X83) (std.any->string X83 X84) \n  =
   (X85 is HB_unnamed_factory_ ^ X84)) (X85 =3D _), \n  log.coq.env.add-con=
st-noimplicits-failondup X85 X82 X72 ff X86, \n  X87 =3D global (const X86)=
, std.drop X80 X78 [X88 | _], \n  instance.private.check-non-forgetful-inhe=
ritance X88 X79, \n  instance.private.declare-instance X79 X88 X87 X89 X90,=
 \n  if (X69 =3D arity _) true \n   (if-verbose (header X91 , coq.say X91 c=
losing instance section) ,\n     log.coq.env.end-section-name X76), acc-cla=
uses current X89]",
+        "current_goal_text": "std.do!\n [std.assert-ok! (coq.elaborate-ari=
ty-skeleton (arity X1) _ X69) \n   Definition type illtyped, coq.arity->ter=
m X69 X70, \n  std.assert-ok!\n   (coq.elaborate-skeleton\n     (app\n     =
  [global (const =C2=ABIsSelfA'.phant_Build=C2=BB), global (indt =C2=ABnat=
=C2=BB), \n        global (indc =C2=ABO=C2=BB), fun `x` X0 c0 \\ c0]) X70 X=
71) \n   Definition illtyped, \n  if (X69 =3D arity X72) \n   (if-verbose (=
coq.say HB: skipping section opening) , X73 =3D 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 (_ =3D _) \n   (, (new_int X83) (std.any->st=
ring X83 X84) \n     (X85 is HB_unnamed_factory_ ^ X84)) (X85 =3D _), \n  l=
og.coq.env.add-const-noimplicits-failondup X85 X82 X72 ff X86, \n  X87 =3D =
global (const X86), std.drop X80 X78 [X88 | _], \n  instance.private.check-=
non-forgetful-inheritance X88 X79, \n  instance.private.declare-instance X7=
9 X88 X87 X89 X90, \n  if (X69 =3D arity _) true \n   (if-verbose (header X=
91 , 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! A=
1).",
                   "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 =C2=ABIsSelfA=
'.phant_Build=C2=BB), global (indt =C2=ABnat=C2=BB), \n        global (indc=
 =C2=ABO=C2=BB), fun `x` X0 c0 \\ c0]) X70 X71) \n   Definition illtyped, \=
n  if (X69 =3D arity X72) \n   (if-verbose (coq.say HB: skipping section op=
ening) , X73 =3D X71) \n   (,\n     (, (new_int X74) (std.any->string X74 X=
75) (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-nparam=
s X79 X80) Not a factory synthesized by HB, \n  instance.private.hack-secti=
on-discharging X73 X81, \n  instance.private.optimize-body X81 X82, \n  if =
(_ =3D _) \n   (, (new_int X83) (std.any->string X83 X84) \n     (X85 is HB=
_unnamed_factory_ ^ X84)) (X85 =3D _), \n  log.coq.env.add-const-noimplicit=
s-failondup X85 X82 X72 ff X86, \n  X87 =3D global (const X86), std.drop X8=
0 X78 [X88 | _], \n  instance.private.check-non-forgetful-inheritance X88 X=
79, \n  instance.private.declare-instance X79 X88 X87 X89 X90, \n  if (X69 =
=3D arity _) true \n   (if-verbose (header X91 , coq.say X91 closing instan=
ce 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 =
=C2=ABIsSelfA'.phant_Build=C2=BB), global (indt =C2=ABnat=C2=BB), \n       =
 global (indc =C2=ABO=C2=BB), fun `x` X0 c0 \\ c0]) X70 X71) \n   Definitio=
n illtyped, \n  if (X69 =3D arity X72) \n   (if-verbose (coq.say HB: skippi=
ng section opening) , X73 =3D X71) \n   (,\n     (, (new_int X74) (std.any-=
>string X74 X75) (X76 is hb_instance_ ^ X75)) \n     (log.coq.env.begin-sec=
tion 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! (f=
actory-nparams X79 X80) Not a factory synthesized by HB, \n  instance.priva=
te.hack-section-discharging X73 X81, \n  instance.private.optimize-body X81=
 X82, \n  if (_ =3D _) \n   (, (new_int X83) (std.any->string X83 X84) \n  =
   (X85 is HB_unnamed_factory_ ^ X84)) (X85 =3D _), \n  log.coq.env.add-con=
st-noimplicits-failondup X85 X82 X72 ff X86, \n  X87 =3D global (const X86)=
, std.drop X80 X78 [X88 | _], \n  instance.private.check-non-forgetful-inhe=
ritance X88 X79, \n  instance.private.declare-instance X79 X88 X87 X89 X90,=
 \n  if (X69 =3D arity _) true \n   (if-verbose (header X91 , coq.say X91 c=
losing instance section) ,\n     log.coq.env.end-section-name X76), acc-cla=
uses 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 =3D arity A7) \n                                            (if=
-verbose\n                                              (coq.say\n         =
                                       HB: skipping section opening)\n     =
                                         , A8 =3D A6) \n                   =
                         (,\n                                              =
(, (new_int A21) \n                                                (std.any=
->string A21 A22) \n                                                (A9 is =
hb_instance_ ^ A22)) \n                                              (log.c=
oq.env.begin-section A9) \n                                              (i=
nstance.private.postulate-arity\n                                          =
      A4 [] A6 A8 A7)), \n                                           std.as=
sert!\n                                            (coq.safe-dest-app A7 \n=
                                              (global A10) A11) \n         =
                                   The type of the instance is not a factor=
y, \n                                           factory-alias->gref A10 A12=
, \n                                           std.assert!\n               =
                             (factory-nparams A12 A13) \n                  =
                          Not a factory synthesized by HB, \n              =
                             instance.private.hack-section-discharging\n   =
                                         A8 A14, \n                        =
                   instance.private.optimize-body\n                        =
                    A14 A15, \n                                           i=
f (A0 =3D _) \n                                            (, (new_int A23)=
 \n                                              (std.any->string A23 A24) =
\n                                              (A16 is\n                  =
                              HB_unnamed_factory_ ^ A24)) \n               =
                             (A16 =3D A0), \n                              =
             log.coq.env.add-const-noimplicits-failondup\n                 =
                           A16 A15 A7 ff A17, \n                           =
                A18 =3D global (const A17), \n                             =
              std.drop A13 A11 [A19 | _], \n                               =
            instance.private.check-non-forgetful-inheritance\n             =
                               A19 A12, \n                                 =
          instance.private.declare-instance\n                              =
              A12 A19 A18 A20 A3, \n                                       =
    if (A4 =3D arity _) true \n                                            =
(if-verbose\n                                              (header A25 ,\n =
                                               coq.say A25 \n              =
                                   closing instance section) ,\n           =
                                   log.coq.env.end-section-name A9), \n    =
                                       acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std=
.do!\n                                          [std.assert-ok!\n          =
                                  (coq.elaborate-arity-skeleton A2 \n      =
                                        _ A4) Definition type illtyped, \n =
                                          coq.arity->term A4 A5, \n        =
                                   std.assert-ok!\n                        =
                    (coq.elaborate-skeleton A1 A5 A6) \n                   =
                         Definition illtyped, \n                           =
                if (A4 =3D arity A7) \n                                    =
        (if-verbose\n                                              (coq.say=
\n                                                HB: skipping section open=
ing)\n                                              , A8 =3D A6) \n        =
                                    (,\n                                   =
           (, (new_int A21) \n                                             =
   (std.any->string A21 A22) \n                                            =
    (A9 is hb_instance_ ^ A22)) \n                                         =
     (log.coq.env.begin-section A9) \n                                     =
         (instance.private.postulate-arity\n                               =
                 A4 [] A6 A8 A7)), \n                                      =
     std.assert!\n                                            (coq.safe-des=
t-app A7 \n                                              (global A10) A11) =
\n                                            The type of the instance is n=
ot a factory, \n                                           factory-alias->g=
ref A10 A12, \n                                           std.assert!\n    =
                                        (factory-nparams A12 A13) \n       =
                                     Not a factory synthesized by HB, \n   =
                                        instance.private.hack-section-disch=
arging\n                                            A8 A14, \n             =
                              instance.private.optimize-body\n             =
                               A14 A15, \n                                 =
          if (A0 =3D _) \n                                            (, (n=
ew_int A23) \n                                              (std.any->strin=
g A23 A24) \n                                              (A16 is\n       =
                                         HB_unnamed_factory_ ^ A24)) \n    =
                                        (A16 =3D A0), \n                   =
                        log.coq.env.add-const-noimplicits-failondup\n      =
                                      A16 A15 A7 ff A17, \n                =
                           A18 =3D global (const A17), \n                  =
                         std.drop A13 A11 [A19 | _], \n                    =
                       instance.private.check-non-forgetful-inheritance\n  =
                                          A19 A12, \n                      =
                     instance.private.declare-instance\n                   =
                         A12 A19 A18 A20 A3, \n                            =
               if (A4 =3D arity _) true \n                                 =
           (if-verbose\n                                              (head=
er A25 ,\n                                                coq.say A25 \n   =
                                              closing instance section) ,\n=
                                              log.coq.env.end-section-name =
A9), \n                                           acc-clauses current A20])=
.",
                 "rule_loc": [
                   "File",
                   {
-                    "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/lo=
g.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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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 =3D ok=
 ; A2 =3D error A3 , std.fatal-error-w-data A1 A3), (!).",
+                  "rule_text": "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n=
 (A2 =3D ok ; A2 =3D 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) _ X6=
9 X92",
                 "goal_id": 1247
               },
               { "goal_text": "!", "goal_id": 1248 },
               {
-                "goal_text":
-                  "X92 =3D ok ;\n X92 =3D error X93 , std.fatal-error-w-da=
ta Definition type illtyped X93",
+                "goal_text": "X92 =3D ok ;\n X92 =3D 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 =3D ok ;=
 A2 =3D error A3 , std.fatal-error-w-data A1 A3), (!).",
+                "rule_text": "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (=
A2 =3D ok ; A2 =3D 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 =3D arity A7) \n                                            (if=
-verbose\n                                              (coq.say\n         =
                                       HB: skipping section opening)\n     =
                                         , A8 =3D A6) \n                   =
                         (,\n                                              =
(, (new_int A21) \n                                                (std.any=
->string A21 A22) \n                                                (A9 is =
hb_instance_ ^ A22)) \n                                              (log.c=
oq.env.begin-section A9) \n                                              (i=
nstance.private.postulate-arity\n                                          =
      A4 [] A6 A8 A7)), \n                                           std.as=
sert!\n                                            (coq.safe-dest-app A7 \n=
                                              (global A10) A11) \n         =
                                   The type of the instance is not a factor=
y, \n                                           factory-alias->gref A10 A12=
, \n                                           std.assert!\n               =
                             (factory-nparams A12 A13) \n                  =
                          Not a factory synthesized by HB, \n              =
                             instance.private.hack-section-discharging\n   =
                                         A8 A14, \n                        =
                   instance.private.optimize-body\n                        =
                    A14 A15, \n                                           i=
f (A0 =3D _) \n                                            (, (new_int A23)=
 \n                                              (std.any->string A23 A24) =
\n                                              (A16 is\n                  =
                              HB_unnamed_factory_ ^ A24)) \n               =
                             (A16 =3D A0), \n                              =
             log.coq.env.add-const-noimplicits-failondup\n                 =
                           A16 A15 A7 ff A17, \n                           =
                A18 =3D global (const A17), \n                             =
              std.drop A13 A11 [A19 | _], \n                               =
            instance.private.check-non-forgetful-inheritance\n             =
                               A19 A12, \n                                 =
          instance.private.declare-instance\n                              =
              A12 A19 A18 A20 A3, \n                                       =
    if (A4 =3D arity _) true \n                                            =
(if-verbose\n                                              (header A25 ,\n =
                                               coq.say A25 \n              =
                                   closing instance section) ,\n           =
                                   log.coq.env.end-section-name A9), \n    =
                                       acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std=
.do!\n                                          [std.assert-ok!\n          =
                                  (coq.elaborate-arity-skeleton A2 \n      =
                                        _ A4) Definition type illtyped, \n =
                                          coq.arity->term A4 A5, \n        =
                                   std.assert-ok!\n                        =
                    (coq.elaborate-skeleton A1 A5 A6) \n                   =
                         Definition illtyped, \n                           =
                if (A4 =3D arity A7) \n                                    =
        (if-verbose\n                                              (coq.say=
\n                                                HB: skipping section open=
ing)\n                                              , A8 =3D A6) \n        =
                                    (,\n                                   =
           (, (new_int A21) \n                                             =
   (std.any->string A21 A22) \n                                            =
    (A9 is hb_instance_ ^ A22)) \n                                         =
     (log.coq.env.begin-section A9) \n                                     =
         (instance.private.postulate-arity\n                               =
                 A4 [] A6 A8 A7)), \n                                      =
     std.assert!\n                                            (coq.safe-des=
t-app A7 \n                                              (global A10) A11) =
\n                                            The type of the instance is n=
ot a factory, \n                                           factory-alias->g=
ref A10 A12, \n                                           std.assert!\n    =
                                        (factory-nparams A12 A13) \n       =
                                     Not a factory synthesized by HB, \n   =
                                        instance.private.hack-section-disch=
arging\n                                            A8 A14, \n             =
                              instance.private.optimize-body\n             =
                               A14 A15, \n                                 =
          if (A0 =3D _) \n                                            (, (n=
ew_int A23) \n                                              (std.any->strin=
g A23 A24) \n                                              (A16 is\n       =
                                         HB_unnamed_factory_ ^ A24)) \n    =
                                        (A16 =3D A0), \n                   =
                        log.coq.env.add-const-noimplicits-failondup\n      =
                                      A16 A15 A7 ff A17, \n                =
                           A18 =3D global (const A17), \n                  =
                         std.drop A13 A11 [A19 | _], \n                    =
                       instance.private.check-non-forgetful-inheritance\n  =
                                          A19 A12, \n                      =
                     instance.private.declare-instance\n                   =
                         A12 A19 A18 A20 A3, \n                            =
               if (A4 =3D arity _) true \n                                 =
           (if-verbose\n                                              (head=
er A25 ,\n                                                coq.say A25 \n   =
                                              closing instance section) ,\n=
                                              log.coq.env.end-section-name =
A9), \n                                           acc-clauses current A20])=
.",
                 "rule_loc": [
                   "File",
                   {
-                    "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/lo=
g.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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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) _ X6=
9 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) A=
1 (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 =3D ok ;=
 A2 =3D error A3 , std.fatal-error-w-data A1 A3), (!).",
+                "rule_text": "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (=
A2 =3D ok ; A2 =3D 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 =3D arity A7) \n                                            (if=
-verbose\n                                              (coq.say\n         =
                                       HB: skipping section opening)\n     =
                                         , A8 =3D A6) \n                   =
                         (,\n                                              =
(, (new_int A21) \n                                                (std.any=
->string A21 A22) \n                                                (A9 is =
hb_instance_ ^ A22)) \n                                              (log.c=
oq.env.begin-section A9) \n                                              (i=
nstance.private.postulate-arity\n                                          =
      A4 [] A6 A8 A7)), \n                                           std.as=
sert!\n                                            (coq.safe-dest-app A7 \n=
                                              (global A10) A11) \n         =
                                   The type of the instance is not a factor=
y, \n                                           factory-alias->gref A10 A12=
, \n                                           std.assert!\n               =
                             (factory-nparams A12 A13) \n                  =
                          Not a factory synthesized by HB, \n              =
                             instance.private.hack-section-discharging\n   =
                                         A8 A14, \n                        =
                   instance.private.optimize-body\n                        =
                    A14 A15, \n                                           i=
f (A0 =3D _) \n                                            (, (new_int A23)=
 \n                                              (std.any->string A23 A24) =
\n                                              (A16 is\n                  =
                              HB_unnamed_factory_ ^ A24)) \n               =
                             (A16 =3D A0), \n                              =
             log.coq.env.add-const-noimplicits-failondup\n                 =
                           A16 A15 A7 ff A17, \n                           =
                A18 =3D global (const A17), \n                             =
              std.drop A13 A11 [A19 | _], \n                               =
            instance.private.check-non-forgetful-inheritance\n             =
                               A19 A12, \n                                 =
          instance.private.declare-instance\n                              =
              A12 A19 A18 A20 A3, \n                                       =
    if (A4 =3D arity _) true \n                                            =
(if-verbose\n                                              (header A25 ,\n =
                                               coq.say A25 \n              =
                                   closing instance section) ,\n           =
                                   log.coq.env.end-section-name A9), \n    =
                                       acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std=
.do!\n                                          [std.assert-ok!\n          =
                                  (coq.elaborate-arity-skeleton A2 \n      =
                                        _ A4) Definition type illtyped, \n =
                                          coq.arity->term A4 A5, \n        =
                                   std.assert-ok!\n                        =
                    (coq.elaborate-skeleton A1 A5 A6) \n                   =
                         Definition illtyped, \n                           =
                if (A4 =3D arity A7) \n                                    =
        (if-verbose\n                                              (coq.say=
\n                                                HB: skipping section open=
ing)\n                                              , A8 =3D A6) \n        =
                                    (,\n                                   =
           (, (new_int A21) \n                                             =
   (std.any->string A21 A22) \n                                            =
    (A9 is hb_instance_ ^ A22)) \n                                         =
     (log.coq.env.begin-section A9) \n                                     =
         (instance.private.postulate-arity\n                               =
                 A4 [] A6 A8 A7)), \n                                      =
     std.assert!\n                                            (coq.safe-des=
t-app A7 \n                                              (global A10) A11) =
\n                                            The type of the instance is n=
ot a factory, \n                                           factory-alias->g=
ref A10 A12, \n                                           std.assert!\n    =
                                        (factory-nparams A12 A13) \n       =
                                     Not a factory synthesized by HB, \n   =
                                        instance.private.hack-section-disch=
arging\n                                            A8 A14, \n             =
                              instance.private.optimize-body\n             =
                               A14 A15, \n                                 =
          if (A0 =3D _) \n                                            (, (n=
ew_int A23) \n                                              (std.any->strin=
g A23 A24) \n                                              (A16 is\n       =
                                         HB_unnamed_factory_ ^ A24)) \n    =
                                        (A16 =3D A0), \n                   =
                        log.coq.env.add-const-noimplicits-failondup\n      =
                                      A16 A15 A7 ff A17, \n                =
                           A18 =3D global (const A17), \n                  =
                         std.drop A13 A11 [A19 | _], \n                    =
                       instance.private.check-non-forgetful-inheritance\n  =
                                          A19 A12, \n                      =
                     instance.private.declare-instance\n                   =
                         A12 A19 A18 A20 A3, \n                            =
               if (A4 =3D arity _) true \n                                 =
           (if-verbose\n                                              (head=
er A25 ,\n                                                coq.say A25 \n   =
                                              closing instance section) ,\n=
                                              log.coq.env.end-section-name =
A9), \n                                           acc-clauses current A20])=
.",
                 "rule_loc": [
                   "File",
                   {
-                    "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/lo=
g.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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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 =3D X96", "goal_id": 1253 },
               {
-                "goal_text":
-                  "declare-evar [] (X97) (sort (typ =C2=ABinterleave_conte=
xt.403=C2=BB)) (X96)",
+                "goal_text": "declare-evar [] (X97) (sort (typ =C2=ABinter=
leave_context.403=C2=BB)) (X96)",
                 "goal_id": 1254
               },
               { "goal_text": "X92 =3D 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 =3D ok ;=
 A2 =3D error A3 , std.fatal-error-w-data A1 A3), (!).",
+                "rule_text": "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (=
A2 =3D ok ; A2 =3D 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 =3D arity A7) \n                                            (if=
-verbose\n                                              (coq.say\n         =
                                       HB: skipping section opening)\n     =
                                         , A8 =3D A6) \n                   =
                         (,\n                                              =
(, (new_int A21) \n                                                (std.any=
->string A21 A22) \n                                                (A9 is =
hb_instance_ ^ A22)) \n                                              (log.c=
oq.env.begin-section A9) \n                                              (i=
nstance.private.postulate-arity\n                                          =
      A4 [] A6 A8 A7)), \n                                           std.as=
sert!\n                                            (coq.safe-dest-app A7 \n=
                                              (global A10) A11) \n         =
                                   The type of the instance is not a factor=
y, \n                                           factory-alias->gref A10 A12=
, \n                                           std.assert!\n               =
                             (factory-nparams A12 A13) \n                  =
                          Not a factory synthesized by HB, \n              =
                             instance.private.hack-section-discharging\n   =
                                         A8 A14, \n                        =
                   instance.private.optimize-body\n                        =
                    A14 A15, \n                                           i=
f (A0 =3D _) \n                                            (, (new_int A23)=
 \n                                              (std.any->string A23 A24) =
\n                                              (A16 is\n                  =
                              HB_unnamed_factory_ ^ A24)) \n               =
                             (A16 =3D A0), \n                              =
             log.coq.env.add-const-noimplicits-failondup\n                 =
                           A16 A15 A7 ff A17, \n                           =
                A18 =3D global (const A17), \n                             =
              std.drop A13 A11 [A19 | _], \n                               =
            instance.private.check-non-forgetful-inheritance\n             =
                               A19 A12, \n                                 =
          instance.private.declare-instance\n                              =
              A12 A19 A18 A20 A3, \n                                       =
    if (A4 =3D arity _) true \n                                            =
(if-verbose\n                                              (header A25 ,\n =
                                               coq.say A25 \n              =
                                   closing instance section) ,\n           =
                                   log.coq.env.end-section-name A9), \n    =
                                       acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std=
.do!\n                                          [std.assert-ok!\n          =
                                  (coq.elaborate-arity-skeleton A2 \n      =
                                        _ A4) Definition type illtyped, \n =
                                          coq.arity->term A4 A5, \n        =
                                   std.assert-ok!\n                        =
                    (coq.elaborate-skeleton A1 A5 A6) \n                   =
                         Definition illtyped, \n                           =
                if (A4 =3D arity A7) \n                                    =
        (if-verbose\n                                              (coq.say=
\n                                                HB: skipping section open=
ing)\n                                              , A8 =3D A6) \n        =
                                    (,\n                                   =
           (, (new_int A21) \n                                             =
   (std.any->string A21 A22) \n                                            =
    (A9 is hb_instance_ ^ A22)) \n                                         =
     (log.coq.env.begin-section A9) \n                                     =
         (instance.private.postulate-arity\n                               =
                 A4 [] A6 A8 A7)), \n                                      =
     std.assert!\n                                            (coq.safe-des=
t-app A7 \n                                              (global A10) A11) =
\n                                            The type of the instance is n=
ot a factory, \n                                           factory-alias->g=
ref A10 A12, \n                                           std.assert!\n    =
                                        (factory-nparams A12 A13) \n       =
                                     Not a factory synthesized by HB, \n   =
                                        instance.private.hack-section-disch=
arging\n                                            A8 A14, \n             =
                              instance.private.optimize-body\n             =
                               A14 A15, \n                                 =
          if (A0 =3D _) \n                                            (, (n=
ew_int A23) \n                                              (std.any->strin=
g A23 A24) \n                                              (A16 is\n       =
                                         HB_unnamed_factory_ ^ A24)) \n    =
                                        (A16 =3D A0), \n                   =
                        log.coq.env.add-const-noimplicits-failondup\n      =
                                      A16 A15 A7 ff A17, \n                =
                           A18 =3D global (const A17), \n                  =
                         std.drop A13 A11 [A19 | _], \n                    =
                       instance.private.check-non-forgetful-inheritance\n  =
                                          A19 A12, \n                      =
                     instance.private.declare-instance\n                   =
                         A12 A19 A18 A20 A3, \n                            =
               if (A4 =3D arity _) true \n                                 =
           (if-verbose\n                                              (head=
er A25 ,\n                                                coq.say A25 \n   =
                                              closing instance section) ,\n=
                                              log.coq.env.end-section-name =
A9), \n                                           acc-clauses current A20])=
.",
                 "rule_loc": [
                   "File",
                   {
-                    "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/lo=
g.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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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 =3D ok ;=
 A2 =3D error A3 , std.fatal-error-w-data A1 A3), (!).",
+                "rule_text": "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (=
A2 =3D ok ; A2 =3D 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 =3D arity A7) \n                                            (if=
-verbose\n                                              (coq.say\n         =
                                       HB: skipping section opening)\n     =
                                         , A8 =3D A6) \n                   =
                         (,\n                                              =
(, (new_int A21) \n                                                (std.any=
->string A21 A22) \n                                                (A9 is =
hb_instance_ ^ A22)) \n                                              (log.c=
oq.env.begin-section A9) \n                                              (i=
nstance.private.postulate-arity\n                                          =
      A4 [] A6 A8 A7)), \n                                           std.as=
sert!\n                                            (coq.safe-dest-app A7 \n=
                                              (global A10) A11) \n         =
                                   The type of the instance is not a factor=
y, \n                                           factory-alias->gref A10 A12=
, \n                                           std.assert!\n               =
                             (factory-nparams A12 A13) \n                  =
                          Not a factory synthesized by HB, \n              =
                             instance.private.hack-section-discharging\n   =
                                         A8 A14, \n                        =
                   instance.private.optimize-body\n                        =
                    A14 A15, \n                                           i=
f (A0 =3D _) \n                                            (, (new_int A23)=
 \n                                              (std.any->string A23 A24) =
\n                                              (A16 is\n                  =
                              HB_unnamed_factory_ ^ A24)) \n               =
                             (A16 =3D A0), \n                              =
             log.coq.env.add-const-noimplicits-failondup\n                 =
                           A16 A15 A7 ff A17, \n                           =
                A18 =3D global (const A17), \n                             =
              std.drop A13 A11 [A19 | _], \n                               =
            instance.private.check-non-forgetful-inheritance\n             =
                               A19 A12, \n                                 =
          instance.private.declare-instance\n                              =
              A12 A19 A18 A20 A3, \n                                       =
    if (A4 =3D arity _) true \n                                            =
(if-verbose\n                                              (header A25 ,\n =
                                               coq.say A25 \n              =
                                   closing instance section) ,\n           =
                                   log.coq.env.end-section-name A9), \n    =
                                       acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std=
.do!\n                                          [std.assert-ok!\n          =
                                  (coq.elaborate-arity-skeleton A2 \n      =
                                        _ A4) Definition type illtyped, \n =
                                          coq.arity->term A4 A5, \n        =
                                   std.assert-ok!\n                        =
                    (coq.elaborate-skeleton A1 A5 A6) \n                   =
                         Definition illtyped, \n                           =
                if (A4 =3D arity A7) \n                                    =
        (if-verbose\n                                              (coq.say=
\n                                                HB: skipping section open=
ing)\n                                              , A8 =3D A6) \n        =
                                    (,\n                                   =
           (, (new_int A21) \n                                             =
   (std.any->string A21 A22) \n                                            =
    (A9 is hb_instance_ ^ A22)) \n                                         =
     (log.coq.env.begin-section A9) \n                                     =
         (instance.private.postulate-arity\n                               =
                 A4 [] A6 A8 A7)), \n                                      =
     std.assert!\n                                            (coq.safe-des=
t-app A7 \n                                              (global A10) A11) =
\n                                            The type of the instance is n=
ot a factory, \n                                           factory-alias->g=
ref A10 A12, \n                                           std.assert!\n    =
                                        (factory-nparams A12 A13) \n       =
                                     Not a factory synthesized by HB, \n   =
                                        instance.private.hack-section-disch=
arging\n                                            A8 A14, \n             =
                              instance.private.optimize-body\n             =
                               A14 A15, \n                                 =
          if (A0 =3D _) \n                                            (, (n=
ew_int A23) \n                                              (std.any->strin=
g A23 A24) \n                                              (A16 is\n       =
                                         HB_unnamed_factory_ ^ A24)) \n    =
                                        (A16 =3D A0), \n                   =
                        log.coq.env.add-const-noimplicits-failondup\n      =
                                      A16 A15 A7 ff A17, \n                =
                           A18 =3D global (const A17), \n                  =
                         std.drop A13 A11 [A19 | _], \n                    =
                       instance.private.check-non-forgetful-inheritance\n  =
                                          A19 A12, \n                      =
                     instance.private.declare-instance\n                   =
                         A12 A19 A18 A20 A3, \n                            =
               if (A4 =3D arity _) true \n                                 =
           (if-verbose\n                                              (head=
er A25 ,\n                                                coq.say A25 \n   =
                                              closing instance section) ,\n=
                                              log.coq.env.end-section-name =
A9), \n                                           acc-clauses current A20])=
.",
                 "rule_loc": [
                   "File",
                   {
-                    "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/lo=
g.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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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 =3D ok ;=
 A2 =3D error A3 , std.fatal-error-w-data A1 A3), (!).",
+                "rule_text": "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (=
A2 =3D ok ; A2 =3D 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 =3D arity A7) \n                                            (if=
-verbose\n                                              (coq.say\n         =
                                       HB: skipping section opening)\n     =
                                         , A8 =3D A6) \n                   =
                         (,\n                                              =
(, (new_int A21) \n                                                (std.any=
->string A21 A22) \n                                                (A9 is =
hb_instance_ ^ A22)) \n                                              (log.c=
oq.env.begin-section A9) \n                                              (i=
nstance.private.postulate-arity\n                                          =
      A4 [] A6 A8 A7)), \n                                           std.as=
sert!\n                                            (coq.safe-dest-app A7 \n=
                                              (global A10) A11) \n         =
                                   The type of the instance is not a factor=
y, \n                                           factory-alias->gref A10 A12=
, \n                                           std.assert!\n               =
                             (factory-nparams A12 A13) \n                  =
                          Not a factory synthesized by HB, \n              =
                             instance.private.hack-section-discharging\n   =
                                         A8 A14, \n                        =
                   instance.private.optimize-body\n                        =
                    A14 A15, \n                                           i=
f (A0 =3D _) \n                                            (, (new_int A23)=
 \n                                              (std.any->string A23 A24) =
\n                                              (A16 is\n                  =
                              HB_unnamed_factory_ ^ A24)) \n               =
                             (A16 =3D A0), \n                              =
             log.coq.env.add-const-noimplicits-failondup\n                 =
                           A16 A15 A7 ff A17, \n                           =
                A18 =3D global (const A17), \n                             =
              std.drop A13 A11 [A19 | _], \n                               =
            instance.private.check-non-forgetful-inheritance\n             =
                               A19 A12, \n                                 =
          instance.private.declare-instance\n                              =
              A12 A19 A18 A20 A3, \n                                       =
    if (A4 =3D arity _) true \n                                            =
(if-verbose\n                                              (header A25 ,\n =
                                               coq.say A25 \n              =
                                   closing instance section) ,\n           =
                                   log.coq.env.end-section-name A9), \n    =
                                       acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std=
.do!\n                                          [std.assert-ok!\n          =
                                  (coq.elaborate-arity-skeleton A2 \n      =
                                        _ A4) Definition type illtyped, \n =
                                          coq.arity->term A4 A5, \n        =
                                   std.assert-ok!\n                        =
                    (coq.elaborate-skeleton A1 A5 A6) \n                   =
                         Definition illtyped, \n                           =
                if (A4 =3D arity A7) \n                                    =
        (if-verbose\n                                              (coq.say=
\n                                                HB: skipping section open=
ing)\n                                              , A8 =3D A6) \n        =
                                    (,\n                                   =
           (, (new_int A21) \n                                             =
   (std.any->string A21 A22) \n                                            =
    (A9 is hb_instance_ ^ A22)) \n                                         =
     (log.coq.env.begin-section A9) \n                                     =
         (instance.private.postulate-arity\n                               =
                 A4 [] A6 A8 A7)), \n                                      =
     std.assert!\n                                            (coq.safe-des=
t-app A7 \n                                              (global A10) A11) =
\n                                            The type of the instance is n=
ot a factory, \n                                           factory-alias->g=
ref A10 A12, \n                                           std.assert!\n    =
                                        (factory-nparams A12 A13) \n       =
                                     Not a factory synthesized by HB, \n   =
                                        instance.private.hack-section-disch=
arging\n                                            A8 A14, \n             =
                              instance.private.optimize-body\n             =
                               A14 A15, \n                                 =
          if (A0 =3D _) \n                                            (, (n=
ew_int A23) \n                                              (std.any->strin=
g A23 A24) \n                                              (A16 is\n       =
                                         HB_unnamed_factory_ ^ A24)) \n    =
                                        (A16 =3D A0), \n                   =
                        log.coq.env.add-const-noimplicits-failondup\n      =
                                      A16 A15 A7 ff A17, \n                =
                           A18 =3D global (const A17), \n                  =
                         std.drop A13 A11 [A19 | _], \n                    =
                       instance.private.check-non-forgetful-inheritance\n  =
                                          A19 A12, \n                      =
                     instance.private.declare-instance\n                   =
                         A12 A19 A18 A20 A3, \n                            =
               if (A4 =3D arity _) true \n                                 =
           (if-verbose\n                                              (head=
er A25 ,\n                                                coq.say A25 \n   =
                                              closing instance section) ,\n=
                                              log.coq.env.end-section-name =
A9), \n                                           acc-clauses current A20])=
.",
                 "rule_loc": [
                   "File",
                   {
-                    "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/lo=
g.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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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 =C2=ABinterleave_context.403=
=C2=BB)) (X96)",
+        "current_goal_text": "declare-evar [] (X97) (sort (typ =C2=ABinter=
leave_context.403=C2=BB)) (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 (de=
clare-evar A0 A1 A2 A3) \n                                [A1]).",
+                  "rule_text": "(declare-evar A0 A1 A2 A3) :- (declare_con=
straint (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 =
=C2=ABinterleave_context.403=C2=BB)) (X96)) [\n X97]",
+                "goal_text": "declare_constraint\n (declare-evar [] (X97) =
(sort (typ =C2=ABinterleave_context.403=C2=BB)) (X96)) [\n X97]",
                 "goal_id": 1256
               }
             ],
@@ -22528,8 +21457,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(declare-evar A0 A1 A2 A3) :- (declare_constraint (decl=
are-evar A0 A1 A2 A3) \n                                [A1]).",
+                "rule_text": "(declare-evar A0 A1 A2 A3) :- (declare_const=
raint (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 =3D ok ;=
 A2 =3D error A3 , std.fatal-error-w-data A1 A3), (!).",
+                "rule_text": "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (=
A2 =3D ok ; A2 =3D 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 =3D arity A7) \n                                            (if=
-verbose\n                                              (coq.say\n         =
                                       HB: skipping section opening)\n     =
                                         , A8 =3D A6) \n                   =
                         (,\n                                              =
(, (new_int A21) \n                                                (std.any=
->string A21 A22) \n                                                (A9 is =
hb_instance_ ^ A22)) \n                                              (log.c=
oq.env.begin-section A9) \n                                              (i=
nstance.private.postulate-arity\n                                          =
      A4 [] A6 A8 A7)), \n                                           std.as=
sert!\n                                            (coq.safe-dest-app A7 \n=
                                              (global A10) A11) \n         =
                                   The type of the instance is not a factor=
y, \n                                           factory-alias->gref A10 A12=
, \n                                           std.assert!\n               =
                             (factory-nparams A12 A13) \n                  =
                          Not a factory synthesized by HB, \n              =
                             instance.private.hack-section-discharging\n   =
                                         A8 A14, \n                        =
                   instance.private.optimize-body\n                        =
                    A14 A15, \n                                           i=
f (A0 =3D _) \n                                            (, (new_int A23)=
 \n                                              (std.any->string A23 A24) =
\n                                              (A16 is\n                  =
                              HB_unnamed_factory_ ^ A24)) \n               =
                             (A16 =3D A0), \n                              =
             log.coq.env.add-const-noimplicits-failondup\n                 =
                           A16 A15 A7 ff A17, \n                           =
                A18 =3D global (const A17), \n                             =
              std.drop A13 A11 [A19 | _], \n                               =
            instance.private.check-non-forgetful-inheritance\n             =
                               A19 A12, \n                                 =
          instance.private.declare-instance\n                              =
              A12 A19 A18 A20 A3, \n                                       =
    if (A4 =3D arity _) true \n                                            =
(if-verbose\n                                              (header A25 ,\n =
                                               coq.say A25 \n              =
                                   closing instance section) ,\n           =
                                   log.coq.env.end-section-name A9), \n    =
                                       acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std=
.do!\n                                          [std.assert-ok!\n          =
                                  (coq.elaborate-arity-skeleton A2 \n      =
                                        _ A4) Definition type illtyped, \n =
                                          coq.arity->term A4 A5, \n        =
                                   std.assert-ok!\n                        =
                    (coq.elaborate-skeleton A1 A5 A6) \n                   =
                         Definition illtyped, \n                           =
                if (A4 =3D arity A7) \n                                    =
        (if-verbose\n                                              (coq.say=
\n                                                HB: skipping section open=
ing)\n                                              , A8 =3D A6) \n        =
                                    (,\n                                   =
           (, (new_int A21) \n                                             =
   (std.any->string A21 A22) \n                                            =
    (A9 is hb_instance_ ^ A22)) \n                                         =
     (log.coq.env.begin-section A9) \n                                     =
         (instance.private.postulate-arity\n                               =
                 A4 [] A6 A8 A7)), \n                                      =
     std.assert!\n                                            (coq.safe-des=
t-app A7 \n                                              (global A10) A11) =
\n                                            The type of the instance is n=
ot a factory, \n                                           factory-alias->g=
ref A10 A12, \n                                           std.assert!\n    =
                                        (factory-nparams A12 A13) \n       =
                                     Not a factory synthesized by HB, \n   =
                                        instance.private.hack-section-disch=
arging\n                                            A8 A14, \n             =
                              instance.private.optimize-body\n             =
                               A14 A15, \n                                 =
          if (A0 =3D _) \n                                            (, (n=
ew_int A23) \n                                              (std.any->strin=
g A23 A24) \n                                              (A16 is\n       =
                                         HB_unnamed_factory_ ^ A24)) \n    =
                                        (A16 =3D A0), \n                   =
                        log.coq.env.add-const-noimplicits-failondup\n      =
                                      A16 A15 A7 ff A17, \n                =
                           A18 =3D global (const A17), \n                  =
                         std.drop A13 A11 [A19 | _], \n                    =
                       instance.private.check-non-forgetful-inheritance\n  =
                                          A19 A12, \n                      =
                     instance.private.declare-instance\n                   =
                         A12 A19 A18 A20 A3, \n                            =
               if (A4 =3D arity _) true \n                                 =
           (if-verbose\n                                              (head=
er A25 ,\n                                                coq.say A25 \n   =
                                              closing instance section) ,\n=
                                              log.coq.env.end-section-name =
A9), \n                                           acc-clauses current A20])=
.",
                 "rule_loc": [
                   "File",
                   {
-                    "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/lo=
g.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 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^ c0)) \n   =
                 (supported-attribute (att c7 attmap)) (!) \n              =
      (parse-attributes.aux c2 c3 c5) \n                    (pi (c8 \\ (sup=
ported-attribute (att c8 string) :- !)) =3D>\n                      parse-a=
ttributes.aux c1  c6) \n                    (std.append c5 [get-option c7 c=
6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [att verbose =
bool, att mathcomp bool, att mathcomp.axiom string, \n     att short.type s=
tring, att short.pack string, att infer attmap, \n     att key string, att =
arg_sort bool, att log bool, att log.raw bool, \n     att compress_coercion=
s bool, att export bool, att skip string, \n     att local bool, att fail b=
ool, att doc string, \n     att primitive_class bool, att primitive bool, \=
n     att non_forgetful_inheritance bool, att hnf bool] A2), (!), \n (A2 =
=3D> (save-docstring , A0)).",
+                "rule_text": "(with-attributes A0) :- (attributes A1), \n =
(pi (c0 \\\n   (pi (c1 \\\n     (pi (c2 \\\n       (pi (c3 \\\n         (pi=
 (c4 \\\n           (pi (c5 \\\n             (pi (c6 \\\n               (pi=
 (c7 \\\n                 (parse-attributes.aux [attribute c0 (node c1) | c=
2] c3 c4 :-\n                   , (if (c3 =3D ) (c7 =3D c0) (c7 is c3 ^ . ^=
 c0)) \n                    (supported-attribute (att c7 attmap)) (!) \n   =
                 (parse-attributes.aux c2 c3 c5) \n                    (pi =
(c8 \\ (supported-attribute (att c8 string) :- !)) =3D>\n                  =
    parse-attributes.aux c1  c6) \n                    (std.append c5 [get-=
option c7 c6] c4))))))))))))))))) =3D>\n   coq.parse-attributes A1 \n    [a=
tt verbose bool, att mathcomp bool, att mathcomp.axiom string, \n     att s=
hort.type string, att short.pack string, att infer attmap, \n     att key s=
tring, att arg_sort bool, att log bool, att log.raw bool, \n     att compre=
ss_coercions bool, att export bool, att skip string, \n     att local bool,=
 att fail bool, att doc string, \n     att primitive_class bool, att primit=
ive bool, \n     att non_forgetful_inheritance bool, att hnf bool] A2), (!)=
, \n (A2 =3D> (save-docstring , A0)).",
                 "rule_loc": [
                   "File",
                   {
-                    "filename":
-                      "/home/gares/MATHCOMP/hierarchy-builder/HB/common/ut=
ils.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-at=
tributes (with-logging (instance.declare-const A0 A1 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 =C2=ABin=
terleave_context.403=C2=BB)) (X96)) [\n X97]",
+        "suspend_goal_text": "declare_constraint\n (declare-evar [] (X97) =
(sort (typ =C2=ABinterleave_context.403=C2=BB)) (X96)) [\n X97]",
         "suspend_sibling": {
-          "goal_text":
-            "declare-evar [] (X97) (sort (typ =C2=ABinterleave_context.403=
=C2=BB)) (X96)",
+          "goal_text": "declare-evar [] (X97) (sort (typ =C2=ABinterleave_=
context.403=C2=BB)) (X96)",
           "goal_id": 1257
         },
         "suspend_stack": [
@@ -22734,8 +21652,7 @@
             "rule": [
               "UserRule",
               {
-                "rule_text":
-                  "(declare-evar A0 A1 A2 A3) :- (declare_constraint (decl=
are-evar A0 A1 A2 A3) \n                                [A1]).",
+                "rule_text": "(declare-evar A0 A1 A2 A3) :- (declare_const=
raint (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 =3D ok ;=
 A2 =3D error A3 , std.fatal-error-w-data A1 A3), (!).",
+                "rule_text": "(std.assert-ok! A0 A1) :- (A0 A2), (!), \n (=
A2 =3D ok ; A2 =3D 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 =3D arity A7) \n                                            (if=
-verbose\n                                              (coq.say\n         =
                                       HB: skipping section opening)\n     =
                                         , A8 =3D A6) \n                   =
                         (,\n                                              =
(, (new_int A21) \n                                                (std.any=
->string A21 A22) \n                                                (A9 is =
hb_instance_ ^ A22)) \n                                              (log.c=
oq.env.begin-section A9) \n                                              (i=
nstance.private.postulate-arity\n                                          =
      A4 [] A6 A8 A7)), \n                                           std.as=
sert!\n                                            (coq.safe-dest-app A7 \n=
                                              (global A10) A11) \n         =
                                   The type of the instance is not a factor=
y, \n                                           factory-alias->gref A10 A12=
, \n                                           std.assert!\n               =
                             (factory-nparams A12 A13) \n                  =
                          Not a factory synthesized by HB, \n              =
                             instance.private.hack-section-discharging\n   =
                                         A8 A14, \n                        =
                   instance.private.optimize-body\n                        =
                    A14 A15, \n                                           i=
f (A0 =3D _) \n                                            (, (new_int A23)=
 \n                                              (std.any->string A23 A24) =
\n                                              (A16 is\n                  =
                              HB_unnamed_factory_ ^ A24)) \n               =
                             (A16 =3D A0), \n                              =
             log.coq.env.add-const-noimplicits-failondup\n                 =
                           A16 A15 A7 ff A17, \n                           =
                A18 =3D global (const A17), \n                             =
              std.drop A13 A11 [A19 | _], \n                               =
            instance.private.check-non-forgetful-inheritance\n             =
                               A19 A12, \n                                 =
          instance.private.declare-instance\n                              =
              A12 A19 A18 A20 A3, \n                                       =
    if (A4 =3D arity _) true \n                                            =
(if-verbose\n                                              (header A25 ,\n =
                                               coq.say A25 \n              =
                                   closing instance section) ,\n           =
                                   log.coq.env.end-section-name A9), \n    =
                                       acc-clauses current A20]).",
+                "rule_text": "(instance.declare-const A0 A1 A2 A3) :- (std=
.do!\n                                          [std.assert-ok!\n          =
                                  (coq.elaborate-arity-skeleton A2 \n      =
                                        _ A4) Definition type illtyped, \n =
                                          coq.arity->term A4 A5, \n        =
                                   std.assert-ok!\n                        =
                    (coq.elaborate-skeleton A1 A5 A6) \n                   =
                         Definition illtyped, \n                           =
                if (A4 =3D arity A7) \n                                    =
        (if-verbose\n                                              (coq.say=
\n                                                HB: skipping section open=
ing)\n                                              , A8 =3D A6) \n        =
                                    (,\n                                   =
           (, (new_int A21) \n                                             =
   (std.any->string A21 A22) \n                                            =
    (A9 is hb_instance_ ^ A22)) \n                                         =
     (log.coq.env.begin-section A9) \n                                     =
         (instance.private.postulate-arity\n                               =
                 A4 [] A6 A8 A7)), \n                                      =
     std.assert!\n                                            (coq.safe-des=
t-app A7 \n                                              (global A10) A11) =
\n                                            The type of the instance is n=
ot a factory, \n                                           factory-alias->g=
ref A10 A12, \n                                           std.assert!\n    =
                                        (factory-nparams A12 A13) \n       =
                                     Not a factory synthesized by HB, \n   =
                                        instance.private.hack-section-disch=
arging\n                                            A8 A14, \n             =
                              instance.private.optimize-body\n             =
                               A14 A15, \n                                 =
          if (A0 =3D _) \n                                            (, (n=
ew_int A23) \n                                              (std.any->strin=
g A23 A24) \n                                              (A16 is\n       =
                                         HB_unnamed_factory_ ^ A24)) \n    =
                                        (A16 =3D A0), \n                   =
                        log.coq.env.add-const-noimplicits-failondup\n      =
                                      A16 A15 A7 ff A17, \n                =
                           A18 =3D global (const A17), \n                  =
                         std.drop A13 A11 [A19 | _], \n                    =
                       instance.private.check-non-forgetful-inheritance\n  =
                                          A19 A12, \n                      =
                     instance.private.declare-instance\n                   =
                         A12 A19 A18 A20 A3, \n                            =
               if (A4 =3D arity _) true \n                                 =
           (if-verbose\n                                              (head=
er A25 ,\n                                                coq.say A25 \n   =
                                              closing instance section) ,\n=
                                              log.coq.env.end-section-name =
A9), \n                                           acc-clauses current A20])=
.",
                 "rule_loc": [
                   "File",
                   {
-                    "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/lo=
g.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&