ADD dag library

This commit is contained in:
Nathan Dwarshuis 2022-01-06 23:58:57 -05:00
parent b352d37a3b
commit b68326cb72
2 changed files with 772 additions and 0 deletions

438
local/lib/dag/dag.el Normal file
View File

@ -0,0 +1,438 @@
;;; dag.el --- Functions for directed acyclic graphs -*- lexical-binding: t; -*-
;; Copyright (C) 2021 Nathan Dwarshuis
;; Author: Nathan Dwarshuis <natedwarshuis@gmail.com>
;; Keywords: tools
;; Package-Requires: ((emacs "27.2") (dash "2.18"))
;; Version: 0.0.1
;; This program is free software; you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation, either version 3 of the License, or
;; (at your option) any later version.
;; This program is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;; GNU General Public License for more details.
;; You should have received a copy of the GNU General Public License
;; along with this program. If not, see <http://www.gnu.org/licenses/>.
;;; Commentary:
;; DAGs and stuff
;;; Code:
(require 'ht)
(require 'dash)
(defun dag--ht-create (what)
"Create a hash table.
Hash table will always be created with the `equal' test.
The type of WHAT will determine how the hash table is build:
- number: allocate a certain size
- nul: allocate an empty hash table
- anything else: assume its an alist and allocate with that"
(cond
((null what) (ht-create #'equal))
((numberp what) (make-hash-table :size what :test #'equal))
(t (ht<-alist what #'equal))))
(defun dag--plist-cons (plist prop x)
(plist-put plist prop (cons x (plist-get plist prop))))
(defun dag--plist-remove (plist prop x)
(plist-put plist prop (remove x (plist-get plist prop))))
(defun dag--adjlist-remove-edge (which key edge adjlist)
(ht-set adjlist key (dag--plist-remove (ht-get adjlist key) which edge)))
(defun dag--adjlist-add-edge (which key edge adjlist)
(ht-set adjlist key (dag--plist-cons (ht-get adjlist key) which edge)))
(defun dag--adjlist-remove-child-edge (key edge adjlist)
(dag--adjlist-remove-edge :children key edge adjlist))
(defun dag--adjlist-remove-parent-edge (key edge adjlist)
(dag--adjlist-remove-edge :parents key edge adjlist))
(defun dag--adjlist-add-parent-edge (key edge adjlist)
(dag--adjlist-add-edge :parents key edge adjlist))
(defun dag--adjlist-add-child-edge (key edge adjlist)
(dag--adjlist-add-edge :children key edge adjlist))
(defun dag--ht-cons (h k x)
(ht-set h k (cons x (ht-get h k))))
(defun dag--ht-remove (h k x)
(ht-set h k (remove x (ht-get h k))))
(defun dag--adjlist-get-relationships (key adjlist)
(ht-get adjlist key))
(defun dag--relationship-get-children (rel)
(plist-get rel :children))
(defun dag--relationship-get-parents (rel)
(plist-get rel :parents))
(defun dag--adjlist-get-children (key adjlist)
(->> (ht-get adjlist key)
(dag--relationship-get-children)))
(defun dag--adjlist-get-parents (key adjlist)
(->> (ht-get adjlist key)
(dag--relationship-get-parents)))
(defun dag--new-relationship (p c)
(list :parents p :children c))
(defmacro dag--each-key (h &rest body)
(declare (indent 1))
`(--each (ht-keys ,h) ,@body))
(defun dag--get-topological-order (adjlist)
;; this is just Kahn's algorithm
(let ((parent-degrees (dag--ht-create (ht-size adjlist)))
(node-queue)
(ordered-nodes)
(cur-node)
(cur-degree))
;; TODO is there a way to do this without making a new hash table?
;; Get parent degrees and init the node queue with root nodes (those with
;; parent degree of zero)
(dag--each-key adjlist
(setq cur-degree (length (dag--adjlist-get-parents it adjlist)))
(ht-set parent-degrees it cur-degree)
(when (= 0 cur-degree)
(!cons it node-queue)))
;; Traverse down the DAG starting at the root node(s). When encountering a
;; child, reduce the parent degrees of that child by one an add it to the
;; end of the node queue. Continue until the node queue is empty.
(while node-queue
(setq cur-node (car node-queue))
(!cdr node-queue)
(!cons cur-node ordered-nodes)
(--each (dag--adjlist-get-children cur-node adjlist)
(setq cur-degree (1- (ht-get parent-degrees it)))
(ht-set parent-degrees it cur-degree)
(when (= 0 cur-degree)
(setq node-queue (-snoc node-queue it)))))
;; If all parent degrees have been reduced to 0, then return order as this
;; is a valid DAG. NOTE: if the DAG is invalid the parent degrees don't tell
;; us which nodes have cycles.
(when (--all-p (= 0 it) (ht-values parent-degrees))
(nreverse ordered-nodes))))
(defun dag--get-floating (adjlist)
;; Find 'floating nodes', which are nodes that have no children or parents
;; (this will happen if the original alist has node keys that aren't
;; referenced by any parents).
;;
;; O(N)
(let ((acc (dag--ht-create nil))
cur)
(dag--each-key adjlist
(setq cur (ht-get adjlist it))
(unless (or (plist-get cur :children) (plist-get cur :parents))
(ht-remove adjlist it)
(ht-set acc it t)))
(list adjlist acc)))
(defun dag--alist-to-ht (parent-adjlist)
(let ((h (dag--ht-create parent-adjlist))
(broken-edges (dag--ht-create nil))
(parents)
(relations)
(parent-relations)
(cur))
;; Convert alist to initial hash table by making each value a plist with
;; parent and child connections
;;
;; O(N)
(while parent-adjlist
(setq cur (car parent-adjlist))
(ht-set h (car cur) (dag--new-relationship (cdr cur) nil))
(!cdr parent-adjlist))
;; Add child relationships: For each node key, get the parent relation keys,
;; and for each of these, lookup the key in the hash table and add the
;; parent relation key to the child relation keys of the lookup key. If this
;; fails (eg a node is linked to a parent that doesn't exist) remove this
;; key from the parent relations list and add the node key and parent key to
;; a list of 'broken' parent edges.
;;
;; O(E+N)
(--each (ht-keys h)
(setq relations (ht-get h it)
parents (plist-get relations :parents))
(while parents
(setq cur (car parents)
parents (!cdr parents)
parent-relations (ht-get h cur))
(if parent-relations
(dag--plist-cons parent-relations :children it)
(dag--ht-cons broken-edges it cur)
(dag--plist-remove relations :parents cur))))
(list h broken-edges)))
(defun dag--longest-paths (adjlist suborder)
(let ((distances (dag--ht-create (ht-size adjlist)))
;; Flip the order so we climb up the topological order from the deepest
;; nodes first
;; NOTE Need to use reverse here an not nreverse so the original list
;; isn't modified by side effect
(rsuborder (reverse suborder))
cur cur-distance child-distance)
;; initialize distances (all except first to 0)
(ht-set distances (car rsuborder) 0)
(--each (cdr rsuborder) (ht-set distances it nil))
;; walk up the parent edges and add one to each distance
(while rsuborder
(setq cur (car rsuborder))
(--each (dag--adjlist-get-parents cur adjlist)
(when (setq cur-distance (ht-get distances cur))
(setq child-distance (ht-get distances it))
(when (or (null child-distance) (< child-distance (1+ cur-distance)))
(ht-set distances it (1+ cur-distance)))))
(!cdr rsuborder))
distances))
(defun dag--transitive-reduction (adjlist order)
(let (extra-edges cur distances cur-distance)
(while order
(setq distances (dag--longest-paths adjlist order)
cur (car order))
(dag--each-key distances
(setq cur-distance (ht-get distances it))
(when (and cur-distance (< 1 cur-distance))
(!cons (cons cur it) extra-edges)))
(setq order (cdr order)))
extra-edges))
(defun dag--create (adjlist broken-edges)
(-let (((a f) (dag--get-floating adjlist)))
(list :adjlist a
:broken-edges broken-edges
:floating-nodes f
:order (dag--get-topological-order adjlist))))
(defun dag--prune-broken-edges (broken-edges)
(dag--each-key broken-edges
(unless (ht-get broken-edges it)
(ht-remove broken-edges it)))
broken-edges)
(defun dag--adjlist-remove-nodes (to-remove adjlist broken-edges)
(let (r r-rel child-rel)
(while to-remove
;; If the node to be removed is in the adjacency list, get a list of its
;; parents, remove the node from the child list of each parent, then
;; delete the node itself.
(when (setq r (car to-remove)
r-rel (ht-get adjlist r))
(--each (plist-get r-rel :parents)
(dag--adjlist-remove-child-edge it r adjlist))
;; If a child edge refers to a node that is not about to be removed,
;; remove the parent edge from the the child and add it to broken edges.
;; Otherwise do nothing because the child will be removed later anyways.
(--each (plist-get r-rel :children)
(when (and (setq child-rel (ht-get adjlist it))
(not (member it to-remove)))
(ht-set adjlist it (dag--plist-remove child-rel :parents r))
(dag--ht-cons broken-edges it r)))
(ht-remove adjlist r))
;; Remove all broken edges assigned to this node regardless of its
;; presence in the adjacency list
(ht-remove broken-edges r)
(!cdr to-remove)))
(list adjlist broken-edges))
(defmacro dag--intersection-difference (xs ys &optional zs)
"Calculate the intersection and difference of XS and YS.
XS will contain all its members that are also in YS, and YS will
retain all its values that are not in XS. Both are modified in
place.
If ZS is given, additionally store the difference of YS and XS in
ZS."
(let ((found-form (if zs `(if found (!cons i ,xs) (!cons i ,zs))
`(when found (!cons i ,xs)))))
`(let (i j tmp-xs tmp-ys found)
(setq tmp-xs ,xs
,xs nil)
(while tmp-xs
(setq i (car tmp-xs)
tmp-ys ,ys
,ys nil
found nil)
(while tmp-ys
(if (eq i (setq j (car tmp-ys)))
(setq ,ys (append ,ys (cdr tmp-ys))
tmp-ys nil
found t)
(!cons j ,ys)
(!cdr tmp-ys)))
,found-form
(!cdr tmp-xs)))))
(defun dag--mend-edge (adjlist broken edge)
(let ((keys (ht-keys broken))
found i j tmp1 tmp2)
(while (and (not found) keys)
(setq i (car keys)
tmp1 (ht-get broken i)
tmp2 nil)
;; remove something without scanning a list twice (isn't this basically a
;; zipper being used in a really weird way?)
(while tmp1
(if (not (equal edge (setq j (car tmp1))))
(!cons j tmp2)
(ht-set broken i (append tmp2 (cdr tmp1)))
(setq found i))
(!cdr tmp1))
(!cdr keys))
(when found
(dag--adjlist-add-parent-edge found edge adjlist)
(dag--adjlist-add-child-edge edge found adjlist))))
(defun dag--adjlist-insert-nodes (to-insert adjlist broken-ht)
(let (i i-key i-rel edges-to-add parent-edges broken-edges edges-to-remove
parent-rel)
(while to-insert
(setq i (car to-insert)
i-key (car i)
edges-to-add (cdr i))
;; Add new node:
;;
;; If the node does not exist, add an empty relationship (it will be
;; filled in the next loop). If the node is a parent in the broken-hashes
;; table, transfer it to the adjacency list.
(if (not (setq i-rel (ht-get adjlist i-key)))
(progn
(ht-set adjlist i-key (dag--new-relationship nil nil))
(dag--mend-edge adjlist broken-ht i-key))
;; If the node does exist, get the edges that shouldn't be changed
;; (added & current), the edges that are to be added (added - current)
;; and the edges that are to be remove (current - added) (note 'added'
;; and 'current' are treated as sets with the appropriate notation). Set
;; the new parent slot to the edges that aren't to be changed, remove
;; the child references in all parent nodes, and keep the edges to be
;; added for later.
(setq parent-edges (plist-get i-rel :parents))
(dag--intersection-difference parent-edges edges-to-add edges-to-remove)
(ht-set adjlist i-key (plist-put i-rel :parents parent-edges))
(--each edges-to-remove
(dag--adjlist-remove-child-edge it i-key adjlist))
;; Similar to above, get the edges to be added and the nodes that are to
;; remain, and set the broken edges hash table to the latter.
(setq broken-edges (ht-get broken-ht i-key))
(dag--intersection-difference broken-edges edges-to-add)
(ht-set broken-ht i-key broken-edges))
;; Add new node to the child list of newly linked parents. This needs to
;; be done separately from above since we don't know if the new edges are
;; broken or not
(--each edges-to-add
(if (not (setq parent-rel (ht-get adjlist it)))
(dag--ht-cons broken-ht i-key it)
(ht-set adjlist it (dag--plist-cons parent-rel :children i-key))
(dag--adjlist-add-parent-edge i-key it adjlist)))
(!cdr to-insert))
(list adjlist (dag--prune-broken-edges broken-ht))))
(defun dag-alist-to-dag (parent-adjlist)
"Convert PARENT-ADJLIST to a DAG.
PARENT-ADJLIST is an alist where each member represents a
node in which the car is a identifying the node and the cdr is a
list of other keys representing edges to the parents of the car.
The set of all car keys must be equivalent to the set of all cdr
keys.
Return a DAG object."
(->> (dag--alist-to-ht parent-adjlist)
(apply #'dag--create)))
(defun dag-remove-nodes (to-remove dag)
(-let (((&plist :adjlist a :broken-edges b) dag))
(->> (dag--adjlist-remove-nodes to-remove a b)
(apply #'dag--create))))
(defun dag-insert-nodes (to-insert dag)
(-let (((&plist :adjlist a :broken-edges b) dag))
(->> (dag--adjlist-insert-nodes to-insert a b)
(apply #'dag--create))))
(defun dag-edit-nodes (to-remove to-insert dag)
(-let (((&plist :adjlist a :broken-edges b) dag))
(->> (dag--adjlist-remove-nodes to-remove a b)
(apply #'dag--adjlist-insert-nodes to-insert)
(apply #'dag--create))))
(defun dag-get-adjacency-list (dag)
(plist-get dag :adjlist))
(defun dag-get-broken-edges (dag)
(plist-get dag :broken-edges))
(defun dag-get-floating-nodes (dag)
(plist-get dag :floating-nodes))
(defun dag-get-topological-order (dag)
(plist-get dag :order))
(defalias 'dag-get-all-nodes 'dag-get-topological-order)
(defun dag-get-length (dag)
(length (dag-get-topological-order dag)))
(defun dag-is-valid-p (dag)
(< 0 (dag-get-length dag)))
(defun dag-get-relationships (key dag)
(->> (dag-get-adjacency-list dag)
(dag--adjlist-get-relationships key)))
(defun dag-get-parents (key dag)
(->> (dag-get-relationships key dag)
(dag--relationship-get-parents)))
(defun dag-get-children (key dag)
(->> (dag-get-relationships key dag)
(dag--relationship-get-children)))
(defmacro dag-get-nodes-where (dag form)
(declare (indent 1))
`(let ((it-adjlist (dag-get-adjacency-list ,dag))
acc)
(dag--each-key it-adjlist
(when ,form (!cons it acc)))
acc))
(defun dag-get-leaf-nodes (dag)
(dag-get-nodes-where dag
(not (dag--adjlist-get-children it it-adjlist))))
(defun dag-get-root-nodes (dag)
(dag-get-nodes-where dag
(not (dag--adjlist-get-parents it it-adjlist))))
(defun dag-get-extra-nodes (dag)
(-let (((&plist :adjlist :order) dag))
(dag--transitive-reduction adjlist order)))
;; (defun dag-remove-node (key dag)
;; (-let* (((&plist :nodes :order) dag))
;; (-when-let (rel (ht-get nodes key))
;; (plist-put dag :order (remove key order))
;; (ht-remove nodes key)
;; (--each (plist-get rel :children)
;; (dag-remove-node it dag)))))
(provide 'dag)
;;; dag.el ends here

View File

@ -0,0 +1,334 @@
;;; dag-test.el --- Examples for DAG API -*- lexical-binding: t -*-
;; Copyright (C) 2015 Free Software Foundation, Inc.
;; This program is free software; you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation, either version 3 of the License, or
;; (at your option) any later version.
;; This program is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;; GNU General Public License for more details.
;; You should have received a copy of the GNU General Public License
;; along with this program. If not, see <http://www.gnu.org/licenses/>.
;;; Commentary:
;; run with 'emacs --batch -l ../../../init.el -l test/dag-test.el -f ert'
;;; Code:
(require 'ht)
(require 'dash)
(require 'dag)
;; useful bits
(defun dag-test-ht-keys (h)
(-some-> h (ht-keys)))
(defun dag-test-ht-get (h k)
(-some-> h (ht-get k)))
(defun dag-test-sets-equal-p (a b)
(should (seq-set-equal-p a b #'equal)))
;; DAG testing predicates
;;
;; by convention, the curated test value is always the first in binary
;; comparisons
(defun dag-test-has-valid-adjlist-p (dag adjlist-alist)
(-let (((&plist :adjlist b) dag))
(--each adjlist-alist
(-let (((&plist :parents p :children c) (dag-test-ht-get b (car it)))
((&plist :parents p* :children c*) (cdr it)))
(dag-test-sets-equal-p p* p)
(dag-test-sets-equal-p c* c)))
(dag-test-sets-equal-p (-map #'car adjlist-alist) (dag-test-ht-keys b))))
(defun dag-test-has-valid-broken-edges-p (dag broken-edges-alist)
(-let (((&plist :broken-edges b) dag))
(--each broken-edges-alist
(dag-test-sets-equal-p (cdr it) (dag-test-ht-get b (car it))))
(dag-test-sets-equal-p (-map #'car broken-edges-alist)
(dag-test-ht-keys b))))
(defun dag-test-has-valid-floating-nodes-p (dag floating-nodes)
(-let (((&plist :floating-nodes f) dag))
(dag-test-sets-equal-p floating-nodes (dag-test-ht-keys f))))
(defun dag-test-has-valid-order-p (dag order)
(-let (((&plist :order o) dag))
(should (equal order o))))
;; test macros
(defmacro dag-test-dag-is-valid-p (dag adjlist broken-edges floating-nodes order)
(declare (indent 1))
`(progn
(dag-test-has-valid-adjlist-p ,dag ',adjlist)
(dag-test-has-valid-broken-edges-p ,dag ',broken-edges)
(dag-test-has-valid-floating-nodes-p ,dag ',floating-nodes)
(dag-test-has-valid-order-p ,dag ',order)))
(defmacro dag-test-alist-is-valid-p (alist adjlist broken-edges floating-nodes order)
(declare (indent 1))
`(let ((dag (dag-alist-to-dag ',alist)))
(dag-test-dag-is-valid-p dag
,adjlist ,broken-edges ,floating-nodes ,order)))
(defmacro dag-test-alist-remove-is-valid-p (alist to-remove adjlist broken-edges
floating-nodes order)
(declare (indent 2))
`(let ((dag (->> (dag-alist-to-dag ',alist)
(dag-remove-nodes ',to-remove))))
(dag-test-dag-is-valid-p dag
,adjlist ,broken-edges ,floating-nodes ,order)))
(defmacro dag-test-alist-insert-is-valid-p (alist to-insert adjlist broken-edges
floating-nodes order)
(declare (indent 2))
`(let ((dag (->> (dag-alist-to-dag ',alist)
(dag-insert-nodes ',to-insert))))
(dag-test-dag-is-valid-p dag
,adjlist ,broken-edges ,floating-nodes ,order)))
(defmacro dag-test-alist-edit-is-valid-p (alist to-remove to-insert adjlist
broken-edges floating-nodes
order)
(declare (indent 3))
`(let ((dag (->> (dag-alist-to-dag ',alist)
(dag-edit-nodes ',to-remove ',to-insert))))
(dag-test-dag-is-valid-p dag
,adjlist ,broken-edges ,floating-nodes ,order)))
;; tests
(ert-deftest dag-test-null ()
(dag-test-alist-is-valid-p nil
nil
nil
nil
nil))
(ert-deftest dag-test-one ()
(dag-test-alist-is-valid-p ((a))
nil
nil
(a)
nil))
(ert-deftest dag-test-one-cycle ()
(dag-test-alist-is-valid-p ((a a))
((a :children (a) :parents (a)))
nil
nil
nil))
(ert-deftest dag-test-one-broken ()
(dag-test-alist-is-valid-p ((a b))
nil
((a b))
(a)
nil))
(ert-deftest dag-test-two ()
(dag-test-alist-is-valid-p ((a) (b a))
((a :children (b) :parents nil)
(b :children nil :parents (a)))
nil
nil
(a b)))
(ert-deftest dag-test-two-cycle ()
(dag-test-alist-is-valid-p ((a b) (b a))
((a :children (b) :parents (b))
(b :children (a) :parents (a)))
nil
nil
nil))
(ert-deftest dag-test-two-floating ()
(dag-test-alist-is-valid-p ((a) (b))
nil
nil
(a b)
nil))
(ert-deftest dag-test-two-broken ()
(dag-test-alist-is-valid-p ((a) (b a c))
((a :children (b) :parents nil)
(b :children nil :parents (a)))
((b c))
nil
(a b)))
(ert-deftest dag-test-three-linear ()
(dag-test-alist-is-valid-p ((a) (b a) (c b))
((a :children (b) :parents nil)
(b :children (c) :parents (a))
(c :children nil :parents (b)))
nil
nil
(a b c)))
(ert-deftest dag-test-three-tree ()
(dag-test-alist-is-valid-p ((a) (b a) (c a))
((a :children (b c) :parents nil)
(b :children nil :parents (a))
(c :children nil :parents (a)))
nil
nil
(a c b)))
(ert-deftest dag-test-complicated ()
(dag-test-alist-is-valid-p ((a)
(b a)
(c a)
(d c b)
(e c b)
(x y)
(z))
((a :children (b c) :parents nil)
(b :children (d e) :parents (a))
(c :children (d e) :parents (a))
(d :children nil :parents (b c))
(e :children nil :parents (b c)))
((x y))
(x z)
(a c b e d)))
(ert-deftest dag-test-remove ()
(dag-test-alist-remove-is-valid-p ((a)
(b a)
(c a)
(d c b)
(e c b))
(e)
((a :children (b c) :parents nil)
(b :children (d) :parents (a))
(c :children (d) :parents (a))
(d :children nil :parents (b c)))
nil
nil
(a c b d)))
(ert-deftest dag-test-remove-break ()
(dag-test-alist-remove-is-valid-p ((a)
(b a)
(c a)
(d c b)
(e c b))
(e c)
((a :children (b) :parents nil)
(b :children (d) :parents (a))
(d :children nil :parents (b)))
((d c))
nil
(a b d)))
(ert-deftest dag-test-remove-break-float ()
(dag-test-alist-remove-is-valid-p ((a)
(b a)
(c b)
(d c))
(b)
((c :children (d) :parents nil)
(d :children nil :parents (c)))
((c b))
(a)
(c d)))
(ert-deftest dag-test-insert ()
(dag-test-alist-insert-is-valid-p ((a)
(b a)
(c a))
((d c b)
(e c b))
((a :children (b c) :parents nil)
(b :children (d e) :parents (a))
(c :children (d e) :parents (a))
(d :children nil :parents (b c))
(e :children nil :parents (b c)))
nil
nil
(a c b e d)))
(ert-deftest dag-test-insert-overwrite ()
(dag-test-alist-insert-is-valid-p ((a)
(b a)
(c a)
(d b))
((d b c x))
((a :children (b c) :parents nil)
(b :children (d) :parents (a))
(c :children (d) :parents (a))
(d :children nil :parents (b c)))
((d x))
nil
(a c b d)))
(ert-deftest dag-test-insert-floating ()
(dag-test-alist-insert-is-valid-p ((a)
(b a)
(c a))
((d))
((a :children (b c) :parents nil)
(b :children nil :parents (a))
(c :children nil :parents (a)))
nil
(d)
(a c b)))
(ert-deftest dag-test-insert-broken ()
(dag-test-alist-insert-is-valid-p ((a)
(b a)
(c a))
((d c x))
((a :children (b c) :parents nil)
(b :children nil :parents (a))
(c :children (d) :parents (a))
(d :children nil :parents (c)))
((d x))
nil
(a c b d)))
(ert-deftest dag-test-insert-fix-broken ()
(dag-test-alist-insert-is-valid-p ((a)
(b a)
(d c))
((c b))
((a :children (b) :parents nil)
(b :children (c) :parents (a))
(c :children (d) :parents (b))
(d :children nil :parents (c)))
nil
nil
(a b c d)))
(ert-deftest dag-test-edit ()
(dag-test-alist-edit-is-valid-p ((a)
(b a)
(c a)
(d b c)
(e b c))
(b)
((c)
(d c)
(a c))
((a :children nil :parents (c))
(c :children (a d e) :parents nil)
(d :children nil :parents (c))
(e :children nil :parents (c)))
((e b))
nil
(c a e d)))
;; TODO add test for transitive reduction
(provide 'dag-test)
;;; dag-test.el ends here