kibi-swipl-linux-x64-gnu 1.0.0

package/lib/swipl/library/ext/semweb/semweb/rdf11_containers.pl

@@ -0,0 +1,299 @@
+/*  Part of SWI-Prolog
+
+    Author:        Jan Wielemaker and Wouter Beek
+    E-mail:        J.Wielemaker@vu.nl
+    WWW:           http://www.swi-prolog.org
+    Copyright (c)  2016, VU University Amsterdam
+    All rights reserved.
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions
+    are met:
+
+    1. Redistributions of source code must retain the above copyright
+       notice, this list of conditions and the following disclaimer.
+
+    2. Redistributions in binary form must reproduce the above copyright
+       notice, this list of conditions and the following disclaimer in
+       the documentation and/or other materials provided with the
+       distribution.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+    FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+    COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+    INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+    BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+    LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+    CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+    LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+    ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+    POSSIBILITY OF SUCH DAMAGE.
+*/
+
+:- module(rdf11_containers,
+          [ rdf_alt/3,                            % ?Alt, -Default, -Others
+            rdf_assert_alt/3,                     % ?Alt, +Default, +Others
+            rdf_assert_alt/4,                     % ?Alt, +Default, +Others, +G
+            rdf_assert_bag/2,                     % ?Bag, +Set
+            rdf_assert_bag/3,                     % ?Bag, +Set, +G
+            rdf_assert_seq/2,                     % ?Seq, +List
+            rdf_assert_seq/3,                     % ?Seq, +List, +G
+            rdf_bag/2,                            % ?Bag, -List
+            rdf_seq/2,                            % ?Seq, -List
+            rdfs_container/2,                     % ?Container, -List
+            rdfs_container_membership_property/1, % ?Property
+            rdfs_container_membership_property/2, % ?Property, ?Number
+            rdfs_member/2,                        % ?Elem, ?Container
+            rdfs_nth0/3                           % ?N, ?Container, ?Elem
+          ]).
+:- use_module(library(semweb/rdf_prefixes),
+              [ (rdf_meta)/1, op(_,_,rdf_meta)
+              ]).
+:- use_module(rdf11,
+              [ rdf_default_graph/1, rdf_transaction/1, rdf_create_bnode/1,
+                rdf_assert/4, rdf_equal/2, rdf_is_subject/1, rdf_has/3
+              ]).
+
+:- autoload(library(apply),[maplist/3]).
+:- autoload(library(error),[must_be/2,type_error/2]).
+:- autoload(library(lists),[member/2]).
+:- autoload(library(pairs),[group_pairs_by_key/2,pairs_values/2]).
+
+/** <module> RDF 1.1 Containers
+
+Implementation of the conventional human interpretation of RDF 1.1 containers.
+
+RDF containers are open enumeration structures as opposed to RDF collections or
+RDF lists which are closed enumeration structures.
+The same resource may appear in a container more than once.
+A container may be contained in itself.
+
+---
+
+@author Wouter Beek
+@author Jan Wielemaker
+@compat RDF 1.1
+@see http://www.w3.org/TR/2014/REC-rdf-schema-20140225/#ch_containervocab
+@version 2016/01
+*/
+
+:- rdf_meta
+    rdf_alt(r, -, -),
+    rdf_assert_alt(r, r, t),
+    rdf_assert_alt(r, r, t, r),
+    rdf_assert_bag(r, t),
+    rdf_assert_bag(r, t, r),
+    rdf_assert_seq(r, t),
+    rdf_assert_seq(r, t, r),
+    rdf_bag(r, -),
+    rdf_seq(r, -),
+    rdfs_assert_container(r, t),
+    rdfs_assert_container(r, t, r),
+    rdfs_assert_container(r, r, t, r),
+    rdfs_container(r, -),
+    rdfs_container_membership_property(r),
+    rdfs_container_membership_property(r,?),
+    rdfs_member(r, -).
+
+
+%!  rdf_alt(+Alt, ?Default, ?Others) is nondet.
+%
+%   True when Alt is an instance of `rdf:Alt` with first member
+%   Default and remaining members Others.
+%
+%   Notice that this construct adds no machine-processable semantics
+%   but is conventionally used to indicate   to  a human reader that
+%   the numerical ordering of the container membership properties of
+%   Container is intended to  only   be  relevant  in distinguishing
+%   between the first and all non-first members.
+%
+%   Default denotes the default option to  take when choosing one of
+%   the alternatives container in  Container.   Others  denotes  the
+%   non-default options that can be chosen from.
+
+rdf_alt(Alt, Default, Others) :-
+    rdfs_container(Alt, [Default|Others]).
+
+%!  rdf_assert_alt(?Alt, +Default, +Others:list) is det.
+%!  rdf_assert_alt(?Alt, +Default, +Others:list, +Graph) is det.
+%
+%   Create an rdf:Alt with the given Default and Others. Default and
+%   the  members  of  Others  must  be    valid   object  terms  for
+%   rdf_assert/3.
+
+rdf_assert_alt(Alt, H, T) :-
+    rdf_default_graph(G),
+    rdf_assert_alt(Alt, H, T, G).
+
+rdf_assert_alt(Alt, H, T, G) :-
+    rdfs_assert_container(Alt, rdf:'Alt', [H|T], G).
+
+
+%!  rdf_bag(+Bag, -List:list) is nondet.
+%
+%   True when Bag is an rdf:Bag and   set  is the set values related
+%   through container membership properties to Bag.
+%
+%   Notice that this construct adds no machine-processable semantics
+%   but is conventionally used to indicate   to  a human reader that
+%   the numerical ordering of the container membership properties of
+%   Container is intended to not be significant.
+
+rdf_bag(Bag, List) :-
+    rdfs_container(Bag, List).
+
+
+%!  rdf_assert_bag(?Bag, +Set:list) is det.
+%!  rdf_assert_bag(?Bag, +Set:list, +Graph) is det.
+%
+%   Create an rdf:Bag from the given set   of values. The members of
+%   Set must be valid object terms for rdf_assert/3.
+
+rdf_assert_bag(Bag, L) :-
+    rdf_default_graph(G),
+    rdf_assert_bag(Bag, L, G).
+
+rdf_assert_bag(Bag, L, G) :-
+    rdfs_assert_container(Bag, rdf:'Bag', L, G).
+
+
+%!  rdf_seq(+Seq, -List:list) is nondet.
+%
+%   True when Seq is an instance of rdf:Seq   and  List is a list of
+%   associated values, ordered according to the container membership
+%   property used.
+%
+%   Notice that this construct adds no machine-processable semantics
+%   but is conventionally used to indicate   to  a human reader that
+%   the numerical ordering of the container membership properties of
+%   Container is intended to be significant.
+
+rdf_seq(Seq, L) :-
+    rdfs_container(Seq, L).
+
+
+%!  rdf_assert_seq(?Seq, +List) is det.
+%!  rdf_assert_seq(?Seq, +List, +Graph) is det.
+
+rdf_assert_seq(Seq, L) :-
+    rdf_default_graph(G),
+    rdf_assert_seq(Seq, L, G).
+rdf_assert_seq(Seq, L, G) :-
+    rdfs_assert_container(Seq, rdf:'Seq', L, G).
+
+
+%!  rdfs_assert_container(?Container, +Class, +Elems, +Graph)
+
+rdfs_assert_container(Container, Class, Elems, G) :-
+    must_be(list, Elems),
+    rdf_transaction(rdfs_assert_container_(Container, Class, Elems, G)).
+
+rdfs_assert_container_(Container, Class, Elems, G) :-
+    (var(Container) -> rdf_create_bnode(Container) ; true),
+    rdf_assert(Container, rdf:type, Class, G),
+    rdfs_assert_members(Elems, 1, Container, G).
+
+rdfs_assert_members([], _, _, _).
+rdfs_assert_members([H|T], N1, Resource, G) :-
+    !,
+    rdf_equal(rdf:'_', Prefix),
+    atom_concat(Prefix, N1, P),
+    rdf_assert(Resource, P, H, G),
+    N2 is N1 + 1,
+    rdfs_assert_members(T, N2, Resource, G).
+
+
+%!  rdfs_container(+Container, -List) is nondet.
+%
+%   True when List is the  list   of  objects  attached to Container
+%   using a container membership property  (rdf:_0, rdf:_1, ...). If
+%   multiple objects are connected to the   Container using the same
+%   membership  property,  this   predicate    selects   one   value
+%   non-deterministically.
+
+rdfs_container(Container, List) :-
+    rdf_is_subject(Container),
+    !,
+    findall(N-Elem, rdfs_member0(Container, N, Elem), Pairs),
+    keysort(Pairs, Sorted),
+    group_pairs_by_key(Sorted, GroupedPairs),
+    pairs_values(GroupedPairs, Groups),
+    maplist(member, List, Groups).
+rdfs_container(Container, _) :-
+    type_error(rdf_subject, Container).
+
+
+%!  rdfs_container_membership_property(?Property) is nondet.
+%
+%   True when Property is a   container membership property (rdf:_1,
+%   rdf:_2, ...).
+
+rdfs_container_membership_property(P) :-
+    rdfs_container_membership_property(P, _).
+
+
+%!  rdfs_container_membership_property(?Property, ?Number:nonneg) is nondet.
+%
+%   True when Property is the Nth container membership property.
+%
+%   Success of this goal does not imply that Property is present
+%   in the database.
+
+rdfs_container_membership_property(P, N) :-
+    var(P),
+    !,
+    between(1, inf, N),
+    rdf_equal(rdf:'_', Prefix),
+    atom_concat(Prefix, N, P).
+rdfs_container_membership_property(P, N) :-
+    atom(P),
+    rdf_equal(rdf:'_', Prefix),
+    string_concat(Prefix, NumS, P),
+    number_string(N, NumS),
+    integer(N),
+    N >= 0.
+
+
+%!  rdfs_member(?Elem, ?Container) is nondet.
+%
+%   True if rdf(Container, P, Elem) is true   and P is a container
+%   membership property.
+
+rdfs_member(Elem, Container) :-
+    rdfs_member0(Container, _, Elem).
+
+%!  rdfs_nth0(?N, ?Container, ?Elem) is nondet.
+%
+%   True if rdf(Container, P, Elem)  is  true   and  P  is the N-th
+%   (0-based) container membership property.
+
+rdfs_nth0(N, Container, Elem) :-
+    rdfs_member0(Container, N, Elem).
+
+
+%!  rdfs_member0(?Container, ?N, ?Elem) is nondet.
+%
+%   What is the most efficient way to enumerate rdfs_member(-,-)?
+%
+%   1. If we enumerate over all   container membership properties (= the
+%   current implementation) then it  takes  N   steps  before  we get to
+%   triple `<Container, rdf:_N, Elem>`, for arbitrary N.
+%
+%   2. The alternative is  to  enumerate   over  all  triples  and check
+%   whether the predicate term is a container membership property.
+%
+%   3. The choice between (1) and (2)   depends on whether the number of
+%   currently loaded triples in larger/smaller   than the largest number
+%   that  appears  in  a  container   membership  property.  This  means
+%   enumerating over all predicate terms using rdf_predicate/1.
+
+rdfs_member0(Container, N, Elem) :-
+    (nonvar(Container) ; nonvar(Elem)),
+    !,
+    rdf_has(Container, P, Elem),
+    rdfs_container_membership_property(P, N).
+rdfs_member0(Container, N, Elem) :-
+    rdfs_container_membership_property(P, N),
+    rdf_has(Container, P, Elem).

