spiderize_nodes: spiderize a subset of nodes

Author: statusfailed

src/lax/spider.rs

@@ -37,8 +37,45 @@ impl<O: Clone + PartialEq, A: Clone> OpenHypergraph<O, A> {
     /// means that the quotient attempted to identify nodes with different
     /// labels; the returned finite function is the quotient witness, as for
     /// [`OpenHypergraph::quotient`].
-    pub fn spiderize(mut self) -> Result<OpenHypergraph<O, WithSpider<A>>, FiniteFunction> {
-        self.quotient()?;
+    pub fn spiderize(self) -> Result<OpenHypergraph<O, WithSpider<A>>, FiniteFunction> {
+        let nodes: Vec<NodeId> = (0..self.hypergraph.nodes.len()).map(NodeId).collect();
+        self.spiderize_nodes(&nodes)
+    }
+
+    /// Replace the chosen nodes' implicit wiring with explicit spider
+    /// operations.
+    ///
+    /// Each selected node is replaced by the same pair of spiders used by
+    /// [`Self::spiderize`]. Unselected nodes retain their implicit wiring.
+    /// Consequently, unlike [`Self::spiderize`], this operation does not by
+    /// itself guarantee that the result is acyclic or monogamous.
+    ///
+    /// `nodes` contains IDs from the input hypergraph. Pending identifications
+    /// are applied first, and IDs in `nodes` are mapped through the resulting
+    /// quotient. Selecting any representative therefore selects its complete
+    /// equivalence class. Duplicate selections are ignored.
+    ///
+    /// # Panics
+    ///
+    /// Panics if a selected node ID is out of bounds.
+    pub fn spiderize_nodes(
+        mut self,
+        nodes: &[NodeId],
+    ) -> Result<OpenHypergraph<O, WithSpider<A>>, FiniteFunction> {
+        let input_node_count = self.hypergraph.nodes.len();
+        for node in nodes {
+            assert!(
+                node.0 < input_node_count,
+                "node id {:?} is out of bounds",
+                node
+            );
+        }
+
+        let quotient = self.quotient()?;
+        let mut selected = vec![false; quotient.target];
+        for node in nodes {
+            selected[quotient.table[node.0]] = true;
+        }
 
         let OpenHypergraph {
             sources,
@@ -75,19 +112,27 @@ impl<O: Clone + PartialEq, A: Clone> OpenHypergraph<O, A> {
                 .sources
                 .into_iter()
                 .map(|node| {
-                    let occurrence = result.new_node(hypergraph.nodes[node.0].clone());
-                    left_targets[node.0].push(occurrence);
-                    occurrence
+                    if selected[node.0] {
+                        let occurrence = result.new_node(hypergraph.nodes[node.0].clone());
+                        left_targets[node.0].push(occurrence);
+                        occurrence
+                    } else {
+                        central[node.0]
+                    }
                 })
                 .collect();
 
             let operation_targets = adjacency
                 .targets
                 .into_iter()
                 .map(|node| {
-                    let occurrence = result.new_node(hypergraph.nodes[node.0].clone());
-                    right_sources[node.0].push(occurrence);
-                    occurrence
+                    if selected[node.0] {
+                        let occurrence = result.new_node(hypergraph.nodes[node.0].clone());
+                        right_sources[node.0].push(occurrence);
+                        occurrence
+                    } else {
+                        central[node.0]
+                    }
                 })
                 .collect();
 
@@ -103,27 +148,40 @@ impl<O: Clone + PartialEq, A: Clone> OpenHypergraph<O, A> {
         result.sources = sources
             .into_iter()
             .map(|node| {
-                let occurrence = result.new_node(hypergraph.nodes[node.0].clone());
-                left_sources[node.0].push(occurrence);
-                occurrence
+                if selected[node.0] {
+                    let occurrence = result.new_node(hypergraph.nodes[node.0].clone());
+                    left_sources[node.0].push(occurrence);
+                    occurrence
+                } else {
+                    central[node.0]
+                }
             })
             .collect();
 
         result.targets = targets
             .into_iter()
             .map(|node| {
-                let occurrence = result.new_node(hypergraph.nodes[node.0].clone());
-                right_targets[node.0].push(occurrence);
-                occurrence
+                if selected[node.0] {
+                    let occurrence = result.new_node(hypergraph.nodes[node.0].clone());
+                    right_targets[node.0].push(occurrence);
+                    occurrence
+                } else {
+                    central[node.0]
+                }
             })
             .collect();
 
-        for (((left_sources, left_targets), right_sources), right_targets) in left_sources
+        for (node, (((left_sources, left_targets), right_sources), right_targets)) in left_sources
             .into_iter()
             .zip(left_targets)
             .zip(right_sources)
             .zip(right_targets)
+            .enumerate()
         {
+            if !selected[node] {
+                continue;
+            }
+
             result.new_edge(
                 WithSpider::Spider {
                     sources: left_sources.len(),

tests/lax/spider.rs

@@ -139,6 +139,42 @@ fn spiderize_rejects_inconsistent_quotients() {
     assert!(f.spiderize().is_err());
 }
 
+#[test]
+fn spiderize_nodes_only_replaces_selected_nodes() {
+    let mut f = OpenHypergraph::empty();
+    let x = f.new_node(());
+    let y = f.new_node(());
+    f.new_edge("forward", ([x], [y]));
+    f.new_edge("backward", ([y], [x]));
+
+    let original = f.clone();
+    let spiderized = f.spiderize_nodes(&[x]).unwrap();
+
+    assert_eq!(
+        spiderized
+            .hypergraph
+            .edges
+            .iter()
+            .filter(|edge| matches!(edge, WithSpider::Spider { .. }))
+            .count(),
+        2
+    );
+    assert!(spiderized.clone().to_strict().is_acyclic());
+    assert_eq!(forget_spiders(spiderized), original);
+}
+
+#[test]
+fn spiderize_nodes_maps_selections_through_quotient() {
+    let mut f = OpenHypergraph::<(), ()>::empty();
+    let x = f.new_node(());
+    let y = f.new_node(());
+    f.unify(x, y);
+
+    let spiderized = f.spiderize_nodes(&[y, y]).unwrap();
+
+    assert_eq!(spiderized.hypergraph.edges.len(), 2);
+}
+
 proptest! {
     #[test]
     fn spiderize_is_acyclic_monogamous_and_forgetful(
@@ -159,4 +195,19 @@ proptest! {
         );
         assert_eq!(forget_spiders(spiderized), input);
     }
+
+    #[test]
+    fn spiderize_delegates_to_spiderize_nodes(
+        strict_input in arb_open_hypergraph()
+    ) {
+        let input: OpenHypergraph<Obj, Arr> =
+            OpenHypergraph::from_strict(strict_input);
+        let nodes: Vec<NodeId> =
+            (0..input.hypergraph.nodes.len()).map(NodeId).collect();
+
+        assert_eq!(
+            input.clone().spiderize().unwrap(),
+            input.spiderize_nodes(&nodes).unwrap()
+        );
+    }
 }