Add a serde feature flag + support serializing to/from JSON

[statusfailed]

... should have the same representation for both lax/strict open hypergraphs (except lax comes with an extra field - the quotient array).

Require node/edge labels to be serializable as well.

[colltoaction]

Hi! I found this issue and would like to invite you to consider HIF the Hypergraph Interchange Format. The HIF standard defines a JSON schema for well-known network types, currently abstract simplicial complexes, hypergraphs and directed hypergraphs. It is a project coming from the Higher-Order Network Science community that would benefit quite a lot from interacting with Category Theorists.

First I would like to understand if the standard fits your requirements, and second invite you to give feedback from your perspective, including suggesting changes to the standard to support more use cases.

Cheers!

[statusfailed]

@colltoaction I had a quick look at your link. I don't see how we can encode directed hypergraphs whose edges are pairs of ordered lists in this format. Can you clarify?

[colltoaction]

Thank you for taking the time! If I understand correctly from the docs, you would need the set of head and tail incidences that make an edge to also have an internal ordering, represented in this case by its index in the vector (note for self: it is a structure different than an ordered hypergraph). This is only implicitly supported today using custom incidence attributes.

It can be as simple as including a "key" attribute in the incidence entries, along with the validation of such information. For example, the implementation can check for keys to be sequential and starting from 0. Or maybe numbers need not be sequential. Or maybe it also needs to support strings.

In any case, it is desired to extend the standard, especially if we get feedback from real-world scenarios with working implementations. To do this we collaborate in the HIF repo, e.g we started discussing the Temporal aspect here: HIF-org/HIF-standard#44. You're very welcome to participate in the HIF development!

Let me know if I can give you more info, or anything I missed to help your decision.

---

Let me cite part of the recently released manuscript for more context:

while the HIF standard directly supports undirected and directed hypergraphs and abstract simplicial complexes, support for additional higher-order representations will make HIF more widely useful. Examples include hypergraphs with ordered and partially ordered sets (posets) which are useful in legal analysis (Coupette) and the Science of Science. Several types of higher-order networks are implicitly supported by the HIF standard: signed hypergraphs which assign a sign +/- to each hyperedge; multilayer hypergraphs which assign nodes and hyperedges to different layers representing, for example, modes of transportation, relationship types, or social media platforms; and temporal hypergraphs where nodes and hyperedges have associated time intervals in which they are active. The specific structural information necessary for each of these representations can be stored in the attrs field, but the schema excludes these as expected JSON fields. In the future, adding explicit support for these fields will improve compatibility with libraries such as ASH (Failla), Raphtory (Steer), and Reticula (Badie-Modiri).

[statusfailed]

If it helps as real-world feedback, here's a description of the hypergraph datastructure we use -- we also use this library in catgrad.
Specifically, it's the columnar version of the datastructure used in the python implementation and the Rust version's strict module. I'll give all the details because the columnar format is fairly minimal.

Encode NodeId and EdgeId as unsigned integers. A Hypergraph with N nodes and E edges is:

w: a length `N` array of node labels
x: a length `E` array of edge labels
s: a segmented array of edge sources
t: a segmented array of edge targets

Here, a segmented array with K segments is:

sources: an array of unsigned integers of length K
values: an array of NodeId of length sum(sources)

I'll write a segmented array by using | to denote segments instead of explicitly writing out sources. So for example, i'll write:

sources = [ 2 1 ]
values  = [ 0 1 2 ]

As

      segment boundary, computed by cumulative sum of sources
      |
      v

[ 0 1 | 2 ]

So for example, a hypergraph containing a single 2 → 1 operation labeled "Add" with nodes labeled [A, B, C] would be encoded as:

w = [A, B, C]
x = ["Add"]
s = [ 0 1 ] // note: only one segment here
t = [ 2 ]

Then an Open Hypergraph with A sources and B targets is:

sources: A length-M array of NodeId
targets: A length-N array of NodeId
hypergraph: a Hypergraph

The open hypergraph simply adds two arrays (sources/targets) identifying the global inputs and outputs.
Note that a node can appear multiple times in both sources and targets.
For example, we could have a hypergraph with no edges, and a single node (0) with sources/targets:

sources: [0 0 0 0 0]
targets [0 0 0 0]

The specifics of our representation are not super important for interchange (actually we have a slightly different JSON format), but I'm hoping this helps as some real-world use-cases!