guile-rdf

Julien LepillerSun Apr 05 04:10:34+0200 2020

a3f8af8

Fix arguments for consistency checks

rdf/entailment/d.scm

   #:export (consistent-graph?
             entails?))
 (define (consistent-graph? graph)
 (define (consistent-graph? graph vocabulary)
   (define consistent-data?
     (match-lambda
       (($ rdf-literal form ($ rdf-datatype _ _ lexical? _ _ _) _)
        (lexical? form))
       (_ #t)))
   (match graph
   (match (recognize graph vocabulary)
     ('() #t)
     ((($ rdf-triple subject predicate object) graph ...)
      (and (consistent-data? subject) (consistent-data? object)
           (consistent-graph? graph)))))
           (consistent-graph? graph vocabulary)))))
 ;; G entails E if E has an instance (where blank nodes are replaced by literals
 ;; or IRIs) that is a subgraph of G.
                         g2)))
           (validate-mapping mapping g1 g2)))))
 (define (entails? g e)
 (define (entails? g e vocabulary)
   "Return true if g entails e"
   (or (not (consistent-graph? g))
       (let* ((constraints (fold (lambda (t constraints)
                                   (list 'and (generate-constraints t g) constraints))
                                 'none e))
              (disjunctions (to-disjunctions constraints)))
         (if (equal? disjunctions 'bot)
             #f
             (let loop ((disjunctions (filter sat? disjunctions)))
               (match disjunctions
                 ('() #f)
                 ((mapping disjunctions ...)
                  (if (validate-mapping mapping e g)
                    #t
                    (loop disjunctions)))))))))
   (let ((g (recognize g vocabulary)))
     (or (not (consistent-graph? g vocabulary))
         (let* ((constraints (fold (lambda (t constraints)
                                     (list 'and (generate-constraints t g)
                                           constraints))
                                   'none e))
                (disjunctions (to-disjunctions constraints)))
           (if (equal? disjunctions 'bot)
               #f
               (let loop ((disjunctions (filter sat? disjunctions)))
                 (match disjunctions
                   ('() #f)
                   ((mapping disjunctions ...)
                    (if (validate-mapping mapping e g)
                      #t
                      (loop disjunctions))))))))))

rdf/entailment/rdf.scm

           (null?
             (filter
               (lambda (t)
                 (not (compatible (cdr t))))
                 (not (compatible? (cdr t))))
               type-mappings))
           (let* ((t (car graph)))
             (if (equal? (rdf-triple-predicate t) (rdf-iri "type"))
                                      (assoc-ref type-mappings
                                                 (rdf-triple-subject t))
                                      '())))))))))
   (and (d:consistent-graph? graph)
        (compatible-types? graph)))
   (and (d:consistent-graph? graph vocabulary)
        (compatible-types? (recognize graph vocabulary))))
 ;; G entails E if E has an instance (where blank nodes are replaced by literals
 ;; or IRIs) that is a subgraph of G.
   "Return true if g entails e"
   (let ((g (recognize g vocabulary)))
     (or (not (consistent-graph? g vocabulary))
         (d:entails? (augment g) e))))
         (d:entails? (augment g) e vocabulary))))

rdf/entailment/rdfs.scm

            (valid-subclasses? graph)))
       ((_ graph ...)
        (valid-subclasses? graph))))
   (and (valid-subclasses? graph)
   (and (valid-subclasses? (recognize graph vocabulary))
        (rdf:consistent-graph? graph vocabulary)))
 ;; G entails E if E has an instance (where blank nodes are replaced by literals
   (let* ((g (recognize g vocabulary)))
     (or (not (consistent-graph? g vocabulary))
         (d:entails? (augment g (rdf-vocabulary-datatypes vocabulary))
                     (recognize e vocabulary)))))
                     e vocabulary))))