#### **Scheme Procedure**: `rdf-dataset-isomorphic? d1 d2`

Returns whether two datasets are the same.  Two datasets can have a different

representation because of order and because of differing blank node

representations.  They are isomorphic when there is a one-to-one mapping

between them, such that blank nodes from one map to blank nodes of the other,

and vice-versa.  Note that the mapping can map differently named blank nodes

even when the name a named graph.

            rdf-dataset-isomorphic?

(define (generate-graph-constraints g1 g2)

  (fold (lambda (t constraints)

          (list 'and (generate-constraints t g2) constraints))

        'none g1))

  (let* ((constraints (generate-graph-constraints g1 g2))

    (let loop ((disjunctions (filter sat? disjunctions)))

      (match disjunctions

(define (generate-dataset-constraints d1 d2)

  (let ((g1 (rdf-dataset-default-graph d1))

        (g2 (rdf-dataset-default-graph d2))

        (ng1 (rdf-dataset-named-graphs d1))

        (ng2 (rdf-dataset-named-graphs d2)))

    (list 'and (generate-graph-constraints g1 g2)

          (if (null? ng1)

              'none

              (fold (lambda (ng1 constraints)

                      (match ng1

                        ((n1 . g1)

                         (if (blank-node? n1)

                             (fold (lambda (ng2 constraints)

                                     (list 'or (list 'and (list 'equiv n1 (car ng2))

                                                     (generate-graph-constraints g1 g2))

                                           constraints))

                                   'bot

                                   (filter (lambda (g2) (blank-node? (car g2))) ng2))

                             (let ((g2 (assoc-ref ng2 n1)))

                               (if g2

                                   (list 'and (generate-graph-constraints g1 g2)

                                         constraints)

                                   'bot))))))

                    'bot ng1)))))

(define (validate-dataset-mapping mapping d1 d2)

  (define (validate-named-graph name graph)

    (let ((graph2 (if (blank-node? name)

                      (assoc-ref (rdf-dataset-named-graphs d2)

                                 (assoc-ref mapping name))

                      (assoc-ref (rdf-dataset-named-graphs d2) name))))

      (validate-mapping mapping graph graph2)))

  (and (validate-mapping mapping (rdf-dataset-default-graph d1)

                         (rdf-dataset-default-graph d2))

       (null? (filter

                (lambda (ng1)

                  (match ng1

                    ((name . graph)

                     (not (validate-named-graph name graph)))))

                (rdf-dataset-named-graphs d1)))))

(define (rdf-dataset-isomorphic? d1 d2)

  "Compare two datasets and return whether they are isomorphic."

  (let* ((constraints (generate-dataset-constraints d1 d2))

         (disjunctions (to-disjunctions constraints)))

    (let loop ((disjuctions (filter sat? disjunctions)))

      (match disjunctions

        ('() (and (null? (rdf-dataset-default-graph d1))

                  (null? (rdf-dataset-default-graph d2))

                  (null? (rdf-dataset-named-graphs d1))

                  (null? (rdf-dataset-named-graphs d2))))

        ((mapping disjunctions ...)

         (or (and (validate-dataset-mapping mapping d1 d2)

                  (validate-dataset-mapping (reverse-mapping mapping) d2 d1))

             (loop disjunctions)))))))