lib/SemanticWeb.php

   1 <?php // $Id$
   2 /**
   3  * What to do on ?format=rdf  What to do on ?format=owl
   4  *
   5  * Map relations on a wikipage to a RDF ressource to build a "Semantic Web"
   6  * - a web ontology frontend compatible to OWL (web ontology language).
   7  * http://www.w3.org/2001/sw/Activity
   8  * Simple RDF ontologies contain facts and rules, expressed by RDF triples:
   9  *   Subject (page) -> Predicate (verb, relation) -> Object (links)
  10  * OWL extents that to represent a typical OO framework.
  11  *  OO predicates:
  12  *    is_a, has_a, ...
  13  *  OWL predicates:
  14  *    subClassOf, restrictedBy, onProperty, intersectionOf, allValuesFrom, ...
  15  *    someValuesFrom, unionOf, equivalentClass, disjointWith, ...
  16  *    plus the custom vocabulary (ontology): canRun, canBite, smellsGood, ...
  17  *  OWL Subjects: Class, Restriction, ...
  18  *  OWL Properties: type, label, comment, ...
  19  * DAML should also be supported.
  20  *
  21  * Purpose:
  22  * - Another way to represent various KB models in various DL languages.
  23  *   (OWL/DAML/other DL)
  24  * - Frontend to various KB model reasoners and representations.
  25  * - Generation/update of static wiki pages based on external OWL/DL/KB
  26  *   (=> ModelTest/Categories)
  27  *   KB Blackboard and Visualization.
  28  * - OWL generation based on static wiki pages (ModelTest?format=owl)
  29  *
  30  * Facts: (may be represented by special links on a page)
  31  *  - Each page must be representable with an unique URL.
  32  *  - Each fact must be representable with an unique RDF triple.
  33  *  - A class is represented by a category page.
  34  *  - To represent more expressive description logic, "enriched"
  35  *    links will not be enough (? variable symbolic objects).
  36  *
  37  * Rules: (may be represented by special content on a page)
  38  *  - Syntax: reasoner backend specific, or common or ?
  39  *
  40  * RDF Triple: (representing facts)
  41  *   Subject (page) -> Predicate (verb, relation) -> Object (links)
  42  * Subject: a page
  43  * Verb:
  44  *   Special link qualifiers represent RDF triples, based on RDF standard notation.
  45  *   See RDF standard DTD's on daml.org and w3.org, plus your custom predicates.
  46  *   (need your own DTD)
  47  *   Example: page [Ape] isa:Animal, ...
  48  * Object: special links on a page.
  49  * Class: WikiCategory
  50  * Model: Basepage for a KB. (parametrizeable pages or copies of modified snapshots?)
  51  *
  52  * DL: Description Logic
  53  * KB: Knowledge Base
  54  *
  55  * Discussion:
  56  * Of course *real* expert systems ("reasoners") will help/must be used in
  57  * optimization and maintainance of the SemanticWeb KB (Knowledge
  58  * Base). Hooks will be tested to KM (an interactive KB playground),
  59  * LISA (standard unifier), FaCT, RACER, ...
  60
  61  * Maybe also ZEBU (parser generator) is needed to convert the wiki KB
  62  * syntax to the KB reasoner backend (LISA, KM, CLIPS, JESS, FaCT,
  63  * ...) and forth.
  64
  65  * pOWL is a simple php backend with some very simple AI logic in PHP,
  66  * though I strongly doubt the usefulness of reasoners not written in
  67  * Common Lisp.
  68  *
  69  * SEAL (omntoweb.org) is similar to that, just on top of the Zope CMF.
  70  * FaCT uses e.g. this KB DTD:
  71 <!ELEMENT KNOWLEDGEBASE (DEFCONCEPT|DEFROLE|IMPLIESC|EQUALC|IMPLIESR|EQUALR|TRANSITIVE|FUNCTIONAL)*>
  72 <!ELEMENT CONCEPT (PRIMITIVE|TOP|BOTTOM|AND|OR|NOT|SOME|ALL|ATMOST|ATLEAST)>
  73 <!ELEMENT ROLE (PRIMROLE|INVROLE)>
  74 ... (facts and rules described in XML)
  75  *
  76  * Links:
  77  *   http://phpwiki.org/SemanticWeb,
  78  *   http://en.wikipedia.org/wiki/Knowledge_representation
  79  *   http://www.ontoweb.org/
  80  *   http://www.semwebcentral.org/ (OWL on top of FusionForge)
  81  *
  82  *
  83  * Author: Reini Urban <rurban@x-ray.at>
  84  */
  85 /*============================================================================*/
  86 /*
  87  * Copyright 2004,2007 Reini Urban
  88  *
  89  * This file is part of PhpWiki.
  90  *
  91  * PhpWiki is free software; you can redistribute it and/or modify
  92  * it under the terms of the GNU General Public License as published by
  93  * the Free Software Foundation; either version 2 of the License, or
  94  * (at your option) any later version.
  95  *
  96  * PhpWiki is distributed in the hope that it will be useful,
  97  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  98  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  99  * GNU General Public License for more details.
 100  *
 101  * You should have received a copy of the GNU General Public License
 102  * along with PhpWiki; if not, write to the Free Software
 103  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 104  */
 105
 106 require_once('lib/RssWriter.php');
 107 require_once('lib/TextSearchQuery.php');
 108 require_once('lib/Units.php');
 109
 110
 111 /**
 112  * RdfWriter - A class to represent the links of a list of wikipages as RDF.
 113  * Supports ?format=rdf
 114  *
 115  * RdfWriter (unsorted)
 116  *  - RssWriter (timesorted)
 117  *    - RecentChanges (?action=RecentChanges&format=rdf) (filtered)
 118  */
 119 class RdfWriter extends RssWriter // in fact it should be rewritten to be other way round.
 120 {
 121     function RdfWriter (&$request, &$pagelist) {
 122         $this->_request =& $request;
 123         $this->_pagelist =& $pagelist;
 124         $this->XmlElement('rdf:RDF',
 125                           array('xmlns' => "http://purl.org/rss/1.0/",
 126                                 'xmlns:rdf' => 'http://www.w3.org/1999/02/22-rdf-syntax-ns#'));
 127
 128         $this->_modules = array(
 129             //Standards
 130             'content'   => "http://purl.org/rss/1.0/modules/content/",
 131             'dc'        => "http://purl.org/dc/elements/1.1/",
 132             );
 133
 134         $this->_uris_seen = array();
 135         $this->_items = array();
 136
 137         $this->wiki_xmlns_xml = WikiURL(_("UriResolver")."?",false,true);
 138         $this->wiki_xmlns_url = PHPWIKI_BASE_URL;
 139
 140         $this->pre_ns_buffer =
 141             "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" .
 142             "<!DOCTYPE rdf:RDF[\n" .
 143             "\t"."<!ENTITY rdf 'http://www.w3.org/1999/02/22-rdf-syntax-ns#'>\n" .
 144             "\t"."<!ENTITY rdfs 'http://www.w3.org/2000/01/rdf-schema#'>\n" .
 145             "\t"."<!ENTITY owl 'http://www.w3.org/2002/07/owl#'>\n" .
 146             "\t"."<!ENTITY smw 'http://smw.ontoware.org/2005/smw#'>\n" .
 147             "\t"."<!ENTITY smwdt 'http://smw.ontoware.org/2005/smw-datatype#'>\n" .
 148             // A note on "wiki": this namespace is crucial as a fallback when it would be illegal to start e.g. with a number. In this case, one can always use wiki:... followed by "_" and possibly some namespace, since _ is legal as a first character.
 149             "\t"."<!ENTITY wiki '" . $this->wiki_xmlns_xml .  "'>\n" .
 150             "\t"."<!ENTITY relation '" . $this->wiki_xmlns_xml .
 151             $this->makeXMLExportId(urlencode(str_replace(' ', '_', _("Relation") . ':'))) .  "'>\n" .
 152             "\t"."<!ENTITY attribute '" . $this->wiki_xmlns_xml .
 153             $this->makeXMLExportId(urlencode(str_replace(' ', '_', _("Attribute") . ':'))) .  "'>\n" .
 154             "\t"."<!ENTITY wikiurl '" . $this->wiki_xmlns_url .  "'>\n" .
 155             "]>\n\n" .
 156             "<rdf:RDF\n" .
 157             "\t"."xmlns:rdf=\"&rdf;\"\n" .
 158             "\t"."xmlns:rdfs=\"&rdfs;\"\n" .
 159             "\t"."xmlns:owl =\"&owl;\"\n" .
 160             "\t"."xmlns:smw=\"&smw;\"\n" .
 161             "\t"."xmlns:wiki=\"&wiki;\"\n" .
 162             "\t"."xmlns:relation=\"&relation;\"\n" .
 163             "\t"."xmlns:attribute=\"&attribute;\"";
 164         $this->post_ns_buffer =
 165             "\n\t<!-- reference to the Semantic MediaWiki schema -->\n" .
 166             "\t"."<owl:AnnotationProperty rdf:about=\"&smw;hasArticle\">\n" .
 167             "\t\t"."<rdfs:isDefinedBy rdf:resource=\"http://smw.ontoware.org/2005/smw\"/>\n" .
 168             "\t"."</owl:AnnotationProperty>\n" .
 169             "\t"."<owl:AnnotationProperty rdf:about=\"&smw;hasType\">\n" .
 170             "\t\t"."<rdfs:isDefinedBy rdf:resource=\"http://smw.ontoware.org/2005/smw\"/>\n" .
 171             "\t"."</owl:AnnotationProperty>\n" .
 172             "\t"."<owl:Class rdf:about=\"&smw;Thing\">\n" .
 173             "\t\t"."<rdfs:isDefinedBy rdf:resource=\"http://smw.ontoware.org/2005/smw\"/>\n" .
 174             "\t"."</owl:Class>\n" .
 175             "\t<!-- exported page data -->\n";
 176     }
 177
 178     function format() {
 179         header( "Content-type: application/rdf+xml; charset=UTF-8" );
 180         echo $this->pre_ns_buffer;
 181         echo ">\n";
 182
 183         $first = true;
 184         $dbi =  $this->_request->_dbi;
 185         /* Elements per page:
 186            out-links internal, out-links external
 187            backlinks
 188            relations
 189            attributes
 190         */
 191         foreach ($this->_pagelist->_pages as $page) {
 192             $relation = new TextSearchQuery("*");
 193             foreach (array('linkto','linkfrom','relation','attribute') as $linktype) {
 194                 $linkiter = $dbi->linkSearch($pages, $search, $linktype, $relation);
 195             }
 196             while ($link = $linkiter->next()) {
 197                 if (mayAccessPage('view', $rev->_pagename)) {
 198                     $linkto->addItem($this->item_properties($rev),
 199                                      $this->pageURI($rev));
 200                     if ($first)
 201                         $this->setValidators($rev);
 202                     $first = false;
 203                 }
 204             }
 205         }
 206
 207         echo $this->post_ns_buffer;
 208         echo "</rdf:RDF>\n";
 209     }
 210
 211     /** This function transforms a valid url-encoded URI into a string
 212      *  that can be used as an XML-ID. The mapping should be injective.
 213      */
 214     function makeXMLExportId($uri) {
 215         $uri = str_replace( '-', '-2D', $uri);
 216         //$uri = str_replace( ':', '-3A', $uri); //already done by PHP
 217         //$uri = str_replace( '_', '-5F', $uri); //not necessary
 218         $uri = str_replace( array('"',  '#',   '&', "'",  '+',  '=',  '%'),
 219                             array('-22','-23','-26','-27','-2B','-3D','-'),
 220                             $uri);
 221         return $uri;
 222     }
 223
 224     /** This function transforms an XML-ID string into a valid
 225      *  url-encoded URI. This is the inverse to makeXMLExportID.
 226      */
 227     function makeURIfromXMLExportId($id) {
 228         $id = str_replace( array('-22','-23','-26','-27','-2B','-3D','-'),
 229                            array('"',  '#',  '&',  "'",  '+',  '=',  '%'),
 230                            $id);
 231         $id = str_replace( '-2D', '-', $id);
 232         return $id;
 233     }
 234 }
 235
 236 /**
 237  */
 238 class RdfsWriter extends RdfWriter {
 239 };
 240
 241 /**
 242  * OwlWriter - A class to represent a set of wiki pages (a DL model) as OWL.
 243  * Requires an actionpage returning a pagelist.
 244  * Supports ?format=owl
 245  *
 246  * OwlWriter
 247  *  - RdfWriter
 248  *  - Reasoner
 249 */
 250 class OwlWriter extends RdfWriter {
 251 };
 252
 253 /**
 254  * ModelWriter - Export a KB as set of wiki pages.
 255  * Requires an actionpage returning a pagelist.
 256  * Probably based on some convenient DL expression syntax. (deffact, defrule, ...)
 257  *
 258  * ModelWriter
 259  *  - OwlWriter
 260  *  - ReasonerBackend
 261 */
 262 class ModelWriter extends OwlWriter {
 263 };
 264
 265 /**
 266  *  NumericSearchQuery can do:
 267  *         ("population < 20000 and area > 1000000", array("population", "area"))
 268  *  ->match(array('population' => 100000, 'area' => 10000000))
 269  * @see NumericSearchQuery
 270  *
 271  *  SemanticAttributeSearchQuery can detect and unify units in numbers.
 272  *         ("population < 2million and area > 100km2", array("population", "area"))
 273  *  ->match(array('population' => 100000, 'area' => 10000000))
 274  *
 275  * Do we need a real parser or can we just regexp over some allowed unit
 276  * suffixes to detect the numbers?
 277  * See man units(1) and /usr/share/units.dat
 278  * base units: $ units "1 million miles"
 279  *                     Definition: 1.609344e+09 m
 280  */
 281 class SemanticAttributeSearchQuery
 282 extends NumericSearchQuery
 283 {
 284     /*
 285     var $base_units = array('m'   => explode(',','km,miles,cm,dm,mm,ft,inch,inches,meter'),
 286                             'm^2' => explode(',','km^2,ha,cm^2,mi^2'),
 287                             'm^3' => explode(',','km^3,lit,cm^3,dm^3,gallons'),
 288                             );
 289     */
 290
 291     /**
 292      * We need to detect units from the freetext query:
 293      * population > 1 million
 294      */
 295     function SemanticAttributeSearchQuery($search_query, $placeholders, $unit = '') {
 296         $this->NumericSearchQuery($search_query, $placeholders);
 297         $this->_units = new Units();
 298         $this->unit = $unit;
 299     }
 300
 301     /**
 302      * Strip non-numeric chars from the variable (as the groupseperator) and replace
 303      * it in the symbolic query for evaluation.
 304      * This version unifies the attribute values from the database to a
 305      * numeric basevalue before comparison. (area:=963.6km^2 => 9.366e+08 m^2)
 306      *
 307      * @access private
 308      * @param $value number   A numerical value: integer, float or string.
 309      * @param $x string       The variable name to be replaced in the query.
 310      * @return string
 311      */
 312     function _bind($value, $x) {
 313         $ori_value = $value;
 314         $value = preg_replace("/,/", "", $value);
 315         $this->_bound[] = array('linkname'  => $x,
 316                                 'linkvalue' => $value);
 317         // We must ensure that the same baseunits are matched against.
 318         // We cannot compare m^2 to m or ''
 319         $val_base = $this->_units->basevalue($value);
 320         if (!DISABLE_UNITS and $this->_units->baseunit($value) != $this->unit) {
 321             // Poor user has selected an attribute, but no unit. assume he means the baseunit
 322             if (count($this->getVars() == 1) and $this->unit == '') {
 323                 ;
 324             } else {
 325                 // non-matching units are silently ignored
 326                 $this->_workquery = '';
 327                 return '';
 328             }
 329         }
 330         $value = $val_base;
 331         if (!is_numeric($value)) {
 332             $this->_workquery = ''; //must return false
 333             trigger_error("Cannot match against non-numeric attribute value $x := $ori_value",
 334                           E_USER_NOTICE);
 335             return '';
 336         }
 337
 338         $this->_workquery = preg_replace("/\b".preg_quote($x,"/")."\b/", $value, $this->_workquery);
 339         return $this->_workquery;
 340     }
 341
 342 }
 343
 344 /**
 345  *  SemanticSearchQuery can do:
 346  *     (is_a::city and population < 20000) and (*::city and area > 1000000)
 347  *  ->match(array('is_a' => 'city', 'linkfrom' => array(),
 348  *          population' => 100000, 'area' => 10000000))
 349  * @return array  A list of found and bound matches
 350  */
 351 class SemanticSearchQuery
 352 extends SemanticAttributeSearchQuery
 353 {
 354     function hasAttributes() { // TODO
 355     }
 356     function hasRelations()  { // TODO
 357     }
 358     function getLinkNames()  { // TODO
 359     }
 360 }
 361
 362 /**
 363  * ReasonerBackend - hooks to reasoner backends.
 364  * via http as with DIG,
 365  * or internally
 366  */
 367 class ReasonerBackend {
 368     function ReasonerBackend () {
 369         ;
 370     }
 371     /**
 372      * transform to reasoner syntax
 373      */
 374     function transformTo () {
 375         ;
 376     }
 377     /**
 378      * transform from reasoner syntax
 379      */
 380     function transformFrom () {
 381         ;
 382     }
 383     /**
 384      * call the reasoner
 385      */
 386     function invoke () {
 387         ;
 388     }
 389 };
 390
 391 class ReasonerBackend_LISA extends ReasonerBackend {
 392 };
 393
 394 class ReasonerBackend_Racer extends ReasonerBackend {
 395 };
 396
 397 class ReasonerBackend_KM extends ReasonerBackend {
 398 };
 399
 400 // Local Variables:
 401 // mode: php
 402 // tab-width: 8
 403 // c-basic-offset: 4
 404 // c-hanging-comment-ender-p: nil
 405 // indent-tabs-mode: nil
 406 // End:
 407 ?>