Supplemental material for the paper "Bridging ML and algorithms: comparison of hyperbolic embeddings" (ICLR 2026)

Post-conference fixes
=====================

We have found the following issues while preparing our poster:

- `Human2`, `Human8` and `Macaque4` connectomes were loaded incorrectly (fixed scripts/convert-graphs.str.cpp)
- HMCS was not actually used on the `yeast` graph
- TreeRep results were missing on the `astroph` and `hepph` graphs
- updated the RogueViz engine to the current version
- the visualize script (`scripts/visualize.sh`) was outdated -- this script is improved now
- included the visualization of papers that was shown on the poster (run `scripts/visualize-papers.sh`, the files are available as the graph `papers`)
- Readme said "After the paper is accepted, full data will be available on a repository such as FigShare." but we did not actually do so

Projects included:
==================

The core of our comparison framework is built on RogueViz ( https://github.com/zenorogue/hyperrogue ). This framework implements the DHRG and Anneal algorithms.
Our changes have been pushed to the official repo; we include the version used by us in the attachment.

- some irrelevant part of the repo were removed
- the C++ source code specifically for the comparison framework is in rogueviz/embeddings/
- some of the contents of rogueviz/embeddings/ is based on code which was previously in the repo in dhrg/, sag/ or rogueviz folders
  (this includes: loglik computation, map/meanrank computation, some commandline commands, reading graphs in BFKL polar format)

Other projects included:

hyperbolic-embedder: from https://bitbucket.org/HaiZhung/hyperbolic-embedder/overview (commit 3ade6d7d67188b0ab82949397ea5da62e4d9c845, 2018-05-02)
poincare-embeddings: from https://github.com/facebookresearch/poincare-embeddings (commit ff1d846db3a64a759e56173d7846c164a37654f9, 2021-09-16)
mercator: from https://github.com/networkgeometry/mercator (commit a5dd4a05f4d77f92c32ee7750efd450cee0d3014, 2022-06-21)
TreeRep: from https://github.com/rsonthal/TreeRep (commit 8ed4d830b5d0da41aeecf786d5be650ed75b8d59, 2023-06-22)
HyperbolicTiling_Learning: from https://github.com/ydtydr/HyperbolicTiling_Learning (commit c77f0d1a1b32ed5437a59d7cdeb8426ff03ea70b, 2020-03-19)
hypviewer: from https://graphics.stanford.edu/~munzner/h3/download.html (not git -- last modified in 2003)
d-mercator: from https://github.com/networkgeometry/d-mercator (commit 45e71880b8744ba4e9e87c3db5e6675551cbf200, 2023-10-17)
kvk: from https://bitbucket.org/dk-lab/2020_code_hyperlink/src/master/ (commit 31b65ce7545e226f62dcfeddb04043aeb149866d, 2021-06-11)
coalescent_embedding: from https://github.com/biomedical-cybernetics/coalescent_embedding (commit 842a1dae06f8bb4a7c26a7d64f25285f55d4c1e6, 2019-08-07)
hypCLOVE: from https://github.com/samu32ELTE/hypCLOVE (commit dbab9523af758500ef2e76c1aed6b1a0db4444fb, 2025-10-16)
LPCS: from https://www.sciencedirect.com/science/article/pii/S0378437116000182

See `diffs` for the changes from the original commits listed above. We have done: (also some files included in the repo such as datasets and helper tools are not removed)

In hyperbolic-embedder:
- fix a compilation error on newer C++

In poincare-embeddings:
- add a CLI option `-initial` (not actually used in the final paper)
- create kx-evaluate.py, mostly to evaluate embeddings using MAP
  (including BFKL embedding, but as mentioned in the paper, it did not work due to numerical precision errors) and export embeddings to a format recognized by DHRG
- create wordnets/transitive_closure_verb.py to export the verb hierarchy by analogy to wordnets/transitive_closure.py
- an option to change the seed via the `SEED` environmental variable (not discussed in the paper)

In HyperbolicTiling_Learning:
- remove HalfspaceManifold which was referred to but seems not actually present in the repo; also train-grqc.py refers to `group_rie` which is not available
- added an option to produce a table of distances that can be analyzed using other tools (specifically we use dhrg)

In TreeRep:
- implemented `experiment.jl` which runs the experiments and outputs

In kvk:
- the embedder accedts the nodes to be indexed with numbers -- adapted the embedder to work with more general node names
- implemented `bridging-hyperlink.sh` script which runs the experiments and outputs

In coalescent_embedding:
- we have been running this embedder using GNU Octave instead of Matlab. However, Octave does not include the `graphallshortestpaths` function,
  so we have writen a C program scripts/graph-to-matlab.cpp which takes a graph on input and produces the file `coalescent_embedding/usage_example/graphallshortestpaths.m`
  containing the shortest path matrix for the given graph.
- octave with packages statistics and symbolic should be installed (in octave, run `pkg install -forge symbolic statistics`

In mercator/d-mercator:
- the version of Eigen included does not compile in newer g++ -- due to a template function which does not seem to be used, so it is commented out

In LPCS:
- added `louvain-community.R` which performs the first step, as explained in readme.txt
- some other changes
- fixed some warnings reported by Octave
- made it work when there are only two communities

Since the official implementation ran very slow in Octave, we have also reimplemented the algorithm in C++ (script/lpcs-remake.cpp).
Our reimplementation fixes a bug in ConnectNextCom.m (which compares the intimacies of x(1) and x(2), while, according to the paper,
intimacies of the first and last subcommunity in x should be compared here).

In hypCLOVE:
- added `import-clove.py` which read the graphs and calls hypCLOVE proper
- changed hypCLOVE to work even if estimated b is greater than 1 (by assuming 1 instead)

Datasets included: (graphs/*/graph-orig.txt)
astroph, condmat, grqc, hepph, facebook: from http://snap.stanford.edu/data/
brain maps data: https://github.com/networkgeometry/navigable_brain_maps_data

Our setup and compute
=====================

Hardware:
[1] Intel(R) Core(TM) i7-9700K CPU @ 3.60GHz, NVIDIA GeForce GTX 1060 6GB/PCIe/SSE2
[2] 11th Gen Intel(R) Core(TM) i7-11850H @ 2.50GHz, OpenGL renderer string: NVIDIA RTX A3000 Laptop GPU/PCIe/SSE2

Software: Arch Linux, g++, older experiments: 12.2.1, newer experiments: 15.2.1

The times reported in the paper have been obtained on [1]. Some experiments have been run on [2].

The total time of all computations (as reported in log.txt) is about 3608 hours. There were some computations that were aborted (due to bugs) but they were a minority.

Files omitted
=============

Due to the filesize limits for the supplemental material, we had to omit a part of files. These include:

- the results of LTiling and TreeRep (disttables 1972 MB + treerep 8870 MB)
- embeddings generated by Poincare/Lorentz (2321 MB)
- Euclidean embeddings (50D: 166 MB*, 200D: 687 MB)
- a part of data regarding repeated experiments (909 MB*)
- hypviewer embeddings (26 MB*), rogueviz coordinates (5 MB*)
- various intermediate files: (bfkl links 215 MB, coalescent embeddings 148 MB)
- most files regarding simulated networks, except time logs and summaries (2293 MB*)
- experiments on other kinds of simulated networks which are not included in the paper

The files marked with (*) can be found in the full version of the package, uploaded to FigShare:
https://figshare.com/articles/dataset/Supplemental_material_for_the_paper_Bridging_ML_and_algorithms_comparison_of_hyperbolic_embeddings_ICLR_2026_/32228532

How to reproduce:
=================

Note: scripts are designed to be called from the main directory. (e.g. `bash scripts/compile-all.sh` not `cd scripts; bash compile-all.sh`)

- create and activate the poincare environment, as described in poincare-embeddings/README.org
- compile all included projects (`bash scripts/compile-all.sh`)
- convert graphs/*/graph-orig.txt to the correct formats graphs/*/graph.txt and graphs/*/graph.csv (`bash scripts/read-networks.sh`)
- create WordNet hierarchies and convert them to the correct formats (`bash scripts/hierarchies.sh`)
- perform the experiments (for example: `bash scripts/process.sh -bfkl-embed-bfkl-eval- name`, replacing `name` with every graph in graphs; give the steps from process.sh as required)
- build the tables `tables/*.tex` using `bash scripts/generate-rw-table.sh` and `bash scripts/generate-rep-table.sh`
- generate simulated networks: `bash scripts/sim-generate.sh`
- compute the experiments on simulated networks: `STEPS=[...] bash scripts/simulate.sh` (replace [...] with wanted steps)
- build the CSV data `tables/statistical-data.csv` using `bash scripts/generate-for-table.sh`
- compute the precise BFKL time data `tables/precise-times.csv` using `bash scripts/compute-precise-simulated-times.sh bp`
- scripts/analysis.R was used to create the graphs and statistical analysis

Explanation of files:
=====================

In graphs/[graph name]:
- `graph-orig.txt`: original data from the source
- `graph.txt`: data in the BFKL format
- `graph.csv`: data in the poincare-embeddings format
- `notrans.txt`: for hierarchies, edges without transitive closure (created by `scripts/create-notrans.sh`, used by the visualizer `scripts/visualize.sh`)

In results/[graph name]:
- `log.txt` logs all times
- `log-*.txt` contain the output of various steps
- `*.bin` and `*.bin.best` are embeddings obtained from poincare-embeddings
- `*-coordinates.txt` are various embeddings; BFKL also produces `bfkl-links.txt` which is used by other dhrg evaluations for convenience
- `*-dhrg.txt` are these embeddings improved by BFKL

Extra explanation:
==================

This code & data appendix includes some methods and graphs which are not explained in the main paper. For completeness, we explain them here.

The 'landscape' embedding method is a method of transforming hyperbolic embeddings into high-dimensional Euclidean embeddings. It is based on the 'landscape' method from [1].
We have devised this method to improve on the very low results on Euclidean embeddings reported by [Nickel and Kiela 2017]; while our method did indeed get better
results, it turned out that the Euclidean embedder from [Nickel and Kiela 2017] actually gets much better results than reported (and also the landscape results), 
thus reducing the signifance of our result.

The 'rogueviz' embedding method is the basic hierarchy embedder implemented in the RogueViz library.

The 'sim3' graphs are three-dimensional artificially constructed networks. While MAP/MeanRank/greedy quality measures will always favor higher-dimensional embeddings,
we expect that ICV will favor the actual dimension, e.g., 2 for two-dimensional artificial networks and 3 for three-dimensional artificial networks. However, this is
beyond the scope of the paper under review.

[1] Non-Euclidean Self-Organizing Maps. Dorota Celinska-Kopczynska, Eryk Kopczynski. Proceedings of the Thirty-First International Joint Conference on Artificial Intelligence (IJCAI-22).
https://www.ijcai.org/proceedings/2022/0269.pdf

