move graph::converse to new relation module...

... and make public.

This is a generic method on IndexedCoproducts thought of as encoding
relations, and was used in some downstream projects.

Author: statusfailed

src/strict/eval.rs

@@ -5,9 +5,9 @@ use crate::finite_function::*;
 use crate::indexed_coproduct::*;
 use crate::semifinite::*;
 
-use crate::strict::graph::converse;
 use crate::strict::layer::layer;
 use crate::strict::open_hypergraph::*;
+use crate::strict::relation::converse;
 
 use num_traits::Zero;
 use std::default::Default;

src/strict/graph.rs

@@ -1,48 +1,11 @@
-use crate::array::{Array, ArrayKind, NaturalArray, OrdArray};
+use super::relation::converse;
+use crate::array::{Array, ArrayKind, NaturalArray};
 use crate::category::Arrow;
 use crate::finite_function::FiniteFunction;
-use crate::indexed_coproduct::HasLen;
 use crate::indexed_coproduct::IndexedCoproduct;
 use crate::strict::hypergraph::Hypergraph;
 use num_traits::{One, Zero};
 
-/// Compute the *converse* of an [`IndexedCoproduct`] thought of as a "multirelation".
-///
-/// An [`IndexedCoproduct`] `c : Σ_{x ∈ X} s(x) → Q` can equivalently be thought of as `c : X →
-/// Q*`, i.e. a mapping from X to finite lists of elements in Q.
-///
-/// Such a list defines a (multi-)relation as the multiset of pairs
-///
-/// `R = { ( x, f(x)_i ) | x ∈ X, i ∈ len(f(x)) }`
-///
-/// This function computes the *converse* of that relation as an indexed coproduct
-/// `converse(c) : Q → X*`, or more precisely
-/// `converse(c) : Σ_{q ∈ Q} s(q) → X`.
-///
-/// NOTE: An indexed coproduct does not uniquely represent a 'multirelation', since *order* of the
-/// elements matters.
-/// The result of this function is only unique up to permutation of the sublists.
-pub(crate) fn converse<K: ArrayKind>(
-    r: &IndexedCoproduct<K, FiniteFunction<K>>,
-) -> IndexedCoproduct<K, FiniteFunction<K>>
-where
-    K::Type<K::I>: NaturalArray<K>,
-{
-    let values_table = {
-        let arange = K::Index::arange(&K::I::zero(), &r.sources.len());
-        let unsorted_values = r.sources.table.repeat(arange.get_range(..));
-        unsorted_values.sort_by(&r.values.table)
-    };
-
-    let sources_table =
-        (r.values.table.as_ref() as &K::Type<K::I>).bincount(r.values.target.clone());
-
-    let sources = FiniteFunction::new(sources_table, r.values.table.len() + K::I::one()).unwrap();
-    let values = FiniteFunction::new(values_table, r.len()).unwrap();
-
-    IndexedCoproduct::new(sources, values).unwrap()
-}
-
 /// Return the adjacency map for a [`Hypergraph`] `h`.
 ///
 /// If `X` is the finite set of operations in `h`, then `operation_adjacency(h)` computes the

src/strict/mod.rs

@@ -10,6 +10,7 @@ pub mod eval;
 pub mod functor;
 pub mod graph;
 pub mod layer;
+pub mod relation;
 
 pub use crate::array::*;
 pub use crate::category::*;

src/strict/relation.rs

@@ -0,0 +1,42 @@
+//! Indexed coproducts as relations
+use crate::array::{Array, ArrayKind, NaturalArray, OrdArray};
+use crate::finite_function::FiniteFunction;
+use crate::indexed_coproduct::{HasLen, IndexedCoproduct};
+use num_traits::{One, Zero};
+
+/// Compute the *converse* of an [`IndexedCoproduct`] thought of as a "multirelation".
+///
+/// An [`IndexedCoproduct`] `c : Σ_{x ∈ X} s(x) → Q` can equivalently be thought of as `c : X →
+/// Q*`, i.e. a mapping from X to finite lists of elements in Q.
+///
+/// Such a list defines a (multi-)relation as the multiset of pairs
+///
+/// `R = { ( x, f(x)_i ) | x ∈ X, i ∈ len(f(x)) }`
+///
+/// This function computes the *converse* of that relation as an indexed coproduct
+/// `converse(c) : Q → X*`, or more precisely
+/// `converse(c) : Σ_{q ∈ Q} s(q) → X`.
+///
+/// NOTE: An indexed coproduct does not uniquely represent a 'multirelation', since *order* of the
+/// elements matters.
+/// The result of this function is only unique up to permutation of the sublists.
+pub fn converse<K: ArrayKind>(
+    r: &IndexedCoproduct<K, FiniteFunction<K>>,
+) -> IndexedCoproduct<K, FiniteFunction<K>>
+where
+    K::Type<K::I>: NaturalArray<K>,
+{
+    let values_table = {
+        let arange = K::Index::arange(&K::I::zero(), &r.sources.len());
+        let unsorted_values = r.sources.table.repeat(arange.get_range(..));
+        unsorted_values.sort_by(&r.values.table)
+    };
+
+    let sources_table =
+        (r.values.table.as_ref() as &K::Type<K::I>).bincount(r.values.target.clone());
+
+    let sources = FiniteFunction::new(sources_table, r.values.table.len() + K::I::one()).unwrap();
+    let values = FiniteFunction::new(values_table, r.len()).unwrap();
+
+    IndexedCoproduct::new(sources, values).unwrap()
+}

src/strict/tests/layer.rs

@@ -2,9 +2,10 @@ use crate::array::vec::*;
 use crate::finite_function::*;
 use crate::indexed_coproduct::*;
 use crate::semifinite::*;
-use crate::strict::graph::{converse, indegree, operation_adjacency};
+use crate::strict::graph::{indegree, operation_adjacency};
 use crate::strict::layer::layer;
 use crate::strict::open_hypergraph::*;
+use crate::strict::relation::converse;
 
 #[derive(Clone, PartialEq, Debug)]
 pub enum Arr {