package/lib/swipl/library/ext/semweb/semweb/rdf_cache.pl

@@ -0,0 +1,278 @@
+/*  Part of SWI-Prolog
+
+    Author:        Jan Wielemaker
+    E-mail:        J.Wielemaker@vu.nl
+    WWW:           http://www.swi-prolog.org
+    Copyright (c)  2007-2020, VU University Amsterdam
+                              CWI, Amsterdam
+    All rights reserved.
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions
+    are met:
+
+    1. Redistributions of source code must retain the above copyright
+       notice, this list of conditions and the following disclaimer.
+
+    2. Redistributions in binary form must reproduce the above copyright
+       notice, this list of conditions and the following disclaimer in
+       the documentation and/or other materials provided with the
+       distribution.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+    FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+    COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+    INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+    BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+    LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+    CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+    LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+    ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+    POSSIBILITY OF SUCH DAMAGE.
+*/
+
+:- module(rdf_cache,
+          [ rdf_set_cache_options/1,    % +Options
+            rdf_cache_file/3            % +URL, +RW, -File
+          ]).
+:- autoload(library(error),[must_be/2,domain_error/2]).
+:- autoload(library(filesex),[make_directory_path/1]).
+
+/** <module> Cache RDF triples
+
+The library library(semweb/rdf_cache) defines the   caching strategy for
+triples sources. When using large RDF   sources, caching triples greatly
+speedup loading RDF documents. The cache  library implements two caching
+strategies that are controlled by rdf_set_cache_options/1.
+
+*|Local caching|* This approach  applies  to   files  only.  Triples are
+cached in a sub-directory of  the   directory  holding  the source. This
+directory is called =|.cache|= (=|_cache|=  on   Windows).  If the cache
+option =create_local_directory= is =true=, a  cache directory is created
+if possible.
+
+*|Global caching|* This approach applies  to   all  sources,  except for
+unnamed streams. Triples are cached in   directory  defined by the cache
+option =global_directory=.
+
+When loading an RDF file, the system   scans  the configured cache files
+unless cache(false) is specified as option   to rdf_load/2 or caching is
+disabled. If caching is enabled but no cache exists, the system will try
+to create a cache file. First it will try to do this locally. On failure
+it will try to configured global cache.
+*/
+
+:- dynamic
+    cache_option/1.
+
+set_setfault_options :-
+    assert(cache_option(enabled(true))),
+    (   current_prolog_flag(windows, true)
+    ->  assert(cache_option(local_directory('_cache')))
+    ;   assert(cache_option(local_directory('.cache')))
+    ).
+
+:- set_setfault_options.                % _only_ when loading!
+
+%!  rdf_set_cache_options(+Options)
+%
+%   Change the cache policy.  Provided options are:
+%
+%     * enabled(Boolean)
+%     If =true=, caching is enabled.
+%
+%     * local_directory(Name).
+%     Plain name of local directory.  Default =|.cache|=
+%     (=|_cache|= on Windows).
+%
+%     * create_local_directory(Bool)
+%     If =true=, try to create local cache directories
+%
+%     * global_directory(Dir)
+%     Writeable directory for storing cached parsed files.
+%
+%     * create_global_directory(Bool)
+%     If =true=, try to create the global cache directory.
+
+rdf_set_cache_options([]) :- !.
+rdf_set_cache_options([H|T]) :-
+    !,
+    rdf_set_cache_options(H),
+    rdf_set_cache_options(T).
+rdf_set_cache_options(Opt) :-
+    functor(Opt, Name, Arity),
+    arg(1, Opt, Value),
+    (   cache_option(Name, Type)
+    ->  must_be(Type, Value)
+    ;   domain_error(cache_option, Opt)
+    ),
+    functor(Gen, Name, Arity),
+    retractall(cache_option(Gen)),
+    expand_option(Opt, EOpt),
+    assert(cache_option(EOpt)).
+
+cache_option(enabled,                 boolean).
+cache_option(local_directory,         atom).
+cache_option(create_local_directory,  boolean).
+cache_option(global_directory,        atom).
+cache_option(create_global_directory, boolean).
+
+expand_option(global_directory(Local), global_directory(Global)) :-
+    !,
+    absolute_file_name(Local, Global).
+expand_option(Opt, Opt).
+
+
+%!  rdf_cache_file(+URL, +ReadWrite, -File) is semidet.
+%
+%   File is the cache file  for  URL.   If  ReadWrite  is =read=, it
+%   returns the name of an existing file.  If =write= it returns
+%   where a new cache file can be overwritten or created.
+
+rdf_cache_file(_URL, _, _File) :-
+    cache_option(enabled(false)),
+    !,
+    fail.
+rdf_cache_file(URL, read, File) :-
+    !,
+    (   atom_concat('file://', Path, URL),
+        cache_option(local_directory(Local)),
+        file_directory_name(Path, Dir),
+        local_cache_file(URL, LocalFile),
+        atomic_list_concat([Dir, Local, LocalFile], /, File)
+    ;   cache_option(global_directory(Dir)),
+        url_cache_file(URL, Dir, trp, read, File)
+    ),
+    access_file(File, read),
+    !.
+rdf_cache_file(URL, write, File) :-
+    !,
+    (   atom_concat('file://', Path, URL),
+        cache_option(local_directory(Local)),
+        file_directory_name(Path, Dir),
+        (   cache_option(create_local_directory(true))
+        ->  RWDir = write
+        ;   RWDir = read
+        ),
+        ensure_dir(Dir, Local, RWDir, CacheDir),
+        local_cache_file(URL, LocalFile),
+        atomic_list_concat([CacheDir, LocalFile], /, File)
+    ;   cache_option(global_directory(Dir)),
+        ensure_global_cache(Dir),
+        url_cache_file(URL, Dir, trp, write, File)
+    ),
+    access_file(File, write),
+    !.
+
+
+ensure_global_cache(Dir) :-
+    exists_directory(Dir),
+    !.
+ensure_global_cache(Dir) :-
+    cache_option(create_global_directory(true)),
+    make_directory_path(Dir),
+    print_message(informational, rdf(cache_created(Dir))).
+
+
+                 /*******************************
+                 *         LOCAL CACHE          *
+                 *******************************/
+
+%!  local_cache_file(+FileURL, -File) is det.
+%
+%   Return the name of the cache file   for FileURL. The name is the
+%   plain filename with the .trp extension.  As   the  URL is a file
+%   URL, it is guaranteed  to  be   a  valid  filename.  Assumes the
+%   hosting OS can handle  multiple  extensions  (=|.x.y|=)  though.
+%   These days that's even true on Windows.
+
+local_cache_file(URL, File) :-
+    file_base_name(URL, Name),
+    file_name_extension(Name, trp, File).
+
+
+                 /*******************************
+                 *         GLOBAL CACHE         *
+                 *******************************/
+
+%!  url_cache_file(+URL, +Dir, +Ext, +RW, -Path) is semidet.
+%
+%   Determine location of cache-file for the   given  URL in Dir. If
+%   Ext is provided, the  returned  Path   is  ensured  to  have the
+%   specified extension.
+%
+%   @param RW       If =read=, no directories are created and the call
+%                   fails if URL is not in the cache.
+
+url_cache_file(URL, Dir, Ext, RW, Path) :-
+    term_hash(URL, Hash0),
+    Hash is Hash0 + 100000,         % make sure > 4 characters
+    format(string(Hex), '~16r', [Hash]),
+    sub_atom(Hex, _, 2, 0, L1),
+    ensure_dir(Dir, L1, RW, Dir1),
+    sub_atom(Hex, _, 2, 2, L2),
+    ensure_dir(Dir1, L2, RW, Dir2),
+    url_to_file(URL, File),
+    ensure_ext(File, Ext, FileExt),
+    atomic_list_concat([Dir2, /, FileExt], Path).
+
+ensure_dir(D0, Sub, RW, Dir) :-
+    atomic_list_concat([D0, /, Sub], Dir),
+    (   exists_directory(Dir)
+    ->  true
+    ;   RW == write
+    ->  catch(make_directory(Dir), _, fail)
+    ).
+
+ensure_ext(File, '', File) :- !.
+ensure_ext(File, Ext, File) :-
+    file_name_extension(_, Ext, File),
+    !.
+ensure_ext(File, Ext, FileExt) :-
+    file_name_extension(File, Ext, FileExt).
+
+%!  url_to_file(+URL, -File)
+%
+%   Convert a URL in something that fits  in a file, i.e. avoiding /
+%   and :. We  simply  replace  these  by   -.  We  could  also  use
+%   www_form_encode/2, but confusion when to replace  as well as the
+%   fact that we loose the '.' (extension)   makes this a less ideal
+%   choice.  We could also consider base64 encoding of the name.
+
+url_to_file(URL, File) :-
+    atom_codes(URL, Codes),
+    phrase(safe_file_name(Codes), FileCodes),
+    atom_codes(File, FileCodes).
+
+safe_file_name([]) -->
+    [].
+safe_file_name([H|T]) -->
+    replace(H),
+    !,
+    safe_file_name(T).
+safe_file_name([H|T]) -->
+    [H],
+    safe_file_name(T).
+
+%!  replace(+Code)//
+%
+%   Replace a character  code  that  cannot   safely  be  put  in  a
+%   filename. Should we use %XX?
+
+replace(0'/)  --> "-".                  % directory separator
+replace(0'\\) --> "-".                  % not allowed in Windows filename
+replace(0':)  --> "-".                  % idem
+replace(0'?)  --> "-".                  % idem
+replace(0'*)  --> "-".                  % idem
+
+
+                 /*******************************
+                 *             MESSAGES         *
+                 *******************************/
+
+:- multifile prolog:message/3.
+
+prolog:message(rdf(cache_created(Dir))) -->
+    [ 'Created RDF cache directory ~w'-[Dir] ].

package/lib/swipl/library/ext/semweb/semweb/rdf_compare.pl

@@ -0,0 +1,132 @@
+/*  Part of SWI-Prolog
+
+    Author:        Jan Wielemaker
+    E-mail:        J.Wielemaker@vu.nl
+    WWW:           http://www.swi-prolog.org
+    Copyright (c)  2009-2022, University of Amsterdam
+                              CWI, Amsterdam
+                              SWI-Prolog Solutions b.v.
+    All rights reserved.
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions
+    are met:
+
+    1. Redistributions of source code must retain the above copyright
+       notice, this list of conditions and the following disclaimer.
+
+    2. Redistributions in binary form must reproduce the above copyright
+       notice, this list of conditions and the following disclaimer in
+       the documentation and/or other materials provided with the
+       distribution.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+    FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+    COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+    INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+    BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+    LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+    CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+    LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+    ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+    POSSIBILITY OF SUCH DAMAGE.
+*/
+
+:- module(rdf_compare,
+          [ rdf_equal_graphs/3          % +Graph1, +Graph2, -Substitutions
+          ]).
+:- if(exists_source(library(semweb/rdf_db))).
+:- use_module(library(semweb/rdf_db),[lang_equal/2,rdf_is_bnode/1]).
+:- endif.
+:- autoload(library(apply),[partition/4,maplist/3]).
+:- use_module(library(debug),[debug/3]).
+:- autoload(library(lists),[select/3]).
+
+/** <module> Compare RDF graphs
+
+This library provides predicates that compare   RDF  graphs. The current
+version only provides one predicate:   rdf_equal_graphs/3  verifies that
+two graphs are identical after proper labeling of the blank nodes.
+
+Future versions of this library may   contain  more advanced operations,
+such as diffing two graphs.
+*/
+
+
+%!  rdf_equal_graphs(+GraphA, +GraphB, -Substition) is semidet.
+%
+%   True if GraphA  and  GraphB  are   the  same  under  Substition.
+%   Substition is a list of BNodeA = BNodeB, where BNodeA is a blank
+%   node that appears in GraphA and  BNodeB   is  a  blank node that
+%   appears in GraphB.
+%
+%   @param GraphA is a list of rdf(S,P,O) terms
+%   @param GraphB is a list of rdf(S,P,O) terms
+%   @param Substition is a list if NodeA = NodeB terms.
+%   @tbd    The current implementation is rather naive.  After
+%           dealing with the subgraphs that contain no bnodes,
+%           it performs a fully non-deterministic substitution.
+
+rdf_equal_graphs(A, B, Substitutions) :-
+    sort(A, SA),
+    sort(B, SB),
+    partition(contains_bnodes, SA, VA, GA),
+    partition(contains_bnodes, SB, VB, GB),
+    (   GA == GB
+    ->  true
+    ;   maplist(compare_triple, GA, GB)
+    ),
+    compare_list(VA, VB, [], Substitutions),
+    !.
+
+contains_bnodes(rdf(S,P,O)) :-
+    (   node_id(S)
+    ;   node_id(P)
+    ;   node_id(O)
+    ),
+    !.
+
+compare_list([], [], S, S).
+compare_list([H1|T1], In2, S0, S) :-
+    select(H2, In2, T2),
+    compare_triple(H1, H2, S0, S1),
+    compare_list(T1, T2, S1, S).
+
+compare_triple(T1, T2) :-
+    compare_triple(T1,T2,[],[]).
+
+compare_triple(rdf(Subj1,P1,O1), rdf(Subj2, P2, O2), S0, S) :-
+    compare_field(Subj1, Subj2, S0, S1),
+    compare_field(P1, P2, S1, S2),
+    compare_field(O1, O2, S2, S).
+
+compare_field(X, X, S, S) :- !.
+compare_field(literal(X), xml(X), S, S) :- !. % TBD
+compare_field(literal(lang(L1,X)), literal(lang(L2,X)), S, S) :-
+    !,
+    lang_equal(L1, L2).
+compare_field(X, Id, S, S) :-
+    memberchk(X=Id, S),
+    !.
+compare_field(X, Y, S, [X=Y|S]) :-
+    \+ memberchk(X=_, S),
+    node_id(X),
+    node_id(Y),
+    debug(rdf_compare, 'Assume ~w = ~w~n', [X, Y]).
+
+node_id(node(_)) :- !.
+node_id(X) :-
+    rdf_is_bnode(X).
+
+:- if(\+current_predicate(rdf_is_bnode/1)).
+rdf_is_bnode(Node) :-
+    atom(Node),
+    sub_atom(Node, 0, _, _, '_:').
+:- endif.
+:- if(\+current_predicate(lang_equal/2)).
+lang_equal(X, Y) :-
+    downcase_atom(X, L),
+    downcase_atom(Y, L).
+:- endif.