Может быть заменен
Данный раздел описывает статус текущего документа на момент его публикации. Этот документ может быть заменен другими. Перечень текущих публикаций W3C и последних изменений этого технического отчета можно найти посредством указателя технических отчетов W3C на странице http://www.w3.org/TR/..
Этот документ является составной частью нижеперечисленного набора из 6 опубликованных документов:
- Структурная спецификация и функциональный синтаксис
- Модельно-теоретические семантики
- Преобразование в RDF-графы
- XML-сериализация
- Профили
- Начальное руководство (текущий документ)
Совместимость с OWL 1
Рабочая группа OWL декларирует, что OWL 2 является расширением OWL 1. По сравнению с предыдущей версией здесь элиминировано несколько незначительных ошибок и внесены изменения в формальные семантики аннотаций. Это значит, что OWL 2 совместим с предыдущей версией, а разработчикам документов OWL 1 понадобится просто перейти к использованию OWL 2 при наличии необходимости работы с дополнительными возможностями OWL 2. Более подробная информация о переходе от OWL 1 к OWL 2 будет представлена в последующих рабочих проектах.
Разные варианты синтаксиса
Текущий документ содержит примеры в четырех вариантах OWL-синтаксиса. Javascript используется для управления отображением каждого синтаксиса. Один из вариантов синтаксиса — манчестерский синтаксис (Manchester Syntax) — задокументирован в ненормативной заметке рабочей группы, расположенной на текущий момент на странице Wiki.
Замечания принимаются до 11 мая 2008
Рабочая группа OWL принимает отзывы общественности касательно первого опубликованного рабочего проекта. Свои комментарии вы можете направлять по адресу public-owl-comments@w3.org (архив сообщений). Если вас не затруднит, предложите конкретные изменения, которые необходимо внести с вашей точки зрения в текст. Можете также ознакомиться с вики-версией данного документа. Здесь представлены комментарии и внесенные изменения, которые могут касаться вашего вопроса.
Отсутствие поддержки
Публикации в виде рабочих проектов не предполагают поддержку со стороны W3C. Текущий документ является черновиком, поэтому в любой момент времени он может быть обновлен, заменен или вообще вытеснен из общественного пользования другими документами. Цитирование данного документа запрещено, за исключением его дальнейшего усовершенствования.
Патенты
При создании данного документа рабочая группа руководствовалась патентной политикой W3C от 5 февраля 2004. W3C поддерживает публичный список открытых патентов
сформированный совместно с членами группы. Вышеуказанная Web-страница также содержит инструкции по раскрытию патента. Лица, обладающие актуальной информацией о патенте, который удовлетворяет
основным требованиям, должны раскрыть эту информацию согласно пункту 6 патентной политики W3C.
1 Введение
Примечание редактора: На втором заседании F2F рабочая группа приняла решение упростить словарь OWL-онтологий. В последующих версиях данной спецификации терминалы функциональной грамматики и RDF-словарь будут значительно меньшими.
Язык Web-онтологий (OWL, Web Ontology Language) OWL 2 от W3C является языком Semantic Web, созданным для представления онтологий. Под онтологией будем понимать информацию о группировке отдельных индивидов, которые вместе определяют некоторую предметную область (домен). OWL может представлять комплексную обогащенную информацию о классах индивидов и их свойствах. OWL — это логический язык, где каждая конструкция имеет строго определенный смысл. Совокупность таких конструкций позволяет воссоздать некоторую информацию. OWL группирует информацию в онтологии, которые представлены в виде документов. Эти документы могут храниться и передаваться в глобальной сети точно так же, как передаются любые другие данные или информация. Эффективная обработка документов может осуществляться посредством инструментария, позволяющего извлечь информацию, скрытую внутри онтологии.
В этом кратком обзоре раскрыта взаимосвязь OWL с различными технологиями: XML, RDF, базами данных и объектно-ориентированным программированием. Большая часть руководства посвящена исполняемому примеру. Данный пример иллюстрирует многообразие информации, которая может быть представлена посредством OWL. В Приложении представлен законченный пример онтологии. В этом документе рассказывается о том, как OWL "упаковывает" информацию в онтологии, а также о том, как выполнить привязку дополнительной информации к составным частям онтологии. Здесь имеются краткие описания OWL-конструкций со ссылками на другие документы, которые содержат более полную информацию по OWL. И, наконец, описания различных субформ OWL, позволяющие определить выгоды и потери, связанные с использованием каждой из них.
В некотором отношении OWL очень похож на существующие формализмы моделирования, однако с другой стороны данная технология совершенно отличается от других. Некоторые возможности OWL окажутся неожиданным сюрпризом для приверженцев других методологий, а явные преимущества и вовсе могут быть упущены по незнанию. Главная цель данного руководства — ознакомить читателя с основными положениями OWL, его сильными и слабыми сторонами. Если вы захотите больше узнать о конструкциях языка, прочитайте документ Структурный синтаксис OWL 2. В сети выложено в свободное пользование множество руководств, в том числе с привязкой на специальные среды разработки OWL-онтологий.
2 Перспективы
Внешне OWL напоминает многие существующие технологии, что не удивительно в связи с преобладанием XML-синтаксиса и использованием объектно-классовой парадигмы. Тот, кто знаком с другими технологиями, иногда заблуждается в их схожести, а потому искренне удивляется, когда находит отличия. В разделе 2.1 приведено краткое сравнение OWL с несколькими наиболее известными технологиями. В этом руководстве выделены именно те аспекты OWL, которые могут заинтересовать приверженцев других технологий.
В разделе 2.2 обсуждаются основные способы использования OWL в приложениях.
2.1 Взаимосвязь с другими технологиями
Примечание редактора: Рабочая группа обязуется предоставить доступ к разделам, посвященным различным технологиям, пользователям этих технологий. В особенности приветствуются комментарии касательно правдивости приведенных утверждений, чтобы сделать их таковыми.
Примечание редактора: касательно структуры документа: Некоторые пользователи заявили, что расположение данного раздела вначале несколько неуместно. Редакторы рассматривают вопрос о перемещении описания технологий в Приложение. По этому поводу принимаются отзывы.
Примечание редактора: Есть предложение внести в текст документа советы, заметки и маленькие хитрости по технологиям и их применению, и реализовать управление отображением этих элементов, чтобы читатель мог настроить документ под свой вкус и потребности.
2.1.1 Технологии описания ресурсов RDF и RDFS
Среди всех технологий, которые обсуждаются в данном разделе, RDF(S) ближе всего стоит к OWL. Обе они основываются на логическом представлении знаний. В большинстве случаев RDF(S) может рассматриваться как подмножество OWL. И, конечно, RDF/XML является исходным синтаксисом обмена для OWL. Однако все же существуют различия в стиле, выделении и некоторых общепринятых практиках, которые могут привести к заблуждению, если основываться на правилах RDF(S) при работе с OWL. Например, если объявления и выражения OWL могут быть закодированы в виде RDF-фактов (триплетов), то представление большинства объявлений и выражений OWL в виде коллекций является неэффективным ни с точки зрения написания, ни с точки зрения восприятия. С RDF принято работать, как с графовой структурой данных или базой данных, где основное внимание уделяется явным объявлениям в графе.
Если мы рассматриваем RDFS с точки зрения поддержки неявных знаний (например, определение отношений подкласса), в таком случае существует прямая связь между явными и неявными объявлениями. Поэтому достаточно просто концептуализировать вывод с точки зрения манипуляции над графовой структурой. Иначе дело обстоит с определением неявных знаний в OWL (в том числе с определением отношений внутри подкласса, типизацией и проверкой непротиворечивости онтологии), что требует использования методов, похожих на доказательство теорем.
2.1.2 XML
Технологии OWL и XML разделяют несколько общих моментов. Во-первых, OWL может быть выражен с помощью XML (например, RDF/XML или XML-синтаксис для OWL)
, а следовательно и обработан посредством инструментальных средств для XML. Во-вторых, OWL позволяет повторно использовать типы данных и специальные ограничения (facet) для определения производных типов данных XML-схемы. Также в OWL существует несколько вариантов определения типов XML-схемы. И, наконец, обе технологии (OWL и XML) успешно применяются для концептуального моделирования и описания данных. Хотя используемые при этом методы несколько отличаются в рамках каждой из технологий. По сравнению с XML язык OWL ориентирован на более абстрактное и высокоуровневое концептуальное моделирование.
OWL предназначен для поддержки выявления связей между классами посредством автоматизированных рассуждений. В языке Web-онтологий заложено гораздо меньше допущений касательно описываемых сущностей — как в целом, так и в терминах их физической реализации в вычислительных системах.
Обе технологии обеспечивают поддержку высокого уровня абстракции. Однако XML-схема больше нацелена на организацию данных. Ведь главная задача этой технологии заключается в валидации XML-документов.
2.1.3 Базы данных
Базы данных (реляционные или объектно-ориентированные) также обеспечивают хранение и организацию информации. Однако они ориентированы на работу в средах, где доступна вся необходимая для приложения информация, где важность представляет анализ целостности данных при одновременном доступе и обновлении данных, или где приходится работать с большим объемом данных. Технология OWL нацелена в большей степени на гибкое и выразительное описание данных (или информации). Здесь информация считается полной, если полнота может быть установлена с помощью другой информации.
Онтологии на базе OWL гораздо мощнее и гибче, нежели схемы баз данных. В основном схемы баз данных лишь определяют те виды информации, которые могут быть связаны с объектами (или кортежами), принадлежащими какому-либо классу (или таблице). В OWL-онтологиях классы могут предназначаться для аналогичных целей, однако они также могут содержать условия по распознаванию, поэтому явная типизация в OWL необязательна. Безусловно, наличие подобной гибкости в OWL при определении типов может потребовать сложных выводов.
Последнее важное различие между базами данных и OWL заключается в том, что информация, хранимая в базе, определяется посредством схемы базы данных и ограничений целостности. Если схема не поддерживает хранение определенных типов информации или информация нарушает принятые ограничения целостности, тогда эта информация не может быть сохранена в базе данных. С другой стороны, OWL позволяет связать информацию произвольного типа практически с любым объектом, если в онтологии ничего не противоречит этой связи. Поэтому с точки зрения хранения информации OWL гораздо гибче.
2.1.4 Объектно-ориентированное программирование
Объектно-ориентированное программирование (ООП) также характеризуется моделированием относительно объекта, и поэтому имеет много общего с OWL. Однако ООП в основном используется в контексте полной информации. Здесь информация об объекте, которая потенциально может быть получена, ограничена типом этого объекта. Как и с базами данных, основное отличие ООП от OWL состоит в разной степени полноты информации об объекте. Аналогично классы в ООП гораздо менее экспрессивны, чем OWL-классы.
Более того, язык Web-онтологий является строго декларативным и логическим. Следовательно, OWL не присущи компоненты ООП, как, например, методы. Рассуждения в OWL основаны на четкой логике, где нет ничего схожего на наследование, а уж тем более на наследование с исключениями или с переопределением.
OWL применяется для решения различных задач и для различных доменов — перечислить все просто невозможно. Однако все же стоит рассмотреть несколько примеров, чтобы получить представление о проблемах, которые позволяет решить OWL.
Для эффективного использования всех возможностей OWL необходимы некоторые умения.
2.1.5 OWL 1
OWL 2 представляет собой доработанный язык Web-онтологий (OWL), совместимый с предыдущей версией. В OWL 2 добавлено несколько новых конструкций для расширения экспрессивности языка, в том числе конструкции по ограничению кардинальности, цепочки ролей и предикаты эксплицитных данных. OWL 2 также включает новую XML-сериализацию (нацелен на взаимодействие с набором инструментов XML, то есть XSLT, языками схем и т. д.) и набор подмножеств профилей с разнообразным применением и вычислительными свойствами.
Для тех, кто интересуется OWL 1, стоит ознакомиться с соответствующими документами по OWL 1:
Обзор
и Руководство по языку. Исходя из того, что каждая онтология OWL 1 является также онтологией OWL 2, в документации по OWL 1 содержится небольшое введение в OWL 2 (хотя только по синтаксису RDF/XML). Существует и другая документация по OWL 1, которая доступна на сайте рабочей группы WebOnt.
Примечание редактора: Несколько позднее будет написан раздел об отличиях между OWL 1 и OWL 2.
2.2 Практическое применение
2.2.1 Разработка и управление терминологией
Терминология, управляемые словари, таксономия и тому подобные вещи используются для целого ряда задач информационного поиска (IR, information retrieval), например, расширение запросов или поддержка доступа по специальным ограничениям (facet). Предопределенная терминология также может применяться для упорядочивания записей (при поддержке IR) или направления пользователя по определенному пути. К примеру, в медицинских системах поддержки принятия решений определенная форма или ее часть отображается на экране, когда врач собирается выполнить специфические процедуры, которые в свою очередь определяются путем выявления комбинации терминов из управляющего словаря.
Создание и поддержка большого терминологического словаря — времяемкая и трудозатратная задача даже при относительно простой структуре терминологии. Поддержка данного процесса осуществляется в OWL несколькими способами:
- разработчики могут кодировать модели домена вместо того, чтобы кодировать отношения между терминами (которые впоследствии будут получены из модели). Такой подход позволяет выполнить независимую проверку корректности терминологического отношения. Формальные семантики OWL дают точные смысловые обозначения любым определениям. Эти значения доступны другим разработчикам моделей, а также могут быть использованы инструментальными средствами.
- блоки рассуждений могут подтверждать непротиворечивость моделей (и определений). Например, механизм рассуждений позволяет установить возможность наличия экземпляра в определении класса.
- блоки рассуждений могут извлечь скрытую информацию из определений. Иными словами процедуры вывода будут автоматически проверять предполагаемый порядок следования и выявлять неупорядоченные элементы.
- блоки рассуждений могут анализировать терминологию в целом для получения дополнительной информации о ее структуре. Например, для определения неравномерности или выявления логически независимых друг от друга (однако взаимозависимых в отдельности) подмножеств внутри терминологии (логически независимые части терминологии могут быть удалены либо расширены).
OWL использовался для поддержки огромных терминологических словарей с сотней тысяч терминов и сложной иерархией. Galen? NCI? SNOMED? Большая работа проделана с помощью OWL в домене HCLS (Health Care and Life Sciences, Здоровье и науки о жизни), где присутствует изобилие опыта разработки объемных терминологических словарей.
В прошлом блоки рассуждений OWL широко использовались лишь на этапе разработки терминологий, то есть в разрыве от практического приложения. В таком случае механизм рассуждений выступает в роли "терминологического компилятора", формирующего полную таксономию из определений терминов. Затем таксономия развертывается в приложении. В задачах поиска относительно неизменных коллекций это приемлемый способ совладать со сложностью рассуждений больших онтологий. Однако с увеличением вычислительной мощности механизм рассуждений OWL стал более оптимизированным. Возросло использование блоков рассуждений OWL в терминологических приложениях онлайн и в процессе развертывания. В частности стала широко применяться "посткоординация" — способность субъекта расширять терминологию для более адекватного представления ситуации. Динамическое расширение терминологии в критических системах имеет явную выгоду перед методологической неизменностью, которая поддерживалась блоками рассуждений OWL. Вместо того, чтобы просто создавать новый термин и помещать его в произвольное место таксономии, теперь приветствуется совершенствование терминов путем уточнения их определений конечными пользователями.
Приведем простой пример: врач хочет сделать запись о пациенте, у которого аллергия на миндаль. Тогда ему следует указать, что миндаль — это разновидность ореха. После чего система сможет определить, что аллергия на миндаль является специфической формой аллергии на орехи, и как обычно предоставить пользователю необходимый совет или соответствующие формы ввода данных. Конечно, в таком случае целесообразнее создать приложение на основе существующей расширенной онтологии (например, OpenCyc), в которой уже заложена информация о том, что миндаль — это орех. Это избавит медика от необходимости обучения системы на предмет миндаля.
2.2.2 Концептуальное моделирование
Из предыдущего раздела вытекает основное преимущество OWL, которое состоит в поддержке моделирования предметной области (домена), то есть в концептуальном моделировании. OWL является мощным языком концептуального моделирования. С его помощью, к примеру, можно легко закодировать большую часть схем сущность-связь и UML-диаграмм. Закодировав информацию единожды, блоки рассуждений OWL могут находить скрытые отношения, конфликты и пропущенные элементы. Так как OWL позволяет описывать неполную информацию и взаимодействовать с ней, он отлично подходит для высокоуровневого концептуального моделирования, при этом вы не только занимаетесь абстракцией на физическом или логическом уровне информационной системы, но и по-прежнему не уверены касательно различных аспектов концептуальной структуры. OWL позволяет отложить моделирование некоторых решений, в то время как вы можете продолжить эффективно использовать то, что вам уже хорошо известно.
OWL поддерживает разные стили моделирования, например, "сверху вниз" или "снизу вверх", итеративное или прямолинейное, ориентированное на уточнение или, наоборот, на обобщение. В процессе моделирования механизм рассуждений (и другие инструменты) обеспечивает непрерывное взаимодействие с моделью. В действительности, порой отсутствие какой-либо реакции механизма рассуждений дает очень ценную информацию субъекту, осуществляющему моделирование (то есть модель описана хуже, чем ожидалось).
Концептуальные модели на базе OWL могут использоваться для объединения информации. Положим, к примеру, вы столкнулись с необходимостью объединения двух приложений баз данных с совершенно разными схемами, однако сходными (во всяком случае, на первый взгляд) концептуальными моделями. При трансформации обеих моделей в OWL и соединении их друг с другом могут быть найдены как скрытые отношения, так и противоречивость моделей (или несовместимость с вашим представлением об отношениях). По ходу изучения процессов на концептуальном уровне не стоит удивляться иррелевантному низкому уровню деталей реализации. Исходя из того, что модели имеют четкую семантику, они могут систематически проверяться. Чтобы не заниматься утомительной проверкой соответствий вручную, вы можете задать необходимые настройки моделирования.
Концептуальные модели на основе OWL использовались непосредственно для объединения несовместимых информационных систем. Существует несколько методов: начиная с рассмотрения концептуальных моделей в виде высокоуровневых схем для хранилищ данных на основе RDF, и заканчивая использованием концептуальных моделей для построения распределенных запросов в домашних системах данных.
3 Основные понятия
OWL позволяет выразить информацию об окружающем мире, а затем построить определенные выводы на ее основе. Инструментальные средства OWL — блоки рассуждений — дают возможность автоматически сформировать эти выводы. В терминах OWL мы предполагаем, что окружающий мир в основном состоит из отдельных сущностей (обычно известных как индивиды или объекты). Индивиды взаимосвязаны друг с другом и со значениями данных посредством свойств. С помощью OWL мы можем сгруппировать индивиды, обладающие определенными характеристиками, в классы.
OWL является частью Semantic Web, поэтому имена в OWL представлены в виде международных идентификаторов ресурсов (IRI, international resource identifier). Так как IRI достаточно длинный, мы будем использовать в OWL компактный вариант написания, состоящий из префикса и ссылки, разделенных двоеточием. Существует множество доступных вариантов OWL-синтаксиса, служащих разнообразным целям. Когда OWL-информация передается по сети, она записана на диалекте XML.
Самым простым в восприятии (даже для неспециалиста) является манчестерский синтаксис [OWL 2 Манчестерский синтаксис]. Функциональный синтаксис [Спецификация ОWL 2] более прост с точки зрения спецификации и использования в рамках инструментов рассуждений. Синтаксис OWL XML — это XML-синтаксис для OWL, который определен посредством XML-схемы [Спецификация ОWL 2]. Синтаксис RDF/XML для OWL представляет собой простой RDF/XML со специфическим преобразованием для OWL-конструкций [Преобразование OWL 2 в RDF]. Есть специальные инструментальные средства перевода между разными диалектами синтаксиса OWL.
Законченный исполняемый пример онтологии, расположенный в Приложении, можно просмотреть в любом из четырех предложенных вариантов синтаксиса (по умолчанию отображается только манчестерский синтаксис).
Нижеприведенные кнопки позволяют скрыть или отобразить четыре варианта синтаксиса.
Положим, мы хотим представить информацию об отдельной семье. (Этот пример вовсе не является репрезентативным в отношении предметных областей, с которыми может оперировать OWL. Он не претендует на образец хорошего моделирования посредством OWL. Также не является корректным отображением достаточно сложных, изменчивых и политически скользких вопросов в домене семей. Вместо этого, мы намеревались представить простой обзор возможностей OWL.) Сначала нам необходимо определить, какие индивиды фигурируют в семье, и как они взаимосвязаны друг с другом, какие значения данных связаны с ними. После этого мы сможем записать все эти сведения при помощи OWL.
Итак, если мы имеем семью с родителями John и
Mary и детьми Susan
и Bill
можем задать индивидов и записать все эти факты вместе с
фактами о возрасте (age), как во фрагменте кода ниже..
Манчестерский синтаксис:
Individual: f:John
Facts: f:hasWife f:Mary,
f:hasSon f:Bill,
f:hasDaughter f:Susan,
f:hasAge 33
Individual: f:Mary
Facts: f:hasSon f:Bill,
f:hasDaughter f:Susan,
f:hasAge 31
Individual: f:Bill
Facts: f:hasAge 13
Individual: f:Susan
Facts: f:hasAge 8
Функциональный синтаксис:
ObjectPropertyAssertion(f:John f:hasWife f:Mary)
ObjectPropertyAssertion(f:John f:hasSon f:Bill)
ObjectPropertyAssertion(f:John f:hasDaughter f:Susan)
DataPropertyAssertion(f:John f:hasAge "33"^^xsd:integer)
ObjectPropertyAssertion(f:Mary f:hasSon f:Bill)
ObjectPropertyAssertion(f:Mary f:hasDaughter f:Susan)
DataPropertyAssertion(f:Mary f:hasAge "31"^^xsd:integer)
DataPropertyAssertion(f:Bill f:hasAge "13"^^xsd:integer)
DataPropertyAssertion(f:Susan f:hasAge "8"^^xsd:integer)
OWL XML синтаксис:
<ObjectPropertyAssertion>
<ObjectProperty URI="&f;hasWife"/>
<Individual URI="&f;John"/>
<Individual URI="&f;Mary"/>
</ObjectPropertyAssertion>
<ObjectPropertyAssertion>
<ObjectProperty URI="&f;hasSon"/>
<Individual URI="&f;John"/>
<Individual URI="&f;Bill"/>
</ObjectPropertyAssertion>
<ObjectPropertyAssertion>
<ObjectProperty URI="&f;hasDaughter"/>
<Individual URI="&f;John"/>
<Individual URI="&f;Susan"/>
</ObjectPropertyAssertion>
<DataPropertyAssertion>
<DataProperty URI="&f;hasAge"/>
<Individual URI="&f;John"/>
<Constant datatypeURI="&xsd;integer">33</Constant>
</DataPropertyAssertion>
<ObjectPropertyAssertion>
<ObjectProperty URI="&f;hasSon"/>
<Individual URI="&f;Mary"/>
<Individual URI="&f;Bill"/>
</ObjectPropertyAssertion>
<ObjectPropertyAssertion>
<ObjectProperty URI="&f;hasDaughter"/>
<Individual URI="&f;Mary"/>
<Individual URI="&f;Susan"/>
</ObjectPropertyAssertion>
<DataPropertyAssertion>
<DataProperty URI="&f;hasAge"/>
<Individual URI="&f;Mary"/>
<Constant datatypeURI="&xsd;integer">31</Constant>
</DataPropertyAssertion>
<DataPropertyAssertion>
<DataProperty URI="&f;hasAge"/>
<Individual URI="&f;Bill"/>
<Constant datatypeURI="&xsd;integer">13</Constant>
</DataPropertyAssertion>
<DataPropertyAssertion>
<DataProperty URI="&f;hasAge"/>
<Individual URI="&f;Susan"/>
<Constant datatypeURI="&xsd;integer">8</Constant>
</DataPropertyAssertion>
RDF/XML синтаксис:
<rdf:Description rdf:about="&f;John">
<f:hasWife rdf:resource="&f;Mary" />
<f:hasSon rdf:resource="&f;Bill" />
<f:hasDaughter rdf:resource="&f;Susan" />
<f:hasAge rdf:datatype="http://www.w3.org/2001/XMLSchema#integer">33</f:hasage>
</rdf:Description>
<rdf:Description rdf:about="&f;Mary">
<f:hasSon rdf:resource="&f;Bill" />
<f:hasDaughter rdf:resource="&f;Susan" />
<f:hasAge rdf:datatype="http://www.w3.org/2001/XMLSchema#integer">31</f:hasage>
</rdf:Description>
<rdf:Description rdf:about="&f;Bill">
<f:hasAge rdf:datatype="http://www.w3.org/2001/XMLSchema#integer">13</f:hasage>
</rdf:Description>
<rdf:Description rdf:about="&f;Susan">
<f:hasAge rdf:datatype="http://www.w3.org/2001/XMLSchema#integer">8</f:hasage>
</rdf:Description>
Мы также должны записать информацию о поле(gender) этих людей, установив значения либо male, либо female для gender.
Манчестерский синтаксис:
Individual: f:John Facts: f:hasGender f:male
Individual: f:Mary Facts: f:hasGender f:female
Individual: f:Bill Facts: f:hasGender f:male
Individual: f:Susan Facts: f:hasGender f:female
Individual: f:male
Individual: f:female
Функциональный синтаксис:
ObjectPropertyAssertion(f:John f:hasGender f:male)
ObjectPropertyAssertion(f:Mary f:hasGender f:female)
ObjectPropertyAssertion(f:Bill f:hasGender f:male)
ObjectPropertyAssertion(f:Susan f:hasGender f:female)
OWL XML синтаксис:
<ObjectPropertyAssertion>
<ObjectProperty URI="&f;hasGender"/>
<Individual URI="&f;John"/>
<Individual URI="&f;male"/>
</ObjectPropertyAssertion>
<ObjectPropertyAssertion>
<ObjectProperty URI="&f;hasGender"/>
<Individual URI="&f;Mary"/>
<Individual URI="&f;female"/>
</ObjectPropertyAssertion>
<ObjectPropertyAssertion>
<ObjectProperty URI="&f;hasGender"/>
<Individual URI="&f;Bill"/>
<Individual URI="&f;male"/>
</ObjectPropertyAssertion>
<ObjectPropertyAssertion>
<ObjectProperty URI="&f;hasGender"/>
<Individual URI="&f;Susan"/>
<Individual URI="&f;female"/>
</ObjectPropertyAssertion>
RDF/XML синтаксис:
<rdf:Description rdf:about="&f;John">
<f:hasGender rdf:resource="&f;male" />
</rdf:Description>
<rdf:Description rdf:about="&f;Mary">
<f:hasGender rdf:resource="&f;female" />
</rdf:Description>
<rdf:Description rdf:about="&f;Bill">
<f:hasGender rdf:resource="&f;male" />
</rdf:Description>
<rdf:Description rdf:about="&f;Susan">
<f:hasGender rdf:resource="&f;female" />
</rdf:Description>
<rdf:Description rdf:about="&f;male"/>
<rdf:Description rdf:about="&f;female"/>
Однако, все, чем мы занимались до настоящего времени, — лишь фиксация основных фактов о конкретной семье. В известной мере мы работали лишь с "RDF" составляющей OWL: с помощью тегов записывали индивидов в виде экземпляров поименованных классов и связывали их с другими индивидами посредством свойств. Несмотря на то, что все это весьма полезно, OWL также позволяет описать общие правила формирования семей.
Итак, давайте задумаемся, как устроены семьи вообще. (Этот процесс называется представлением знаний. Как и для любого процесса представления информации об окружающем мире, нам потребуются некоторые упрощения. А так как этот документ является начальным руководством, допущений будет много.) Для начала заметим, что все индивиды семьи — это люди. Поэтому у нас должен быть отдельный
класс людей с именем Person.
Ниже представлена информация о некоторых свойствах.
Жена(wife) это отношение между людьми (Person)то есть и доменом(Domain) и диапазоном (range) для wife будет Person,
как собственно для son и daughter.
Возраст(age) это связь
между Person
с integer.
Манчестерский синтаксис:
Class: f:Person
ObjectProperty: f:hasWife Domain: f:Person Range: f:Person
ObjectProperty: f:hasSon Domain: f:Person Range: f:Person
ObjectProperty: f:hasDaughter Domain: f:Person Range: f:Person
DataProperty: f:hasAge Domain: f:Person Range: integer
Функциональный синтаксис:
ObjectPropertyDomain(f:hasWife f:Person)
ObjectPropertyRange(f:hasWife f:Person)
ObjectPropertyDomain(f:hasSon f:Person)
ObjectPropertyRange(f:hasSon f:Person)
ObjectPropertyDomain(f:hasDaughter f:Person)
ObjectPropertyRange(f:hasDaughter f:Person)
DataPropertyDomain(f:hasAge f:Person)
DataPropertyRange(f:hasAge xsd:integer)
OWL XML синтаксис:
<ObjectPropertyDomain>
<ObjectProperty URI="&f;hasWife"/>
<OWLClass URI="&f;Person"/>
</ObjectPropertyDomain>
<ObjectPropertyRange>
<ObjectProperty URI="&f;hasWife"/>
<OWLClass URI="&f;Person"/>
</ObjectPropertyRange>
<ObjectPropertyDomain>
<ObjectProperty URI="&f;hasSon"/>
<OWLClass URI="&f;Person"/>
</ObjectPropertyDomain>
<ObjectPropertyRange>
<ObjectProperty URI="&f;hasSon"/>
<OWLClass URI="&f;Person"/>
</ObjectPropertyRange>
<ObjectPropertyDomain>
<ObjectProperty URI="&f;hasDaughter"/>
<OWLClass URI="&f;Person"/>
</ObjectPropertyDomain>
<ObjectPropertyRange>
<ObjectProperty URI="&f;hasDaughter"/>
<OWLClass URI="&f;Person"/>
</ObjectPropertyRange>
<DataPropertyDomain>
<DataProperty URI="&f;hasAge"/>
<OWLClass URI="&f;Person"/>
</DataPropertyDomain>
<DataPropertyRange>
<DataProperty URI="&f;hasAge"/>
<Datatype URI="&xsd;integer"/>
</DataPropertyRange>
RDF/XML синтаксис:
<owl:Class rdf:about="&f;Person" />
<owl:ObjectProperty rdf:about="&f;hasWife">
<rdfs:domain rdf:resource="&f;Person" />
<rdfs:range rdf:resource="&f;Person" />
</owl:ObjectProperty>
<owl:ObjectProperty rdf:about="&f;hasSon">
<rdfs:domain rdf:resource="&f;Person" />
<rdfs:range rdf:resource="&f;Person" />
</owl:ObjectProperty>
<owl:ObjectProperty rdf:about="&f;hasDaughter">
<rdfs:domain rdf:resource="&f;Person" />
<rdfs:range rdf:resource="&f;Person" />
</owl:ObjectProperty>
<owl:DataProperty rdf:about="&f;hasAge">
<rdfs:domain rdf:resource="&f;Person" />
<rdfs:range rdf:resource="http://www.w3.org/2001/XMLSchema#integer" />
</owl:ObjectProperty>
Из вышеприведенной информации мы (либо механизм рассуждений) можем заключить, что John принадлежит к класу
Person, ведь домен
wife характерен для Person, а у John
есть
wife.
Мы также можем сразу установить принадлежность индивида к классу.
Манчестерский синтаксис:
Individual: f:John Types: f:Person
Функциональный синтаксис:
ClassAssertion(f:Person f:John)
OWL XML синтаксис:
<ClassAssertion>
<OWLClass URI="&f;Person"/>
<Individual URI="&f;John"/>
</ClassAssertion>
RDF/XML синтаксис:
<f:Person rdf:about="&f;John" />
Даже из этого небольшого описания семейных отношений можно сделать несколько дополнительных выводов. Например, обратным свойством для wife является
husband. Так же, как son и daughter будет специализацией отношения child. Далее, ни один индивид не может быть одновременно и son, и daughter, то есть эти свойства непересекающиеся. В большинстве случаев индивидам присуще единственное значение возраста, поэтому age
обладает функциональным свойством данных. По большей части индивидам присуще только одно отношение wife, и ни один индивид не может быть wife самим для себя. Поэтому свойство wife является
функциональным,
обратно функциональным, и нерефлексивным.(Можно указать, что свойство является рефлексивным, но зачастую этого не делают, ведь тогда свойство будет нерефлексивным.(Можно указать, что свойство является рефлексивным для всех индивидов.) Также wife
является асимметричным. Обратите внимание, что мы расширили информацию о некоторых свойствах. Размещение информации о свойстве (классе или индивиде) в нескольких местах — широко используемая практика в OWL.
Манчестерский синтаксис:
ObjectProperty: f:hasHusband Inverses: f:hasWife
ObjectProperty: f:hasChild Domain: f:Person range f:Person
ObjectProperty: f:hasSon SubPropertyOf: f:hasChild
ObjectProperty: f:hasDaughter SubPropertyOf: f:hasChild
DisjointObjectProperties: f:hasSon f:hasDaughter
DataProperty: f:hasAge Characteristics: Functional
ObjectProperty: f:hasWife Characteristics: Functional, InverseFunctional, Irreflexive, Asymmetric
Функциональный синтаксис:
InverseObjectProperties(f:hasHusband f:hasWife)
ObjectPropertyDomain(f:hasChild f:Person)
ObjectPropertyRange(f:hasChild f:Person)
SubObjectPropertyOf(f:hasSon f:hasChild)
SubObjectPropertyOf(f:hasDaughter f:hasChild)
DisjointObjectProperties(f:hasSon f:hasDaughter)
FunctionalDataProperty(f:hasAge)
FunctionalObjectProperty(f:hasWife)
InverseFunctionalObjectProperty(f:hasWife)
IrreflexiveObjectProperty(f:hasWife)
AsymmetricObjectProperty(f:hasWife)
OWL XML синтаксис:
<InverseObjectProperties>
<ObjectProperty URI="&f;hasHusband"/>
<ObjectProperty URI="&f;hasWife"/>
</InverseObjectProperties>
<ObjectPropertyDomain>
<ObjectProperty URI="&f;hasChild"/>
<OWLClass URI="&f;Person"/>
</ObjectPropertyDomain>
<ObjectPropertyRange>
<ObjectProperty URI="&f;hasChild"/>
<OWLClass URI="&f;Person"/>
</ObjectPropertyRange>
<SubObjectPropertyOf>
<ObjectProperty URI="&f;hasSon"/>
<ObjectProperty URI="&f;hasChild"/>
</SubObjectPropertyOf>
<SubObjectPropertyOf>
<ObjectProperty URI="&f;hasDaughter"/>
<ObjectProperty URI="&f;hasChild"/>
</SubObjectPropertyOf>
<DisjointObjectProperties>
<ObjectProperty URI="&f;hasDaughter"/>
<ObjectProperty URI="&f;hasSon"/>
</DisjointObjectProperties>
<FunctionalDataProperty>
<DataProperty URI="&f;hasAge"/>
</FunctionalDataProperty>
<FunctionalObjectProperty>
<ObjectProperty URI="&f;hasWife"/>
</FunctionalObjectProperty>
<InverseFunctionalObjectProperty>
<ObjectProperty URI="&f;hasWife"/>
</InverseFunctionalObjectProperty>
<IrreflexiveObjectProperty>
<ObjectProperty URI="&f;hasWife"/>
</IrreflexiveObjectProperty>
<AsymmetricObjectProperty>
<ObjectProperty URI="&f;hasWife"/>
</AsymmetricObjectProperty>
RDF/XML синтаксис:
<owl:ObjectProperty rdf:about="#hasHusband">
<owl:inverseOf rdf:resource="#hasWife"/>
</owl:ObjectProperty>
<owl:ObjectProperty rdf:about="#hasChild">
<rdfs:domain rdf:resource="#Person"/>
<rdfs:range rdf:resource="#Person"/>
</owl:ObjectProperty>
<owl:ObjectProperty rdf:about="#hasSon">
<rdfs:subPropertyOf rdf:resource="#hasChild"/>
</owl:ObjectProperty>
<owl:ObjectProperty rdf:about="#hasDaughter">
<rdfs:subPropertyOf rdf:resource="#hasChild"/>
</owl:ObjectProperty>
<owl:ObjectProperty rdf:about="#hasSon">
<owl2:disjointObjectProperties rdf:resource="#hasDaughter"/>
</owl:ObjectProperty>
<owl:DatatypeProperty rdf:about="#hasAge">
<rdf:type rdf:resource="&owl;FunctionalProperty"/>
</owl:DatatypeProperty>
<owl:ObjectProperty rdf:about="#hasWife">
<rdf:type rdf:resource="&owl;FunctionalProperty"/>
<rdf:type rdf:resource="&owl;InverseFunctionalProperty"/>
<rdf:type rdf:resource="&owl2;IrreflexiveProperty"/>
<rdf:type rdf:resource="&owl2;AsymmetricProperty"/>
</owl:ObjectProperty>
Вышеприведенная информация о семьях вообще и о нашей конкретной семье в частности имеет целый ряд следствий. К примеру, если husband является обратным свойством wife, то мужем для Mary будет John. Полностью укомплектованные инструментальные средства рассуждений OWL позволяют установить возможность вывода определенных следствий из имеющейся информации.
Таким образом, мы записали довольно много информации о семьях, используя только один класс: Person. OWL — это мощный язык описания классов в терминах других классов, а также в терминах обязательных или необязательных отношений экземпляров классов с другими индивидами. Итак, у нас могут быть классы мужчин, женщин и родителей, каждый из которых является специализацией Person.
Манчестерский синтаксис:
Class: f:Man SubClassOf: f:Person
Class: f:Woman SubClassOf: f:Person
Class: f:Parent SubClassOf: f:Person
Функциональный синтаксис:
SubClassOf(f:Man f:Person)
SubClassOf(f:Woman f:Person)
SubClassOf(f:Parent f:Person)
OWL XML синтаксис:
<SubClassOf>
<OWLClass URI="&f;Man"/>
<OWLClass URI="&f;Person"/>
</SubClassOf>
<SubClassOf>
<OWLClass URI="&f;Woman"/>
<OWLClass URI="&f;Person"/>
</SubClassOf>
<SubClassOf>
<OWLClass URI="&f;Parent"/>
<OWLClass URI="&f;Person"/>
</SubClassOf>
RDF/XML синтаксис:
<owl:Class rdf:about="#Man">
<rdfs:subClassOf rdf:resource="#Parent">
</owl:Class>
<owl:Class rdf:about="#Woman">
<rdfs:subClassOf rdf:resource="#Parent">
</owl:Class>
<owl:Class rdf:about="#Parent">
<rdfs:subClassOf rdf:resource="#Parent">
</owl:Class>
OWL позволяет выполнить гораздо больше различных манипуляций с классами, чем просто создание обобщений для них.
OWL может предоставлять частичную или полную информацию о том, какие элементы должны принадлежать классу. (Конструкции OWL, используемые для представления информации о классах, называют описаниями.) Скажем, если у людей — мужского (male) или женского (female) пола — может быть только один age и один gender,
это дает (частичную) информацию о людях. Не только о том, что каждый индивид, который принадлежит к классу Man также принадлежит Person,
но и о том, что каждый Person с gender, соответствующим male, принадлежит к классу Man (аналогично для Woman). Таким образом, появляется полная информация о требованиях для принадлежности к этим двум классам. Можем также полагать, что каждый Person, у которого есть, по крайней мере, один child, принадлежит классу Parent.
Манчестерский синтаксис:
ObjectProperty: f:hasGender
Class: f:Person SubClassOf: f:hasAge exactly 1 and
f:hasGender exactly 1 and
f:hasGender only {f:female , f:male}
Class: f:Man EquivalentTo: f:Person and f:hasGender value f:male
Class: f:Woman EquivalentTo: f:Person and f:hasGender value f:female
Class: f:Parent EquivalentTo: f:Person and f:hasChild min 1 f:Person
Функциональный синтаксис:
SubClassOf(f:Person
ObjectIntersectionOf(DataExactCardinality(1 f:hasAge)
ObjectExactCardinality(1 f:hasGender)
ObjectAllValuesFrom(f:hasGender ObjectOneOf(f:female f:male))))
EquivalentClasses(f:Man
ObjectIntersectionOf(f:Person ObjectHasValue(f:hasGender f:male)))
EquivalentClasses(f:Woman
ObjectIntersectionOf(f:Person ObjectHasValue(f:hasGender f:female)))
EquivalentClasses(f:Parent
ObjectIntersectionOf(f:Person ObjectMinCardinality(1 f:hasChild f:Person)))
OWL XML синтаксис:
<SubClassOf>
<OWLClass URI="&f;Person"/>
<ObjectIntersectionOf>
<DataExactCardinality cardinality="1">
<DataProperty URI="&f;hasAge"/>
</DataExactCardinality>
<ObjectExactCardinality cardinality="1">
<ObjectProperty URI="&f;hasGender"/>
</ObjectExactCardinality>
<ObjectAllValuesFrom>
<ObjectProperty URI="&f;hasGender"/>
<ObjectOneOf>
<Individual URI="&f;female"/>
<Individual URI="&f;male"/>
</ObjectOneOf>
</ObjectAllValuesFrom>
</ObjectIntersectionOf>
</SubClassOf>
<EquivalentClasses>
<OWLClass URI="&f;Man"/>
<ObjectIntersectionOf>
<ObjectHasValue>
<ObjectProperty URI="&f;hasGender"/>
<Individual URI="&f;male"/>
</ObjectHasValue>
<OWLClass URI="&f;Person"/>
</ObjectIntersectionOf>
</EquivalentClasses>
<EquivalentClasses>
<OWLClass URI="&f;Woman"/>
<ObjectIntersectionOf>
<OWLClass URI="&f;Person"/>
<ObjectHasValue>
<ObjectProperty URI="&f;hasGender"/>
<Individual URI="&f;female"/>
</ObjectHasValue>
</ObjectIntersectionOf>
</EquivalentClasses>
<EquivalentClasses>
<OWLClass URI="&f;Parent"/>
<ObjectIntersectionOf>
<ObjectMinCardinality cardinality="1">
<ObjectProperty URI="&f;hasChild"/>
<OWLClass URI="&f;Person"/>
</ObjectMinCardinality>
<OWLClass URI="&f;Person"/>
</ObjectIntersectionOf>
</EquivalentClasses>
RDF/XML синтаксис:
<owl:ObjectProperty rdf:about="#hasGender"/>
<owl:Class rdf:about="#Person">
<rdfs:subClassOf>
<owl:Class>
<owl:intersectionOf rdf:parseType="Collection">
<owl:Restriction>
<owl:onProperty rdf:resource="#hasGender"/>
<owl:allValuesFrom>
<owl:Class>
<owl:oneOf rdf:parseType="Collection">
<rdf:Description rdf:about="#female"/>
<rdf:Description rdf:about="#male"/>
</owl:oneOf>
</owl:Class>
</owl:allValuesFrom>
</owl:Restriction>
<owl:Restriction>
<owl:onProperty rdf:resource="#hasGender"/>
<owl:cardinality rdf:datatype="&xsd;nonNegativeInteger">1</owl:cardinality>
</owl:Restriction>
<owl:Restriction>
<owl:onProperty rdf:resource="#hasAge"/>
<owl:cardinality rdf:datatype="&xsd;nonNegativeInteger">1</owl:cardinality>
</owl:Restriction>
</owl:intersectionOf>
</owl:Class>
</rdfs:subClassOf>
</owl:Class>
<owl:Class rdf:about="#Man">
<owl:equivalentClass>
<owl:Class>
<owl:intersectionOf rdf:parseType="Collection">
<rdf:Description rdf:about="#Person"/>
<owl:Restriction>
<owl:onProperty rdf:resource="#hasGender"/>
<owl:hasValue rdf:resource="#male"/>
</owl:Restriction>
</owl:intersectionOf>
</owl:Class>
</owl:equivalentClass>
</owl:Class>
<owl:Class rdf:about="#Woman">
<owl:equivalentClass>
<owl:Class>
<owl:intersectionOf rdf:parseType="Collection">
<rdf:Description rdf:about="#Person"/>
<owl:Restriction>
<owl:onProperty rdf:resource="#hasGender"/>
<owl:hasValue rdf:resource="#female"/>
</owl:Restriction>
</owl:intersectionOf>
</owl:Class>
</owl:equivalentClass>
</owl:Class>
<owl:Class rdf:about="#Parent">
<owl:equivalentClass>
<owl:Class>
<owl:intersectionOf rdf:parseType="Collection">
<owl:Restriction>
<owl:onProperty rdf:resource="#hasChild"/>
<owl2:onClass rdf:resource="#Person"/>
<owl:minCardinalityQ rdf:datatype="&xsd;nonNegativeInteger">1</owl:minCardinalityQ>
</owl:Restriction>
<rdf:Description rdf:about="#Person"/>
</owl:intersectionOf>
</owl:Class>
</owl:equivalentClass>
</owl:Class>
Полные описания в OWL позволяют вывести множество следствий. Как, например, из вышеприведенных описаний, где John принадлежит к Man и Parent. Многие следствия могут показаться неожиданными для пользователей, поэтому некоторые инструментальные средства OWL обладают (элементарными) возможностями демонстрации последовательности вывода следствий.
Описания в OWL могут фигурировать практически в любом месте, где используются имена классов. Так, например, можем предусмотреть информацию о свойствах wife, son и daughter, добавив для них более специфические домены и диапазоны.
Манчестерский синтаксис:
ObjectProperty: f:hasWife Domain: f:Man Range: f:Woman
ObjectProperty: f:hasSon Domain: f:Parent
Range: Person that f:hasGender value f:male
ObjectProperty: f:hasDaughter Domain: f:Parent
Range: Person that f:hasGender value f:female
Функциональный синтаксис:
ObjectPropertyDomain(f:hasWife f:Man)
ObjectPropertyRange(f:hasWife f:Woman)
ObjectPropertyDomain(f:hasSon f:Parent)
ObjectPropertyRange(f:hasSon
ObjectIntersectionOf(f:Person ObjectHasValue(f:hasGender f:male)))
ObjectPropertyDomain(f:hasDaughter f:Parent)
ObjectPropertyRange(f:hasDaughter
ObjectIntersectionOf(f:Person ObjectHasValue(f:hasGender f:female)))
OWL XML синтаксис:
<ObjectPropertyDomain>
<ObjectProperty URI="&f;hasWife"/>
<OWLClass URI="&f;Man"/>
</ObjectPropertyDomain>
<ObjectPropertyRange>
<ObjectProperty URI="&f;hasWife"/>
<OWLClass URI="&f;Woman"/>
</ObjectPropertyRange>
<ObjectPropertyDomain>
<ObjectProperty URI="&f;hasSon"/>
<OWLClass URI="&f;Parent"/>
</ObjectPropertyDomain>
<ObjectPropertyRange>
<ObjectProperty URI="&f;hasSon"/>
<ObjectIntersectionOf>
<ObjectHasValue>
<ObjectProperty URI="&f;hasGender"/>
<Individual URI="&f;male"/>
</ObjectHasValue>
<OWLClass URI="&f;Person"/>
</ObjectIntersectionOf>
</ObjectPropertyRange>
<ObjectPropertyDomain>
<ObjectProperty URI="&f;hasDaughter"/>
<OWLClass URI="&f;Parent"/>
</ObjectPropertyDomain>
<ObjectPropertyRange>
<ObjectProperty URI="&f;hasDaughter"/>
<ObjectIntersectionOf>
<OWLClass URI="&f;Person"/>
<ObjectHasValue>
<ObjectProperty URI="&f;hasGender"/>
<Individual URI="&f;female"/>
</ObjectHasValue>
</ObjectIntersectionOf>
</ObjectPropertyRange>
RDF/XML синтаксис:
<owl:ObjectProperty rdf:about="#hasWife">
<rdfs:domain rdf:resource="#Man"/>
<rdfs:range rdf:resource="#Woman"/>
</owl:ObjectProperty>
<owl:ObjectProperty rdf:about="#hasSon">
<rdfs:domain rdf:resource="#Parent"/>
<rdfs:range>
<owl:Class>
<owl:intersectionOf rdf:parseType="Collection">
<rdf:Description rdf:about="#Person"/>
<owl:Restriction>
<owl:onProperty rdf:resource="#hasGender"/>
<owl:hasValue rdf:resource="#male"/>
</owl:Restriction>
</owl:intersectionOf>
</owl:Class>
</rdfs:range>
</owl:ObjectProperty>
<owl:ObjectProperty rdf:about="#hasDaughter">
<rdfs:domain rdf:resource="#Parent"/>
<rdfs:range>
<owl:Class>
<owl:intersectionOf rdf:parseType="Collection">
<rdf:Description rdf:about="#Person"/>
<owl:Restriction>
<owl:onProperty rdf:resource="#hasGender"/>
<owl:hasValue rdf:resource="#female"/>
</owl:Restriction>
</owl:intersectionOf>
</owl:Class>
</rdfs:range>
</owl:ObjectProperty>
Аналогично можно использовать Man и Woman в качестве диапазонов для son и daughter, что предоставит для OWL практически ту же информацию, которую смогут определить блоки рассуждений OWL.
Вам может показаться избыточным определение Parent, как людей, у которых есть хотя бы один child, и одновременно, как домен для child. Однако для OWL в этом нет ничего особенного. Просто два информационных сообщения разными способами описывают одно и то же.
Еще OWL позволяет представить информацию о некоторых группах значений данных, называемых диапазонами данных. Так, к примеру, Teenager может обозначать тех людей, чей возраст является целым числом, большим 13, но не превышающим 20. К Adult отнесем тех людей, у которых значение age равно хотя бы 21, а к Child причислим тех, у кого age является дополнением ко взрослому возрасту.
Манчестерский синтаксис:
Class: Teenager EquivalentClass: Person and hasAge some integer[>= 13 , < 20]
Class: Adult EquivalentClass: Person and hasAge some integer[>= 21]
Class: Child EquivalentClass: Person and not ( hasAge some integer[>= 21] )
Функциональный синтаксис:
EquivalentClasses(f:Teenager
ObjectIntersectionOf(f:Person
DataSomeValuesFrom(f:hasAge
DatatypeRestriction(xsd:integer minInclusive "13"^^xsd:int
maxExclusive "20"^^xsd:int))))
EquivalentClasses(f:Adult
ObjectIntersectionOf(f:Person
DataSomeValuesFrom(f:hasAge
DatatypeRestriction(xsd:integer minInclusive "21"^^xsd:int))))
EquivalentClasses(f:Child
ObjectIntersectionOf(f:Person
ObjectComplementOf(
DataSomeValuesFrom(f:hasAge
DatatypeRestriction(xsd:integer minInclusive "21"^^xsd:int)))))
OWL XML синтаксис:
<EquivalentClasses>
<OWLClass URI="&f;Teenager"/>
<ObjectIntersectionOf>
<DataSomeValuesFrom>
<DataProperty URI="&f;hasAge"/>
<DatatypeRestriction>
<Datatype URI="&xsd;integer"/>
<DatatypeFacetRestriction facet="&owl2;minInclusive">
<Constant datatypeURI="&xsd;integer">13</Constant>
</DatatypeFacetRestriction>
<DatatypeFacetRestriction facet="&owl2;maxExclusive">
<Constant datatypeURI="&xsd;integer">20</Constant>
</DatatypeFacetRestriction>
</DatatypeRestriction>
</DataSomeValuesFrom>
<OWLClass URI="&f;Person"/>
</ObjectIntersectionOf>
</EquivalentClasses>
<EquivalentClasses>
<OWLClass URI="&f;Adult"/>
<ObjectIntersectionOf>
<DataSomeValuesFrom>
<DataProperty URI="&f;hasAge"/>
<DatatypeRestriction>
<Datatype URI="&xsd;integer"/>
<DatatypeFacetRestriction facet="&owl2;minInclusive">
<Constant datatypeURI="&xsd;integer">21</Constant>
</DatatypeFacetRestriction>
</DatatypeRestriction>
</DataSomeValuesFrom>
<OWLClass URI="&f;Person"/>
</ObjectIntersectionOf>
</EquivalentClasses>
<EquivalentClasses>
<OWLClass URI="&f;Child"/>
<ObjectIntersectionOf>
<ObjectComplementOf>
<DataSomeValuesFrom>
<DataProperty URI="&f;hasAge"/>
<DatatypeRestriction>
<Datatype URI="&xsd;integer"/>
<DatatypeFacetRestriction facet="&owl2;minInclusive">
<Constant datatypeURI="&xsd;integer">21</Constant>
</DatatypeFacetRestriction>
</DatatypeRestriction>
</DataSomeValuesFrom>
</ObjectComplementOf>
<OWLClass URI="&f;Person"/>
</ObjectIntersectionOf>
</EquivalentClasses>
RDF/XML синтаксис:
<owl:Class rdf:about="#Teenager">
<owl:equivalentClass>
<owl:Class>
<owl:intersectionOf rdf:parseType="Collection">
<rdf:Description rdf:about="#Person"/>
<owl:Restriction>
<owl:onProperty rdf:resource="#hasAge"/>
<owl:someValuesFrom>
<rdf:Description>
<rdf:type rdf:resource="&owl;DataRange"/>
<owl2:minInclusive rdf:datatype="&xsd;integer">13</owl2:minInclusive>
<owl2:maxExclusive rdf:datatype="&xsd;integer">20</owl2:maxExclusive>
<owl2:onDataRange rdf:resource="&xsd;integer"/>
</rdf:Description>
</owl:someValuesFrom>
</owl:Restriction>
</owl:intersectionOf>
</owl:Class>
</owl:equivalentClass>
</owl:Class>
<owl:Class rdf:about="#Adult">
<owl:equivalentClass>
<owl:Class>
<owl:intersectionOf rdf:parseType="Collection">
<rdf:Description rdf:about="#Person"/>
<owl:Restriction>
<owl:onProperty rdf:resource="#hasAge"/>
<owl:someValuesFrom>
<rdf:Description>
<rdf:type rdf:resource="&owl;DataRange"/>
<owl2:onDataRange rdf:resource="&xsd;integer"/>
<owl2:minInclusive rdf:datatype="&xsd;integer">21</owl2:minInclusive>
</rdf:Description>
</owl:someValuesFrom>
</owl:Restriction>
</owl:intersectionOf>
</owl:Class>
</owl:equivalentClass>
</owl:Class>
<owl:Class rdf:about="#Child">
<owl:equivalentClass>
<owl:Class>
<owl:intersectionOf rdf:parseType="Collection">
<rdf:Description rdf:about="#Person"/>
<owl:Class>
<owl:complementOf>
<owl:Restriction>
<owl:onProperty rdf:resource="#hasAge"/>
<owl:someValuesFrom>
<rdf:Description>
<rdf:type rdf:resource="&owl;DataRange"/>
<owl2:onDataRange rdf:resource="&xsd;integer"/>
<owl2:minInclusive rdf:datatype="&xsd;integer">21</owl2:minInclusive>
</rdf:Description>
</owl:someValuesFrom>
</owl:Restriction>
</owl:complementOf>
</owl:Class>
</owl:intersectionOf>
</owl:Class>
</owl:equivalentClass>
</owl:Class>
Отсюда следует, что Bill относится к Teenager, но не к Adult. Оба John и Mary — Adult, но не Teenage.
Susan не относится ни к Adult, ни к Teenager.
Для обозначения диапазонов данных в OWL применяются встроенные типы данных из XML-схемы [Типы данных XML-схемы], например, xsd:integer.
Еще несколько полезных типов данных — xsd:string и xsd:decimal.
4 Более экспрессивное моделирование
До настоящего времени мы изучали применение OWL с точки зрения языка структурирования данных. Однако на самом деле OWL гораздо более выразителен, нежели просто языки структурирования данных. OWL обладает рядом преимуществ. Некоторые из них обуславливают разницу между OWL и другими формализмами. Вот почему так важно понимание отличий OWL от других технологий.
В предыдущем примере нам была известна лишь незначительная часть информации. Так, например, мы знали возраст (age) (только для) John-а, равный 47 годам. OWL предназначен для работы в условиях неполной информации. Поэтому для OWL считается общепринятым, если, скажем, не известны возраста всех индивидов, принадлежащих к Person, как в примере ниже.
Манчестерский синтаксис:
Individual: f:Jeff
Facts: f:hasWife f:Emily,
f:hasChild f:Ellen,
f:hasChild f:Jack,
f:hasAge 77
Функциональный синтаксис:
ObjectPropertyAssertion(f:hasWife f:Jeff f:Emily)
ObjectPropertyAssertion(f:hasChild f:Jeff f:Ellen)
ObjectPropertyAssertion(f:hasChild f:Jeff f:Jack)
DataPropertyAssertion(f:hasAge f:Jeff "77"^^xsd:integer)
OWL XML синтаксис:
<ObjectPropertyAssertion>
<ObjectProperty URI="&f;hasWife"/>
<Individual URI="&f;Jeff"/>
<Individual URI="&f;Emily"/>
</ObjectPropertyAssertion>
<ObjectPropertyAssertion>
<ObjectProperty URI="&f;hasChild"/>
<Individual URI="&f;Jeff"/>
<Individual URI="&f;Jack"/>
</ObjectPropertyAssertion>
<ObjectPropertyAssertion>
<ObjectProperty URI="&f;hasChild"/>
<Individual URI="&f;Jeff"/>
<Individual URI="&f;Ellen"/>
</ObjectPropertyAssertion>
<DataPropertyAssertion>
<DataProperty URI="&f;hasAge"/>
<Individual URI="&f;Jeff"/>
<Constant datatypeURI="&xsd;integer">77</Constant>
</DataPropertyAssertion>
RDF/XML синтаксис:
<rdf:Description rdf:about="#Jeff">
<hasWife rdf:resource="#Emily"/>
<hasChild rdf:resource="#Ellen"/>
<hasChild rdf:resource="#Jack"/>
<hasAge rdf:datatype="&xsd;integer">77</hasAge>
</rdf:Description>
Из вышеприведенного следует, что Jeff принадлежит к Adult и не к Teenager. Однако, не определена принадлежность ни Emily, ни Jeff к Adult или к Teenager, хотя у них обоих, наверняка, должен быть какой-то возраст.
Можно задать частичную информацию о значениях, скажем, что для Ellen значение age расположено между 15 и 21, в том числе, что возраст Emily составляет либо 39, либо 49 лет, или даже, что у Jack age не равен 53.
Manchester Syntax:
Individual: f:Emily Types: f:hasAge some {39 , 49}
Individual: f:Ellen Types: f:hasAge some integer[ 15, 21 ]
Individual: f:Jack Facts: not f:hasAge "53"^^integer
Functional-Style Syntax:
ClassAssertion(DataSomeValuesFrom(f:hasAge DataOneOf("39"^^xsd:integer
"49"^^xsd:integer))
f:Emily)
ClassAssertion(
DataSomeValuesFrom(f:hasAge
DatatypeRestriction(xsd:integer minInclusive "15"^^xsd:int
maxInclusive "21"^^xsd:int))
f:Ellen)
NegativeDataPropertyAssertion(f:hasAge f:Jack "53"^^xsd:integer)
OWL XML Syntax:
<ClassAssertion>
<DataSomeValuesFrom>
<DataProperty URI="&f;hasAge"/>
<DataOneOf>
<Constant datatypeURI="&xsd;integer">39</Constant>
<Constant datatypeURI="&xsd;integer">49</Constant>
</DataOneOf>
</DataSomeValuesFrom>
<Individual URI="&f;Emily"/>
</ClassAssertion>
<ClassAssertion>
<DataSomeValuesFrom>
<DataProperty URI="&f;hasAge"/>
<DatatypeRestriction>
<Datatype URI="&xsd;integer"/>
<DatatypeFacetRestriction facet="&owl2;minInclusive">
<Constant datatypeURI="&xsd;integer">15</Constant>
</DatatypeFacetRestriction>
<DatatypeFacetRestriction facet="&owl2;maxInclusive">
<Constant datatypeURI="&xsd;integer">21</Constant>
</DatatypeFacetRestriction>
</DatatypeRestriction>
</DataSomeValuesFrom>
<Individual URI="&f;Ellen"/>
</ClassAssertion>
<NegativeDataPropertyAssertion>
<DataProperty URI="&f;hasAge"/>
<Individual URI="&f;Jack"/>
<Constant datatypeURI="&xsd;integer">53</Constant>
</NegativeDataPropertyAssertion>
RDF/XML Syntax:
<rdf:Description rdf:about="#Emily">
<rdf:type>
<owl:Restriction>
<owl:onProperty rdf:resource="#hasAge"/>
<owl:someValuesFrom>
<rdf:Description>
<rdf:type rdf:resource="&owl;DataRange"/>
<owl:oneOf>
<rdf:Description>
<rdf:type rdf:resource="&rdf;List"/>
<rdf:first rdf:datatype="&xsd;integer">39</rdf:first>
<rdf:rest>
<rdf:Description>
<rdf:type rdf:resource="&rdf;List"/>
<rdf:rest rdf:resource="&rdf;nil"/>
<rdf:first rdf:datatype="&xsd;integer">49</rdf:first>
</rdf:Description>
</rdf:rest>
</rdf:Description>
</owl:oneOf>
</rdf:Description>
</owl:someValuesFrom>
</owl:Restriction>
</rdf:type>
</rdf:Description>
<rdf:Description rdf:about="#Ellen">
<rdf:type>
<owl:Restriction>
<owl:onProperty rdf:resource="#hasAge"/>
<owl:someValuesFrom>
<rdf:Description>
<rdf:type rdf:resource="&owl;DataRange"/>
<owl2:minInclusive rdf:datatype="&xsd;integer">15</owl2:minInclusive>
<owl2:onDataRange rdf:resource="&xsd;integer"/>
<owl2:maxInclusive rdf:datatype="&xsd;integer">21</owl2:maxInclusive>
</rdf:Description>
</owl:someValuesFrom>
</owl:Restriction>
</rdf:type>
</rdf:Description>
<owl2:NegativeDataPropertyAssertion>
<rdf:subject rdf:resource="#Jack"/>
<rdf:predicate rdf:resource="#hasAge"/>
<rdf:object rdf:datatype="&xsd;integer">53</rdf:object>
</owl2:NegativeDataPropertyAssertion>
Отсюда следует, что Emily принадлежит к Adult, даже если нам не известен ее точный возраст. Однако мы не можем утверждать принадлежность Ellen к Adult или Teenager. С другой стороны у нас может быть класс YoungChild, который не пересекается ни с Adult, ни с Teenager. Тогда Ellen к этому классу принадлежать не будет.
Manchester Syntax:
Class: f:YoungChild EquivalentTo: f:Person and not ( f:Teenager or f:Adult )
Functional-Style Syntax:
EquivalentClasses(f:YoungChild
ObjectIntersectionOf(f:Person ObjectComplementOf(ObjectUnionOf(f:Teenager f:Adult))))
OWL XML Syntax:
<EquivalentClasses>
<OWLClass URI="&f;YoungChild"/>
<ObjectIntersectionOf>
<ObjectComplementOf>
<ObjectUnionOf>
<OWLClass URI="&f;Teenager"/>
<OWLClass URI="&f;Adult"/>
</ObjectUnionOf>
</ObjectComplementOf>
<OWLClass URI="&f;Person"/>
</ObjectIntersectionOf>
</EquivalentClasses>
RDF/XML Syntax:
<owl:Class rdf:about="#YoungChild">
<owl:equivalentClass>
<owl:Class>
<owl:intersectionOf rdf:parseType="Collection">
<rdf:Description rdf:about="#Person"/>
<owl:Class>
<owl:complementOf>
<owl:Class>
<owl:unionOf rdf:parseType="Collection">
<rdf:Description rdf:about="#Adult"/>
<rdf:Description rdf:about="#Teenager"/>
</owl:unionOf>
</owl:Class>
</owl:complementOf>
</owl:Class>
</owl:intersectionOf>
</owl:Class>
</owl:equivalentClass>
</owl:Class>
Существует множество причин неполноты в OWL. Некоторые из них могут показаться неожиданными для читателей. Например, несмотря на то, что наличие двух детей у Jeff кажется очевидным, это вовсе не так. Также не очевидно, что у Jeff есть по меньшей мере один ребенок (child), который принадлежит к классу Man
Манчестерский синтаксис:
(в незаконченной онтологии)
Individual: f:Jeff Types: f:hasChild exactly 2
Individual: f:Jeff Types: f:hasChild max 1 f:Man
Функциональный синтаксис:
(в незаконченной онтологии)
ClassAssertion(ObjectExactCardinality(2 f:hasChild) f:Jeff)
ClassAssertion(ObjectMaxCardinality(1 f:hasChild f:Man) f:Jeff)
OWL XML синтаксис:
(в незаконченной онтологии)
<ClassAssertion>
<ObjectExactCardinality cardinality="2">
<ObjectProperty URI="&f;hasChild"/>
</ObjectExactCardinality>
<Individual URI="&f;Jeff"/>
</ClassAssertion>
<ClassAssertion>
<ObjectMaxCardinality cardinality="1">
<ObjectProperty URI="&f;hasChild"/>
<???? URI="&f;Man"/>
</ObjectExactCardinality>
<Individual URI="&f;Jeff"/>
</ClassAssertion>
RDF/XML синтаксис:
(в незаконченной онтологии)
<rdf:Description rdf:about="#Jeff">
<rdf:type>
<owl:Restriction>
<owl:onProperty rdf:resource="#hasChild"/>
<owl:cardinality rdf:datatype="&xsd;nonNegativeInteger">2</owl:cardinality>
</owl:Restriction>
</rdf:type>
</rdf:Description>
<rdf:Description rdf:about="#Jeff">
<rdf:type>
<owl:Restriction>
<owl:onProperty rdf:resource="#hasChild"/>
<owl:maxCardinalityQ rdf:datatype="&xsd;nonNegativeInteger">1</owl:cardinality>
<owl2:onClass rdf:resource="#Man" />
</owl:Restriction>
</rdf:type>
<rdf:Description>
Ведь ничего не сказано о том, что Jack и Ellen — единственные дети Jeff-а. В OWL не предпринимается никаких допущений касательно того, что если что-то не сказано, то это неправда. Можно констатировать, что у Jeff-а больше нет детей. Это можно сделать несколькими способами. Первый из них состоит в явном указании, что у Jeff-а ровно 2 ребенка. Конечно, будет адекватным вывод, что у Jeff-а именно 2 ребенка.
Манчестерский синтаксис:
Individual: f:Jeff Types: f:hasChild exactly 2
Функциональный синтаксис:
ClassAssertion(ObjectExactCardinality(2 f:hasChild) f:Jeff)
OWL XML синтаксис:
<ClassAssertion>
<ObjectExactCardinality cardinality="2">
<ObjectProperty URI="&f;hasChild"/>
</ObjectExactCardinality>
<Individual URI="&f;Jeff"/>
</ClassAssertion>
RDF/XML синтаксис:
<rdf:Description rdf:about="#Jeff">
<rdf:type>
<owl:Restriction>
<owl:onProperty rdf:resource="#hasChild"/>
<owl:cardinality rdf:datatype="&xsd;nonNegativeInteger">2</owl:cardinality>
</owl:Restriction>
</rdf:type>
</rdf:Description>
Однако, даже наличие одного child, принадлежащего к классу Man, у Jeff-а не является адекватным выводом. Мы не утверждали, что Jack и Ellen — разные люди, и ничего из сказанного ранее не указывает на то, что они не одно лицо. Опять же, OWL не делает никаких допущений, что разные имена принадлежат разным индивидам. (Это "допущение уникальных имен" особенно опасно в Semantic Web, где имена могут быть даны разными организациями в разное время, бессознательно ссылаясь на один и тот же индивид.) Если Jack и Ellen — одно лицо, тогда у Jeff-а должен быть другой child, принадлежащий к классу Man.
Вы можете утверждать, что Jack и Ellen — разные люди, ведь у них разный пол,
а у человека может быть только один gender. К сожалению, мы не установили, что male и female различны. Мы можем определить, что male и female — это разные вещи, отсюда последует разница между Jack и Ellen. Однако давайте добавлять разумную коллекцию информации о том, какие индивиды считать разными. Обратите внимание: нам вовсе не обязательно это делать для семьи John-а. Наличие разных возрастов предполагает, что все это — разные люди. Аналогично жены и их мужья — разные люди, потому как мы уже задали, что свойство wife является нерефлексивным.
Манчестерский синтаксис:
DifferentIndividuals: f:John f:Mary f:Bill f:Susan
DifferentIndividuals: f:Jeff f:Emily f:Jack f:Ellen f:Susan
Individual: f:male DifferentFrom: f: female
Функциональный синтаксис:
DifferentIndividuals(f:John f:Mary f:Bill f:Susan)
DifferentIndividuals(f:Jeff f:Emily f:Jack f:Ellen f:Susan)
DifferentIndividuals(f:male f:female)
OWL XML синтаксис:
<DifferentIndividuals>
<Individual URI="&f;John"/>
<Individual URI="&f;Mary"/>
<Individual URI="&f;Bill"/>
<Individual URI="&f;Susan"/>
</DifferentIndividuals>
<DifferentIndividuals>
<Individual URI="&f;Jeff"/>
<Individual URI="&f;Emily"/>
<Individual URI="&f;Jack"/>
<Individual URI="&f;Ellen"/>
<Individual URI="&f;Susan"/>
</DifferentIndividuals>
<DifferentIndividuals>
<Individual URI="&f;female"/>
<Individual URI="&f;male"/>
</DifferentIndividuals>
RDF/XML синтаксис:
<rdf:Description>
<rdf:type rdf:resource="&owl;AllDifferent"/>
<owl:distinctMembers rdf:parseType="Collection">
<rdf:Description rdf:about="#John"/>
<rdf:Description rdf:about="#Mary"/>
<rdf:Description rdf:about="#Bill"/>
<rdf:Description rdf:about="#Susan"/>
</owl:distinctMembers>
</rdf:Description>
<rdf:Description>
<rdf:type rdf:resource="&owl;AllDifferent"/>
<owl:distinctMembers rdf:parseType="Collection">
<rdf:Description rdf:about="#Jeff"/>
<rdf:Description rdf:about="#Emily"/>
<rdf:Description rdf:about="#Jack"/>
<rdf:Description rdf:about="#Ellen"/>
<rdf:Description rdf:about="#Susan"/>
</owl:distinctMembers>
</rdf:Description>
<rdf:Description>
<rdf:type rdf:resource="&owl;AllDifferent"/>
<owl:distinctMembers rdf:parseType="Collection">
<rdf:Description rdf:about="#male"/>
<rdf:Description rdf:about="#female"/>
</owl:distinctMembers>
</rdf:Description>
Также можно установить, что два имени ссылаются на (обозначают) один и тот же индивид. Например, можем сказать, что John и Jack — это один индивид.
Манчестерский синтаксис:
Individual: f:John SameAs: f:Jack
Функциональный синтаксис:
SameIndividuals(f:John f:Jack)
OWL XML синтаксис:
<SameIndividuals>
<Individual URI="&f;John"/>
<Individual URI="&f;Jack"/>
</SameIndividuals>
RDF/XML синтаксис:
<rdf:Description rdf:about="#John">
<owl:sameAs rdf:resource="#Jack"/>
</rdf:Description>
Из вышеуказанного следует, что Man и Woman — непересекающиеся множества, то есть не существует индивидов, принадлежащих к обоим множествам. Потому как у каждого Person есть только один gender, а пол индивидов, принадлежащих классу Man, будет мужским (male), в отличие от индивидов женского пола (female), принадлежащих к классу Woman. Однако мы также можем воспользоваться OWL для задания непересекающихся классов. Зачастую, это необходимо для классов, которым недостает законченных условий принадлежности к классу. (Эти классы называют примитивными классами.)
Так, например, для религиозного брака (ReligiousMarriage) и гражданского брака (CivilMarriage) мы должны непосредственно задать их непересекаемость. Здесь мы также установим, что Marriage является объединением их обоих.
Манчестерский синтаксис:
Class: f:CivilMarriage
Class: f:ReligiousMarriage DisjointWith: f:CivilMarriage
Class: f:Marriage EquivalentTo: f:ReligiousMarriage or f:CivilMarriage
Функциональный синтаксис:
DisjointClasses(f:ReligiousMarriage f:CivilMarriage)
EquivalentClasses(f:Marriage ObjectUnionOf(f:CivilMarriage f:ReligiousMarriage))
OWL XML синтаксис:
<DisjointClasses>
<OWLClass URI="&f;CivilMarriage"/>
<OWLClass URI="&f;ReligiousMarriage"/>
</DisjointClasses>
<EquivalentClasses>
<ObjectUnionOf>
<OWLClass URI="&f;CivilMarriage"/>
<OWLClass URI="&f;ReligiousMarriage"/>
</ObjectUnionOf>
<OWLClass URI="&f;Marriage"/>
</EquivalentClasses>
RDF/XML синтаксис:
<owl:Class rdf:about="#CivilMarriage"/>
<owl:Class rdf:about="#ReligiousMarriage">
<owl:disjointWith rdf:resource="#CivilMarriage"/>
</owl:Class>
<owl:Class rdf:about="#Marriage">
<owl:equivalentClass>
<owl:Class>
<owl:unionOf rdf:parseType="Collection">
<rdf:Description rdf:about="#CivilMarriage"/>
<rdf:Description rdf:about="#ReligiousMarriage"/>
</owl:unionOf>
</owl:Class>
</owl:equivalentClass>
</owl:Class>
Исходя из того, что подобная ситуация встречается достаточно часто, когда класс является объединением нескольких непересекающихся классов, для краткости записи в OWL предусмотрен специальный метод.
Манчестерский синтаксис:
(не в законченной онтологии)
Class f:Marriage DisjointUnionOf: f:ReligiousMarriage f:CivilMarriage
Функциональный синтаксис:
(не в законченной онтологии)
ОТСУТСТВУЕТ
OWL XML синтаксис:
(не в законченной онтологии)
ОТСУТСТВУЕТ
RDF/XML синтаксис:
(не в законченной онтологии)
ОТСУТСТВУЕТ
В OWL могут присутствовать транзитивные свойства(transitive properties), то есть свойства (как, например, наличие предка — hasAncestor), которые представляют собой обобщение обратного свойства (в данном случае — наличие ребенка — hasChild), и являются нерефлексивными.
Манчестерский синтаксис:
ObjectProperty: f:hasAncestor Characteristics: Transitive, Irreflexive
ObjectProperty: f:hasChild SubPropertyOf: inverseOf f:hasAncestor
Функциональный синтаксис:
TransitiveObjectProperty(f:hasAncestor)
IrreflexiveObjectProperty(f:hasAncestor)
SubObjectPropertyOf(f:hasChild InverseObjectProperty(f:hasAncestor))
OWL XML синтаксис:
<TransitiveObjectProperty>
<ObjectProperty URI="&f;hasAncestor"/>
</TransitiveObjectProperty>
<IrreflexiveObjectProperty>
<ObjectProperty URI="&f;hasAncestor"/>
</IrreflexiveObjectProperty>
<SubObjectPropertyOf>
<ObjectProperty URI="&f;hasChild"/>
<ObjectProperty URI="&f;hasAncestor"/>
</SubObjectPropertyOf>
RDF/XML синтаксис:
<owl:ObjectProperty rdf:about="#hasAncestor">
<rdf:type rdf:resource="&owl;TransitiveProperty"/>
<rdf:type rdf:resource="&owl2;IrreflexiveProperty"/>
</owl:ObjectProperty>
<owl:ObjectProperty rdf:about="#hasChild">
<rdfs:subPropertyOf rdf:resource="#hasAncestor"/>
</owl:ObjectProperty>
Из вышеприведенной информации мы можем заключить, что Jeff является предком (ancestor) для Bill-а, причем Jeff не его непосредственный предок (ancestor).
Манчестерский синтаксис:
(не в законченной онтологии)
Individual: f:Bill
Facts: f:hasAncestor f:Jeff
not f:hasAncestor f:Bill
Функциональный синтаксис:
(не в законченной онтологии)
ОТСУТСТВУЕТ!
OWL XML синтаксис:
(не в законченной онтологии)
ОТСУТСТВУЕТ!
RDF/XML синтаксис:
(не в законченной онтологии)
ОТСУТСТВУЕТ
Существуют и другие разновидности информации, которую мы вправе добавить о свойствах.
Можем создать свойство spouse, как симметричное (symmetric) и нерефлексивное обобщение свойства wife.
Манчестерский синтаксис:
ObjectProperty: f:hasSpouse Characteristics: Symmetric, Irreflexive
ObjectProperty: f:hasWife SubPropertyOf: f:hasSpouse
Функциональный синтаксис:
SymmetricObjectProperty(fhasSpouse)
IrreflexiveObjectProperty(f:hasSpouse)
SubObjectPropertyOf(f:hasWife f:hasSpouse)
OWL XML синтаксис:
<SymmetricObjectProperty>
<ObjectProperty URI="&f;hasSpouse"/>
</SymmetricObjectProperty>
<IrreflexiveObjectProperty>
<ObjectProperty URI="&f;hasSpouse"/>
</IrreflexiveObjectProperty>
<SubObjectPropertyOf>
<ObjectProperty URI="&f;hasWife"/>
<ObjectProperty URI="&f;hasSpouse"/>
</SubObjectPropertyOf>
RDF/XML синтаксис:
<owl:ObjectProperty rdf:about="#hasSpouse">
<rdf:type rdf:resource="&owl;SymmetricProperty"/>
<rdf:type rdf:resource="&owl2;IrreflexiveProperty"/>
</owl:ObjectProperty>
<owl:ObjectProperty rdf:about="#hasWife">
<rdfs:subPropertyOf rdf:resource="#hasSpouse"/>
</owl:ObjectProperty>
Хотя напрямую мы не устанавливали, мы можем сделать вывод, что spouse также является обобщением для husband.
Ведь spouse — симметричное обобщение обратного свойства к husband.
Можем обогатить наш пример, добавив свойство loves, как обобщение свойства wife. (Таким образом, идеализируя семейные отношения в нашем упрощенном представлении.)
Манчестерский синтаксис:
ObjectProperty: f:loves Domain: f:Person
ObjectProperty: f:hasWife SubPropertyOf: f:loves
Функциональный синтаксис:
ObjectPropertyDomain(f:loves f:Person)
SubObjectPropertyOf(f:hasWife f:loves)
OWL XML синтаксис:
<ObjectPropertyDomain>
<ObjectProperty URI="&f;loves"/>
<OWLClass URI="&f;Person"/>
</ObjectPropertyDomain>
<SubObjectPropertyOf>
<ObjectProperty URI="&f;hasWife"/>
<ObjectProperty URI="&f;loves"/>
</SubObjectPropertyOf>
RDF/XML синтаксис:
<owl:ObjectProperty rdf:about="#loves">
<rdfs:domain rdf:resource="#Person"/>
</owl:ObjectProperty>
<owl:ObjectProperty rdf:about="#hasWife">
<rdfs:subPropertyOf rdf:resource="#loves"/>
</owl:ObjectProperty>
Так как свойство loves несимметрично, мы не можем утверждать, что loves является обобщением для husband.
Мы также не определяли, обладает ли свойство loves рефлексией, поэтому некоторые люди могут любить себя.
У нас появится новый класс Narcissist, обозначающий самовлюбленных людей. Добавим, немного информации об отношении loves
Манчестерский синтаксис:
Class: f:Narcissist EquivalentTo: f:Person that f:loves Self
Individual: f:Jeff Facts: f:loves f:Jeff
Individual: f:Bill Types: not f:Narcissist
Функциональный синтаксис:
EquivalentClasses(f:Narcissist
ObjectIntersectionOf(f:Person ObjectExistsSelf(f:loves)))
ObjectPropertyAssertion(f:loves f:Jeff f:Jeff)
ClassAssertion(ObjectComplementOf(f:Narcissist) f:Bill)
OWL XML синтаксис:
<EquivalentClasses>
<OWLClass URI="&f;Narcissist"/>
<ObjectIntersectionOf>
<OWLClass URI="&f;Person"/>
<ObjectExistsSelf>
<ObjectProperty URI="&f;loves"/>
</ObjectExistsSelf>
</ObjectIntersectionOf>
</EquivalentClasses>
<ObjectPropertyAssertion>
<ObjectProperty URI="&f;loves"/>
<Individual URI="&f;Jeff"/>
<Individual URI="&f;Jeff"/>
</ObjectPropertyAssertion>
<ClassAssertion>
<ObjectComplementOf>
<OWLClass URI="&f;Narcissist"/>
</ObjectComplementOf>
<Individual URI="&f;Bill"/>
</ClassAssertion>
RDF/XML синтаксис:
<owl:Class rdf:about="#Narcissist">
<owl:equivalentClass>
<owl:Class>
<owl:intersectionOf rdf:parseType="Collection">
<rdf:Description>
<rdf:type rdf:resource="&owl2;SelfRestriction"/>
<owl:onProperty rdf:resource="#loves"/>
</rdf:Description>
<rdf:Description rdf:about="#Person"/>
</owl:intersectionOf>
</owl:Class>
</owl:equivalentClass>
</owl:Class>
<rdf:Description rdf:about="#Jeff">
<loves rdf:resource="#Jeff"/>
</rdf:Description>
<rdf:Description rdf:about="#Bill">
<rdf:type>
<owl:Class>
<owl:complementOf rdf:resource="#Narcissist"/>
</owl:Class>
</rdf:type>
</rdf:Description>
Из вышеприведенного фрагмента следует, что Jeff принадлежит к классу Narcissist, а Bill, конечно же, нет.
Еще несколько слов можно сказать об объединении свойств в OWL посредством цепочек объектных свойств. Например, можем утверждать, что сыновья и дочери одинаковы для обоих супругов, то есть son и daughter для индивида будут теми же, что и для его spouse.
Манчестерский синтаксис:
SubObjectProperty: f:hasSpouse o f:hasSon f:hasSon
SubObjectProperty: f:hasSpouse o f:hasDaughter f:hasDaughter
Функциональный синтаксис:
SubObjectPropertyOf(SubObjectPropertyChain(f:hasSpouse f:hasSon) f:hasSon)
SubObjectPropertyOf(SubObjectPropertyChain(f:hasSpouse f:hasDaughter) f:hasDaughter)
OWL XML синтаксис:
<SubObjectPropertyOf>
<SubObjectPropertyChain>
<ObjectProperty URI="&f;hasSpouse"/>
<ObjectProperty URI="&f;hasSon"/>
</SubObjectPropertyChain>
<ObjectProperty URI="&f;hasSon"/>
</SubObjectPropertyOf>
<SubObjectPropertyOf>
<SubObjectPropertyChain>
<ObjectProperty URI="&f;hasSpouse"/>
<ObjectProperty URI="&f;hasDaughter"/>
</SubObjectPropertyChain>
<ObjectProperty URI="&f;hasDaughter"/>
</SubObjectPropertyOf>
RDF/XML синтаксис:
<rdf:Description>
<rdf:type rdf:resource="&rdf;List"/>
<rdf:first rdf:resource="#hasSpouse"/>
<rdf:rest rdf:parseType="Collection">
<rdf:Description rdf:about="#hasSon"/>
</rdf:rest>
<rdfs:subPropertyOf rdf:resource="#hasSon"/>
</rdf:Description>
<rdf:Description>
<rdf:type rdf:resource="&rdf;List"/>
<rdf:first rdf:resource="#hasSpouse"/>
<rdf:rest rdf:parseType="Collection">
<rdf:Description rdf:about="#hasDaughter"/>
</rdf:rest>
<rdfs:subPropertyOf rdf:resource="#hasDaughter"/>
</rdf:Description>
Теперь мы можем заключить, что у Emily те же son и daughter, что и у Jeff-а:
Манчестерский синтаксис:
(не в законченной онтологии)
f:Emily f:hasChild f:Jack
f:Emily f:hasChild f:Ellen
Функциональный синтаксис:
(не в законченной онтологии)
ObjectPropertyAssertion(f:hasChild f:Emily f:Jack)
ObjectPropertyAssertion(f:hasChild f:Emily f:Ellen)
OWL XML синтаксис:
(не в законченной онтологии)
<ObjectPropertyAssertion>
<ObjectProperty URI="&f;hasChild"/>
<Individual URI="&f;Emily"/>
<Individual URI="&f;Jack"/>
</ObjectPropertyAssertion>
<ObjectPropertyAssertion>
<ObjectProperty URI="&f;hasChild"/>
<Individual URI="&f;Emily"/>
<Individual URI="&f;Ellen"/>
</ObjectPropertyAssertion>
RDF/XML синтаксис:
(не в законченной онтологии)
<rdf:Description rdf:about="#Emily">
<hasChild rdf:resource="#Jack"/>
</rdf:Description>
<rdf:Description rdf:about="#Emily">
<hasChild rdf:resource="#Ellen"/>
</rdf:Description>
В OWL можно задавать конфликтную информацию. Скажем, мы запишем, что у John-а нет child, принадлежащего к классу Woman. Это утверждение конфликтует с тем, что у John-а есть daughter Susan. Онтология с конфликтной информацией порождает множество негативных последствий. Многие инструменты OWL выявят противоречивые онтологии и предложат некоторый механизм исправления.
Манчестерский синтаксис:
(не в законченной онтологии)
Individual: f:John f:hasChild max 0 f:Woman
Функциональный синтаксис:
(не в законченной онтологии)
ClassAssertion(ObjectMaxCardinality(0 f:hasChild f:Woman) f:John)
OWL XML синтаксис:
(не в законченной онтологии)
<ClassAssertion>
<ObjectMaxCardinality cardinality="0">
<ObjectProperty URI="&f;hasChild"/>
<OWLClass URI="&f;Woman"/>
</ObjectMaxCardinality>
<Individual URI="&f;John"/>
</ClassAssertion>
RDF/XML синтаксис:
(не в законченной онтологии)
<rdf:Description rdf:about="#John">
<rdf:type>
<owl:Restriction>
<owl:onProperty rdf:resource="#hasChild"/>
<owl2:onClass rdf:resource="#Person"/>
<owl:maxCardinalityQ rdf:datatype="&xsd;nonNegativeInteger">0</owl:maxCardinalityQ>
</owl:Restriction>
</rdf:type>
</rdf:Description>
При наличии конфликтной информации нарушаются выводы OWL, потому ничего хорошего такая информация не несет. Инструментальные средства OWL вовсе не обязаны отвергать конфликтную информацию, однако большинство из них хотя бы обеспечивает пользователя механизмами ее выявления и позволяют разрешить конфликт.
5 Управление онтологиями
Информация, которой мы оперировали до настоящего момента, подпадает под две категории. Первая — это общая информация о классах и свойствах, касающихся семейных отношений, а вторая — это частная информация по двум взаимосвязанным семьям. Зачастую, общая информация в OWL объединяется в онтологию (ontology), которая впоследствии используется различными приложениями. Мы также можем задавать имена для OWL-онтологий, которые в основном совпадают с местоположением документа онтологии в глобальной сети. Частная информация также может быть помещена в онтологию, если эта информация используется разными приложениями.
Манчестерский синтаксис:
Ontology: <http://example.com/owl/families>
Функциональный синтаксис:
Ontology(<http://example.com/owl/families>
...
)
OWL XML синтаксис:
<Ontology ...
URI="http://example.com/owl/families">
...
</Ontology>
RDF/XML синтаксис:
<rdf:RDF ...>
<owl:Ontology rdf:about="http://example.com/owl/families"/>
...
</rdf:RDF>
OWL-онтологии размещают внутрь OWL-документов, которые затем располагают в локальной файловой системе или выкладывают в сеть. Кроме OWL-онтологий, документы OWL содержат информацию о преобразовании коротких имен, используемых в OWL-онтологиях (например, f:Person), в идентификаторы IRI, предоставляя пространство для префиксов. Поэтому IRI — это объединение пространства для префиксов и ссылки.
В нашем примере онтологии было задействовано два префикса: f и xsd. Последний из них применялся в компактных именах для типов данных XML-схемы. Эти IRI регламентированы в рекомендации по XML-схеме. Вот почему мы используем стандартное пространство для xsd (см. http://www.w3.org/2001/XMLSchema# ). Пространство, выбранное нами для других префиксов повлияет на имена классов, свойств и индивидов в нашей онтологии, как и на имя самой онтологии. Если мы собираемся разместить онтологию в сети, то для этих целей следует выбрать подконтрольное нам сетевое пространство, чтобы нечаянно не задействовать чужие имена. (Здесь мы воспользовались выдуманным именем, которое никто не контролирует.) Двум синтаксисам на основе XML нужны пространства имен для встроенных имен. Эти синтаксисы также используют XML-сущности для пространств имен.
Манчестерский синтаксис:
Namespace: f = <http://example.com/owl/families#>
Namespace: g = <http://example.com/owl2/families#>
Namespace: dc = <http:...#>
Функциональный синтаксис:
Namespace(f=<http://example.com/owl/families#>)
Namespace(g=<http://example.com/owl2/families#>)
Namespace(xsd=<http://www.w3.org/2001/XMLSchema#>)
Namespace(dc=<...#>)
OWL XML синтаксис:
<!DOCTYPE Ontology [
<!ENTITY owl "http://www.w3.org/2002/07/owl#" >
<!ENTITY owl2 "http://www.w3.org/2006/12/owl2#" >
<!ENTITY xsd "http://www.w3.org/2001/XMLSchema#" >
<!ENTITY f "http://example.com/owl/families#" >
<!ENTITY g "http://example.com/owl2/families#" >
<!ENTITY dc "http://http://purl.org/dc/elements/1.1/#" >
]>
<Ontology xml:base="http://www.w3.org/2006/12/owl2-xml#"
xmlns="http://www.w3.org/2006/12/owl2-xml#"
xmlns:owl="http://www.w3.org/2002/07/owl#"
xmlns:owl2="http://www.w3.org/2006/12/owl2#"
xmlns:xsd="http://www.w3.org/2001/XMLSchema#"
xmlns:f="http://example.com/owl/families#"
xmlns:g="http://example.com/owl2/families#"
xmlns:dc="http:....#"
URI="http://example.com/owl/families">
...
</Ontology>
RDF/XML синтаксис:
<!DOCTYPE rdf:RDF [
<!ENTITY owl "http://www.w3.org/2002/07/owl#" >
<!ENTITY owl2 "http://www.w3.org/2006/12/owl2#" >
<!ENTITY rdf "http://www.w3.org/1999/02/22-rdf-syntax-ns#" >
<!ENTITY rdfs "http://www.w3.org/2000/01/rdf-schema#" >
<!ENTITY xsd "http://www.w3.org/2001/XMLSchema#" >
<!ENTITY f "http://example.com/owl/families#" >
<!ENTITY g "http://example.com/owl2/families#" >
]>
<rdf:RDF xml:base="http://example.com/owl/families"
xmlns="http://example.com/owl/families#"
xmlns:owl="http://www.w3.org/2002/07/owl#"
xmlns:owl2="http://www.w3.org/2006/12/owl2#"
xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:xsd="http://www.w3.org/2001/XMLSchema#"
xmlns:f="http://example.com/owl/families#"
xmlns:g="http://example.com/owl2/families#"
xmlns:dc="http:????#">
<owl:Ontology rdf:about="http://example.com/owl/families"/>
...
В OWL также принято повторно использовать общую информацию в других онтологиях. Вместо требования копировать эту информацию, OWL позволяет импортировать содержимое целых онтологий в другие онтологии посредством объявлений импорта, как в примере ниже:
Манчестерский синтаксис:
Import: http://example.com/owl2/families
Функциональный синтаксис:
Import(http://example.com/owl2/families)
OWL XML синтаксис:
<Import URI="http://example.com/owl2/families.owl" />
RDF/XML синтаксис:
<owl:Ontology rdf:about="http://example.com/owl/families">
<owl:imports rdf:resource="http://example.com/owl2/families.owl" />
</owl:Ontology>
Так как Semantic Web и конструкции онтологий являются распределенными, для онтологий считается общепринятым использование разных имен для одинаковых концепций, свойств или индивидов. Некоторые конструкции OWL могут применяться для определения того, что разные имена ссылаются на один и тот же класс, свойство или индивид. Так, например, можно выполнить привязку имен, задействованных в нашей онтологии, к именам импортированной онтологии, как в примере ниже:
Манчестерский синтаксис:
SameIndividual: f:male g:masculine
SameIndividual: f:female g:feminine
EquivalentClasses: f:Adult g:Grownup
EquivalentObjectProperties: f:hasChild g:child
EquivalentDataProperties: f:hasAge g:age
Функциональный синтаксис:
SameIndividuals(f:male g:masculine)
SameIndividuals(f:female g:feminine)
EquivalentClasses(f:Adult g:Grownup)
EquivalentObjectProperties(f:hasChild g:child)
EquivalentDataProperties(f:hasAge g:age)
OWL XML синтаксис:
<SameIndividuals>
<Individual URI="&f;male"/>
<Individual URI="&g;masculine"/>
</SameIndividuals>
<SameIndividuals>
<Individual URI="&f;female"/>
<Individual URI="&g;feminine"/>
</SameIndividuals>
<EquivalentClasses>
<OWLClass URI="&f;Adult"/>
<OWLClass URI="&g;Grownup"/>
</EquivalentClasses>
<EquivalentObjectProperties>
<ObjectProperty URI="&f;hasChild"/>
<ObjectProperty URI="&g;child"/>
</EquivalentObjectProperties>
<EquivalentDataProperties>
<DataProperty URI="&f;hasAge"/>
<DataProperty URI="&g;age"/>
</EquivalentDataProperties>
RDF/XML синтаксис:
<rdf:Description rdf:about="#male">
<owl:sameAs rdf:resource="&g;masculine"/>
</rdf:Description>
<rdf:Description rdf:about="#female">
<owl:sameAs rdf:resource="&g;feminine"/>
</rdf:Description>
<owl:Class rdf:about="#Adult">
<owl:equivalentClass rdf:resource="&g;Grownup"/>
</owl:Class>
<owl:DatatypeProperty rdf:about="#hasAge">
<owl:equivalentProperty rdf:resource="&g;age"/>
</owl:DatatypeProperty>
<owl:Class rdf:about="#Adult">
<owl:equivalentClass rdf:resource="&g;Grownup"/>
</owl:Class>
Во многих ситуациях мы хотим выполнить привязку информации к отдельным частям нашей OWL-онтологии. Для этих целей в OWL предназначены аннотации (annotations). OWL-аннотация попросту связывает пары свойство-значение с частями либо с целой онтологией. На самом деле эта информация не является частью логического содержания онтологии.
Добавим, к примеру, информацию об авторе к одному из фактов нашей онтологии и к одному из классов.
Манчестерский синтаксис:
Individual f:John
Facts: Annotations: dc:author Individual(f:peter)
dc:creationDate "2008-01-10"^^xsd:date
rdfs:comment "A simple fact about John"
f:hasWife f:Mary
Class: f:Person
Annotations: dc:author Individual(f:peter)
dc:creationDate "2008-01-10"^^xsd:date
rdfs:label "Person":en
rdfs:label "Persona":it
rdfs:comment "The class of people"
Функциональный синтаксис:
ОТСУТСТВУЕТ.
OWL XML синтаксис:
ОТСУТСТВУЕТ.
RDF/XML синтаксис:
ОТСУТСТВУЕТ.
Для поддержки управления онтологиями в OWL есть понятие деклараций. Основная идея состоит в том, что каждый класс, свойство или индивид должны быть задекларированы в онтологии, после чего они могут использоваться в данной онтологии или других, в которые импортирована эта.
В манчестерском синтаксисе декларации являются неявными. Конструкции, представляющие информацию о классе, свойстве или индивиде неявно декларируют эти элементы при необходимости. Другие разновидности синтаксиса предполагают явные декларации.
Функциональный синтаксис:
Declaration(Individual(f:John))
Declaration(OWLClass(f:Person))
Declaration(ObjectProperty(f:hasWife))
Declaration(DataProperty(f:hasAge))
OWL XML синтаксис:
<Declaration>
<Individual URI="&f;John"/>
</Declaration>
<Declaration>
<OWLClass URI="&f;Person"/>
</Declaration>
<Declaration>
<ObjectProperty URI="&f;hasWife"/>
</Declaration>
<Declaration>
<DataProperty URI="&f;hasAge"/>
</Declaration>
6 Остальные конструкции
В OWL есть еще несколько интересных элементов, которые, однако, не вошли в данный пример, к ним относят:
- Некоторые специальные ограничения (facet) типов данных из XML-схемы, включая length, minLength, maxLength,
totalDigits, и fractionDigits.
-
Конструкции свойств данных: in, all, min, max и value.
- Объектные свойства и некоторые конструкции.
-
Свойства данных, как подсвойства или разбиение других свойств данных
-
2- или N-направленное разбиение, эквивалентность и разность.
Более подробная информация по этим конструкциям находится в документе Структурная спецификация и функциональный синтаксис OWL 2
[Спецификация ОWL 2].
7 Использование OWL
Примечание редактора: Здесь будет работающий пример. Я раздумываю над ракурсом представления информации, как исходных понятий, так и лежащих в основе формализмов. Или, возможно, пример онтологии Galen.
8 OWL-инструментарий
Примечание редактора: Различные инструментальные средства OWL. Вероятно, описание использования инструментальных средств XML или RDF. Сервисы рассуждений. Что-нибудь еще
9 OWL-профили
Мы убедились, что рассуждения в OWL могут быть достаточно сложными. Полное описания блока рассуждений OWL выходит за рамки данного руководства, однако о некоторых процедурах вывода все-таки стоит упомянуть.
Если мы не наложим ограничения на информацию, описываемую посредством OWL (например, классы, свойства и даже части синтаксиса могут использоваться, как индивиды Semantic Web на языке RDF), рассуждения становятся формально неразрешимыми. Тем не менее, существует специальная субформа OWL, призванная справляться с этими трудностями, она называется OWL Full. Хотя, конечно, инструменты рассуждений под OWL Full весьма сложны в написании и неизбежно неполны.
Однако существует и набор разумных ограничений, делающих рассуждения OWL разрешимыми. Более того, под эту субформу OWL созданы эффективные инструментальные средства, а называется она — OWL DL.
Для того, чтобы открыть возможность создания эффективных инструментов рассуждений, OWL DL ограничивает свободу определенных свойств. Свойства называются составными(composite), если они или их обратные свойства являются транзитивными либо имеют цепочку свойств в виде подсвойств. Составные свойства или свойства, имеющие составное свойство в качестве специализации основного свойства или обратного ему свойства, не могут быть функциональными, обратно функциональными, нерефлексивными, асимметричными или непересекающимися с любыми другими свойствами. Эти свойства также не могут применяться в описании кардинальности и собственных условий. Также существуют сложные условия, накладываемые на конструирование цепочек объектных свойств, для предотвращения циклов, связанных с цепочками объектных свойств. Инструментарий OWL DL распознает нарушение всех этих условий в описании онтологии.
OWL DL позволяет называть одним и тем же именем несколько или все классы, свойства и индивиды. Однако, различные аспекты каждого имени не привязываются друг к другу, поэтому, если мы нечаянно зададим, например,
что Person и Man являются одинаковым индивидом, они не будут эквивалентными классами.
Манчестерский синтаксис:
SameIndividual: f:Person f:Man
Функциональный синтаксис:
SameIndividuals(f:Person f:Man)
Из вышеприведенной строки не последует данный вывод:
Манчестерский синтаксис:
EquivalentClasses: f:Person f:Man
Функциональный синтаксис:
EquivalentClasses(f:Person f:Man)
С этой стороны (и в некоторых других случаях) OWL Full формально более мощный, чем OWL DL, поэтому в OWL Full последует вышеуказанный вывод.
Рассуждения OWL DL по-прежнему сложны и в худшем случае могут занять очень много времени.Отдельные профили OWL DL гарантируют улучшенную производительность рассуждений. Документ по OWL-профилям [Профили ОWL 2] определяет и характеризует приведенные здесь профили, которые могут быть с пользой применены на практике. Выбор каждого из профилей накладывает определенные ограничения на представляемую информацию, однако эти ограничения зачастую весьма полезны при написании больших онтологий, в особенности для важных приложений.
10 Дальнейшее изучение OWL
Это небольшое руководство лишь поверхностно раскрывает суть OWL. Существует множество более объемных и содержательных руководств по OWL, использованию OWL-инструментария, выложенного в сети. Чтения одного из этих руководств и апробация инструментального средства разработки OWL-онтологии, пожалуй, самый лучший способ изучения OWL.
Данное краткое руководство не является нормативным определением OWL. Нормативный документ по OWL-синтаксису, содержащий также информативные определения каждой
конструкции OWL, — это Структурная спецификация и функциональный синтаксис OWL 2 [Спецификация ОWL 2].
Тот, кто интересуется дополнительными формальными документами,
а также формальным определением OWL 2, может ознакомиться с документом Семантика OWL 2 [Семантика ОWL 2].
Информация по преобразованию между OWL-синтаксисом и RDF-триплетами содержится в документе Преобразование OWL 2 в RDF-графы [Преобразование ОWL 2 в RDF].
11 Приложение: возможности OWL
Ниже приведен перечень различных возможностей OWL. Каждая запись в данном перечне связана по ссылке с соответствующими терминами в тексте.
12 Приложение: законченный пример
Здесь мы добавили законченный пример OWL-онтологии. Онтология упорядочена в обычном порядке: сначала представлена информация по онтологии, затем — информация о свойствах, далее — о классах и, наконец, об индивидах. Для пояснения онтологии добавлены дополнительные аннотации (ПОКА ЕЩЕ нет).
Манчестерский синтаксис:
Namespace: = <http://example.com/owl/families#>
Namespace: f = <http://example.com/owl/families#>
Namespace: g = <http://example.com/owl2/families.owl#>
Namespace: dc = <http://purl.org/dc/elements/1.1/>
Ontology: <http://example.com/owl/families>
Import: <http://example.com/owl2/families.owl>
ObjectProperty: hasWife
Characteristics: Functional, InverseFunctional, Irreflexive, Asymmetric
Domain: Person, Man
Range: Person, Woman
SubPropertyOf: hasSpouse, loves
ObjectProperty: hasHusband Inverses: hasWife
ObjectProperty: hasSon
Domain: Person, Parent
Range: Person, Person that hasGender value male
SubPropertyOf: hasChild
DisjointObjectProperties: hasSon hasDaughter
SubObjectProperty: f:hasSpouse o f:hasSon f:hasSon
ObjectProperty: hasDaughter
Domain: Person, Parent
Range: Person, Person that hasGender value female
SubPropertyOf: hasChild
SubObjectProperty: f:hasSpouse o f:hasDaughter f:hasDaughter
ObjectProperty: hasGender
ObjectProperty: hasChild
Domain: Person Range: Person
SubPropertyOf: inverseOf hasAncestor
ObjectProperty: hasAncestor Characteristics: Transitive, Irreflexive
ObjectProperty: hasSpouse Characteristics: Symmetric, Irreflexive
ObjectProperty: loves Domain: Person
DataProperty: hasAge Characteristics: Functional
Domain: Person Range: integer
Class: Person
SubClassOf: hasAge exactly 1
and hasGender exactly 1
and hasGender only {female , male}
Class: Man SubClassOf: Person
EquivalentTo: Person that hasGender value male
Class: Woman SubClassOf: Person
EquivalentTo: Person that hasGender value female
Class: Parent SubClassOf: Person
EquivalentTo: Person that hasChild min 1
Class: Teenager
EquivalentTo: Person that hasAge some integer[>= 13 , < 20]
Class: Adult
EquivalentTo: Person that hasAge some integer[>= 21]
Class: Child
EquivalentTo: Person and not (hasAge some integer[>= 21])
Class: YoungChild
EquivalentTo: Person and not (Teenager or Adult)
Class: Marriage
EquivalentTo: CivilMarriage or ReligiousMarriage
Class: ReligiousMarriage DisjointWith: CivilMarriage
Class: CivilMarriage
Class: Narcissist EquivalentTo: Person that loves Self
Individual: male DifferentFrom: female
Individual: female
Individual: John
Types: Person
Facts: hasWife Mary,
hasSon Bill,
hasDaughter Susan,
hasAge 33,
hasGender male
SameAs: Jack
Individual: Mary
Facts: hasSon Bill,
hasDaughter Susan,
hasAge 31,
hasGender female
Individual: Bill
Types: not (Narcissist)
Facts: hasAge 13,
hasGender male
Individual: Susan
Facts: hasAge 8,
hasGender female
Individual: Jeff
Types: hasChild exactly 2
Facts: hasWife Emily,
hasChild Ellen,
hasChild Jack,
hasAge 77,
loves Jeff
Individual: Emily
Types: hasAge some {39 , 49}
Individual: Ellen
Types: hasAge some integer[>= 15 , <= 21]
Individual: Jack
Facts: not hasAge "53"^^integer
DifferentIndividuals: f:John f:Mary f:Bill f:Susan
DifferentIndividuals: f:Jeff f:Emily f:Jack f:Ellen f:Susan
SameIndividual: f:male g:masculine
SameIndividual: f:female g:feminine
EquivalentClasses: f:Adult g:Grownup
EquivalentObjectProperties: f:hasChild g:child
EquivalentDataProperties: f:hasAge g:age
Функциональный синтаксис:
Namespace(=<http://example.com/owl/families#>)
Namespace(f=<http://example.com/owl/families#>)
Namespace(g=<http://example.com/owl2/families#>)
Namespace(dc=<http://purl.org/dc/elements/1.1/#>)
Namespace(xsd=<http://www.w3.org/2001/XMLSchema#>)
Ontology(<http://example.com/owl/families>
Import(<http://example.com/owl2/families.owl>)
// Object property: http://example.com/owl/families#hasWife
Declaration(ObjectProperty(hasWife))
ObjectPropertyDomain(hasWife Person)
ObjectPropertyDomain(hasWife Man)
ObjectPropertyRange(hasWife Person)
ObjectPropertyRange(hasWife Woman)
FunctionalObjectProperty(hasWife)
InverseFunctionalObjectProperty(hasWife)
IrreflexiveObjectProperty(hasWife)
AsymmetricObjectProperty(hasWife)
SubObjectPropertyOf(hasWife hasSpouse)
SubObjectPropertyOf(hasWife loves)
// Object property: http://example.com/owl/families#hasHusband
Declaration(ObjectProperty(hasHusband))
InverseObjectProperties(hasHusband hasWife)
// Object property: http://example.com/owl/families#hasSon
Declaration(ObjectProperty(hasSon))
ObjectPropertyDomain(hasSon Person)
ObjectPropertyDomain(hasSon Parent)
ObjectPropertyRange(hasSon Person)
ObjectPropertyRange(hasSon
ObjectIntersectionOf(Person ObjectHasValue(hasGender male)))
SubObjectPropertyOf(hasSon hasChild)
DisjointObjectProperties(hasSon hasDaughter)
SubObjectPropertyOf(SubObjectPropertyChain(hasSpouse hasSon) hasSon)
// Object property: http://example.com/owl/families#hasDaughter
Declaration(ObjectProperty(hasDaughter))
ObjectPropertyDomain(hasDaughter Person)
ObjectPropertyDomain(hasDaughter Parent)
ObjectPropertyRange(hasDaughter Person)
ObjectPropertyRange(hasDaughter
ObjectIntersectionOf(Person ObjectHasValue(hasGender female)))
SubObjectPropertyOf(hasDaughter hasChild)
SubObjectPropertyOf(SubObjectPropertyChain(hasSpouse hasDaughter) hasDaughter)
// Object property: http://example.com/owl/families#hasGender
Declaration(ObjectProperty(hasGender))
// Object property: http://example.com/owl/families#hasChild
Declaration(ObjectProperty(hasChild))
ObjectPropertyDomain(hasChild Person)
ObjectPropertyRange(hasChild Person)
SubObjectPropertyOf(hasChild InverseObjectProperty(hasAncestor))
// Object property: http://example.com/owl/families#hasAncestor
Declaration(ObjectProperty(hasAncestor))
TransitiveObjectProperty(hasAncestor)
IrreflexiveObjectProperty(hasAncestor)
// Object property: http://example.com/owl/families#hasSpouse
Declaration(ObjectProperty(hasSpouse))
SymmetricObjectProperty(hasSpouse)
IrreflexiveObjectProperty(hasSpouse)
// Object property: http://example.com/owl/families#loves
ObjectPropertyDomain(loves Person)
Declaration(ObjectProperty(loves))
// Data property: http://example.com/owl/families#hasAge
Declaration(DataProperty(hasAge))
DataPropertyDomain(hasAge Person)
DataPropertyRange(hasAge xsd:integer)
FunctionalDataProperty(hasAge)
// Class: http://example.com/owl/families#Person
Declaration(OWLClass(Person))
SubClassOf(Person
ObjectIntersectionOf(DataExactCardinality(1 hasAge)
ObjectExactCardinality(1 hasGender)
ObjectAllValuesFrom(hasGender ObjectOneOf(female male))))
// Class: http://example.com/owl/families#Man
Declaration(OWLClass(Man))
SubClassOf(Man Person)
EquivalentClasses(Man
ObjectIntersectionOf(Person ObjectHasValue(hasGender male)))
// Class: http://example.com/owl/families#Woman
Declaration(OWLClass(Woman))
SubClassOf(Woman Person)
EquivalentClasses(Woman
ObjectIntersectionOf(Person ObjectHasValue(hasGender female)))
// Class: http://example.com/owl/families#Parent
Declaration(OWLClass(Parent))
SubClassOf(Parent Person)
EquivalentClasses(Parent
ObjectIntersectionOf(Person ObjectMinCardinality(1 hasChild Person)))
// Class: http://example.com/owl/families#Teenager
Declaration(OWLClass(Teenager))
EquivalentClasses(Teenager
ObjectIntersectionOf(Person
DataSomeValuesFrom(hasAge
DatatypeRestriction(xsd:integer minInclusive "13"^^xsd:int
maxExclusive "20"^^xsd:int))))
// Class: http://example.com/owl/families#Adult
Declaration(OWLClass(Adult))
EquivalentClasses(Adult
ObjectIntersectionOf(Person
DataSomeValuesFrom(hasAge
DatatypeRestriction(xsd:integer minInclusive "21"^^xsd:int))))
// Class: http://example.com/owl/families#Child
Declaration(OWLClass(Child))
EquivalentClasses(Child
ObjectIntersectionOf(Person
ObjectComplementOf(
DataSomeValuesFrom(hasAge
DatatypeRestriction(xsd:integer minInclusive "21"^^xsd:int)))))
// Class: http://example.com/owl/families#YoungChild
Declaration(OWLClass(YoungChild))
EquivalentClasses(YoungChild
ObjectIntersectionOf(Person ObjectComplementOf(ObjectUnionOf(Teenager Adult))))
// Class: http://example.com/owl/families#Marriage
Declaration(OWLClass(Marriage))
EquivalentClasses(Marriage ObjectUnionOf(CivilMarriage ReligiousMarriage))
// Class: http://example.com/owl/families#ReligiousMarriage
Declaration(OWLClass(ReligiousMarriage))
DisjointClasses(CivilMarriage ReligiousMarriage)
// Class: http://example.com/owl/families#CivilMarriage
Declaration(OWLClass(CivilMarriage))
// Class: http://example.com/owl/families#Narcissist
Declaration(OWLClass(Narcissist))
EquivalentClasses(Narcissist ObjectIntersectionOf(Person ObjectExistsSelf(loves)))
// Individual: http://example.com/owl/families#male
Declaration(Individual(male))
DifferentIndividuals(male female)
// Individual: http://example.com/owl/families#female
Declaration(Individual(female))
// Individual: http://example.com/owl/families#John
Declaration(Individual(John))
ClassAssertion(Person John)
ObjectPropertyAssertion(hasWife John Mary)
ObjectPropertyAssertion(hasSon John Bill)
ObjectPropertyAssertion(hasDaughter John Susan)
DataPropertyAssertion(hasAge John "33"^^xsd:integer)
ObjectPropertyAssertion(hasGender John male)
SameIndividuals(John Jack)
DifferentIndividuals(John Mary Bill Susan)
// Individual: http://example.com/owl/families#Mary
Declaration(Individual(Mary))
ObjectPropertyAssertion(hasSon Mary Bill)
ObjectPropertyAssertion(hasDaughter Mary Susan)
DataPropertyAssertion(hasAge Mary "31"^^xsd:integer)
ObjectPropertyAssertion(hasGender Mary female)
// Individual: http://example.com/owl/families#Bill
Declaration(Individual(Bill))
ClassAssertion(ObjectComplementOf(Narcissist) Bill)
DataPropertyAssertion(hasAge Bill "13"^^xsd:integer)
ObjectPropertyAssertion(hasGender Bill male)
// Individual: http://example.com/owl/families#Susan
Declaration(Individual(Susan))
DataPropertyAssertion(hasAge Susan "8"^^xsd:integer)
ObjectPropertyAssertion(hasGender Susan female)
// Individual: http://example.com/owl/families#Jeff
Declaration(Individual(Jeff))
ClassAssertion(ObjectExactCardinality(2 hasChild) Jeff)
ObjectPropertyAssertion(hasWife Jeff Emily)
ObjectPropertyAssertion(hasChild Jeff Ellen)
ObjectPropertyAssertion(hasChild Jeff Jack)
DataPropertyAssertion(hasAge Jeff "77"^^xsd:integer)
ObjectPropertyAssertion(loves Jeff Jeff)
DifferentIndividuals(Jeff Emily Jack Ellen Susan)
// Individual: http://example.com/owl/families#Emily
Declaration(Individual(Emily))
ClassAssertion(DataSomeValuesFrom(hasAge DataOneOf("39"^^xsd:integer
"49"^^xsd:integer)) Emily)
// Individual: http://example.com/owl/families#Ellen
Declaration(Individual(Ellen))
ClassAssertion(
DataSomeValuesFrom(hasAge
DatatypeRestriction(xsd:integer minInclusive "15"^^xsd:int
maxInclusive "21"^^xsd:int)) Ellen)
// Individual: http://example.com/owl/families#Jack
Declaration(Individual(Jack))
NegativeDataPropertyAssertion(hasAge Jack "53"^^xsd:integer)
SameIndividuals(male g:masculine)
SameIndividuals(female g:feminine)
EquivalentClasses(Adult g:Grownup)
EquivalentObjectProperties(hasChild g:child)
EquivalentDataProperties(hasAge g:age)
)
OWL XML синтаксис:
<?xml version="1.0"?>
<!DOCTYPE Ontology [
<!ENTITY owl "http://www.w3.org/2002/07/owl#" >
<!ENTITY owl11 "http://www.w3.org/2006/12/owl11#" >
<!ENTITY xsd "http://www.w3.org/2001/XMLSchema#" >
<!ENTITY f "http://example.com/owl/families#" >
<!ENTITY g "http://example.com/owl2/families#" >
<!ENTITY dc "http://purl.org/dc/elements/1.1/#" >
]>
------
<Ontology xml:base="http://www.w3.org/2006/12/owl11-xml#"
xmlns="http://www.w3.org/2006/12/owl11-xml#"
xmlns:owl="http://www.w3.org/2002/07/owl#"
xmlns:owl11="http://www.w3.org/2006/12/owl11#"
xmlns:xsd="http://www.w3.org/2001/XMLSchema#"
xmlns:f="http://example.com/owl/families#"
xmlns:g="http://example.com/owl2/families#"
xmlns:dc="http://purl.org/dc/elements/1.1/#"
URI="http://example.com/owl/families">
<Import URI="http://example.com/owl2/families.owl" />
<Declaration>
<ObjectProperty URI="&f;hasAncestor"/>
</Declaration>
<IrreflexiveObjectProperty>
<ObjectProperty URI="&f;hasAncestor"/>
</IrreflexiveObjectProperty>
<TransitiveObjectProperty>
<ObjectProperty URI="&f;hasAncestor"/>
</TransitiveObjectProperty>
<Declaration>
<ObjectProperty URI="&f;hasChild"/>
</Declaration>
<ObjectPropertyDomain>
<ObjectProperty URI="&f;hasChild"/>
<OWLClass URI="&f;Person"/>
</ObjectPropertyDomain>
<ObjectPropertyRange>
<ObjectProperty URI="&f;hasChild"/>
<OWLClass URI="&f;Person"/>
</ObjectPropertyRange>
<SubObjectPropertyOf>
<ObjectProperty URI="&f;hasChild"/>
<ObjectProperty URI="&f;hasAncestor"/>
</SubObjectPropertyOf>
<EquivalentObjectProperties>
<ObjectProperty URI="&f;hasChild"/>
<ObjectProperty URI="&g;child"/>
</EquivalentObjectProperties>
<Declaration>
<ObjectProperty URI="&f;hasDaughter"/>
</Declaration>
<ObjectPropertyDomain>
<ObjectProperty URI="&f;hasDaughter"/>
<OWLClass URI="&f;Person"/>
</ObjectPropertyDomain>
<ObjectPropertyDomain>
<ObjectProperty URI="&f;hasDaughter"/>
<OWLClass URI="&f;Parent"/>
</ObjectPropertyDomain>
<ObjectPropertyRange>
<ObjectProperty URI="&f;hasDaughter"/>
<OWLClass URI="&f;Person"/>
</ObjectPropertyRange>
<ObjectPropertyRange>
<ObjectProperty URI="&f;hasDaughter"/>
<ObjectIntersectionOf>
<OWLClass URI="&f;Person"/>
<ObjectHasValue>
<ObjectProperty URI="&f;hasGender"/>
<Individual URI="&f;female"/>
</ObjectHasValue>
</ObjectIntersectionOf>
</ObjectPropertyRange>
<SubObjectPropertyOf>
<ObjectProperty URI="&f;hasDaughter"/>
<ObjectProperty URI="&f;hasChild"/>
</SubObjectPropertyOf>
<SubObjectPropertyOf>
<SubObjectPropertyChain>
<ObjectProperty URI="&f;hasSpouse"/>
<ObjectProperty URI="&f;hasDaughter"/>
</SubObjectPropertyChain>
<ObjectProperty URI="&f;hasDaughter"/>
</SubObjectPropertyOf>
<Declaration>
<ObjectProperty URI="&f;hasGender"/>
</Declaration>
<Declaration>
<ObjectProperty URI="&f;hasHusband"/>
</Declaration>
<InverseObjectProperties>
<ObjectProperty URI="&f;hasHusband"/>
<ObjectProperty URI="&f;hasWife"/>
</InverseObjectProperties>
<Declaration>
<ObjectProperty URI="&f;hasSon"/>
</Declaration>
<ObjectPropertyDomain>
<ObjectProperty URI="&f;hasSon"/>
<OWLClass URI="&f;Person"/>
</ObjectPropertyDomain>
<ObjectPropertyDomain>
<ObjectProperty URI="&f;hasSon"/>
<OWLClass URI="&f;Parent"/>
</ObjectPropertyDomain>
<ObjectPropertyRange>
<ObjectProperty URI="&f;hasSon"/>
<OWLClass URI="&f;Person"/>
</ObjectPropertyRange>
<ObjectPropertyRange>
<ObjectProperty URI="&f;hasSon"/>
<ObjectIntersectionOf>
<ObjectHasValue>
<ObjectProperty URI="&f;hasGender"/>
<Individual URI="&f;male"/>
</ObjectHasValue>
<OWLClass URI="&f;Person"/>
</ObjectIntersectionOf>
</ObjectPropertyRange>
<SubObjectPropertyOf>
<ObjectProperty URI="&f;hasSon"/>
<ObjectProperty URI="&f;hasChild"/>
</SubObjectPropertyOf>
<DisjointObjectProperties>
<ObjectProperty URI="&f;hasSon"/>
<ObjectProperty URI="&f;hasDaughter"/>
</DisjointObjectProperties>
<SubObjectPropertyOf>
<SubObjectPropertyChain>
<ObjectProperty URI="&f;hasSpouse"/>
<ObjectProperty URI="&f;hasSon"/>
</SubObjectPropertyChain>
<ObjectProperty URI="&f;hasSon"/>
</SubObjectPropertyOf>
<Declaration>
<ObjectProperty URI="&f;hasSpouse"/>
</Declaration>
<IrreflexiveObjectProperty>
<ObjectProperty URI="&f;hasSpouse"/>
</IrreflexiveObjectProperty>
<SymmetricObjectProperty>
<ObjectProperty URI="&f;hasSpouse"/>
</SymmetricObjectProperty>
<Declaration>
<ObjectProperty URI="&f;hasWife"/>
</Declaration>
<AsymmetricObjectProperty>
<ObjectProperty URI="&f;hasWife"/>
</AsymmetricObjectProperty>
<FunctionalObjectProperty>
<ObjectProperty URI="&f;hasWife"/>
</FunctionalObjectProperty>
<InverseFunctionalObjectProperty>
<ObjectProperty URI="&f;hasWife"/>
</InverseFunctionalObjectProperty>
<IrreflexiveObjectProperty>
<ObjectProperty URI="&f;hasWife"/>
</IrreflexiveObjectProperty>
<ObjectPropertyDomain>
<ObjectProperty URI="&f;hasWife"/>
<OWLClass URI="&f;Person"/>
</ObjectPropertyDomain>
<ObjectPropertyDomain>
<ObjectProperty URI="&f;hasWife"/>
<OWLClass URI="&f;Man"/>
</ObjectPropertyDomain>
<ObjectPropertyRange>
<ObjectProperty URI="&f;hasWife"/>
<OWLClass URI="&f;Person"/>
</ObjectPropertyRange>
<ObjectPropertyRange>
<ObjectProperty URI="&f;hasWife"/>
<OWLClass URI="&f;Woman"/>
</ObjectPropertyRange>
<SubObjectPropertyOf>
<ObjectProperty URI="&f;hasWife"/>
<ObjectProperty URI="&f;loves"/>
</SubObjectPropertyOf>
<SubObjectPropertyOf>
<ObjectProperty URI="&f;hasWife"/>
<ObjectProperty URI="&f;hasSpouse"/>
</SubObjectPropertyOf>
<Declaration>
<ObjectProperty URI="&f;loves"/>
</Declaration>
<ObjectPropertyDomain>
<ObjectProperty URI="&f;loves"/>
<OWLClass URI="&f;Person"/>
</ObjectPropertyDomain>
<Declaration>
<DataProperty URI="&f;hasAge"/>
</Declaration>
<FunctionalDataProperty>
<DataProperty URI="&f;hasAge"/>
</FunctionalDataProperty>
<DataPropertyDomain>
<DataProperty URI="&f;hasAge"/>
<OWLClass URI="&f;Person"/>
</DataPropertyDomain>
<DataPropertyRange>
<DataProperty URI="&f;hasAge"/>
<Datatype URI="&xsd;integer"/>
</DataPropertyRange>
<EquivalentDataProperties>
<DataProperty URI="&f;hasAge"/>
<DataProperty URI="&g;age"/>
</EquivalentDataProperties>
<Declaration>
<OWLClass URI="&f;Adult"/>
</Declaration>
<EquivalentClasses>
<OWLClass URI="&f;Adult"/>
<ObjectIntersectionOf>
<DataSomeValuesFrom>
<DataProperty URI="&f;hasAge"/>
<DatatypeRestriction>
<Datatype URI="&xsd;integer"/>
<DatatypeFacetRestriction facet="&owl11;minInclusive">
<Constant datatypeURI="&xsd;int">21</Constant>
</DatatypeFacetRestriction>
</DatatypeRestriction>
</DataSomeValuesFrom>
<OWLClass URI="&f;Person"/>
</ObjectIntersectionOf>
</EquivalentClasses>
<EquivalentClasses>
<OWLClass URI="&f;Adult"/>
<OWLClass URI="&g;Grownup"/>
</EquivalentClasses>
<Declaration>
<OWLClass URI="&f;Child"/>
</Declaration>
<EquivalentClasses>
<OWLClass URI="&f;Child"/>
<ObjectIntersectionOf>
<ObjectComplementOf>
<DataSomeValuesFrom>
<DataProperty URI="&f;hasAge"/>
<DatatypeRestriction>
<Datatype URI="&xsd;integer"/>
<DatatypeFacetRestriction facet="&owl11;minInclusive">
<Constant datatypeURI="&xsd;int">21</Constant>
</DatatypeFacetRestriction>
</DatatypeRestriction>
</DataSomeValuesFrom>
</ObjectComplementOf>
<OWLClass URI="&f;Person"/>
</ObjectIntersectionOf>
</EquivalentClasses>
<Declaration>
<OWLClass URI="&f;CivilMarriage"/>
</Declaration>
<DisjointClasses>
<OWLClass URI="&f;CivilMarriage"/>
<OWLClass URI="&f;ReligiousMarriage"/>
</DisjointClasses>
<Declaration>
<OWLClass URI="&f;Man"/>
</Declaration>
<EquivalentClasses>
<OWLClass URI="&f;Man"/>
<ObjectIntersectionOf>
<ObjectHasValue>
<ObjectProperty URI="&f;hasGender"/>
<Individual URI="&f;male"/>
</ObjectHasValue>
<OWLClass URI="&f;Person"/>
</ObjectIntersectionOf>
</EquivalentClasses>
<Declaration>
<OWLClass URI="&f;Marriage"/>
</Declaration>
<EquivalentClasses>
<OWLClass URI="&f;Marriage"/>
<ObjectUnionOf>
<OWLClass URI="&f;CivilMarriage"/>
<OWLClass URI="&f;ReligiousMarriage"/>
</ObjectUnionOf>
</EquivalentClasses>
<Declaration>
<OWLClass URI="&f;Narcissist"/>
</Declaration>
<EquivalentClasses>
<OWLClass URI="&f;Narcissist"/>
<ObjectIntersectionOf>
<OWLClass URI="&f;Person"/>
<ObjectExistsSelf>
<ObjectProperty URI="&f;loves"/>
</ObjectExistsSelf>
</ObjectIntersectionOf>
</EquivalentClasses>
<Declaration>
<OWLClass URI="&f;Parent"/>
</Declaration>
<EquivalentClasses>
<OWLClass URI="&f;Parent"/>
<ObjectIntersectionOf>
<ObjectMinCardinality cardinality="1">
<ObjectProperty URI="&f;hasChild"/>
<OWLClass URI="&f;Person"/>
</ObjectMinCardinality>
<OWLClass URI="&f;Person"/>
</ObjectIntersectionOf>
</EquivalentClasses>
<Declaration>
<OWLClass URI="&f;Person"/>
</Declaration>
<SubClassOf>
<OWLClass URI="&f;Person"/>
<ObjectIntersectionOf>
<DataExactCardinality cardinality="1">
<DataProperty URI="&f;hasAge"/>
</DataExactCardinality>
<ObjectExactCardinality cardinality="1">
<ObjectProperty URI="&f;hasGender"/>
</ObjectExactCardinality>
<ObjectAllValuesFrom>
<ObjectProperty URI="&f;hasGender"/>
<ObjectOneOf>
<Individual URI="&f;female"/>
<Individual URI="&f;male"/>
</ObjectOneOf>
</ObjectAllValuesFrom>
</ObjectIntersectionOf>
</SubClassOf>
<Declaration>
<OWLClass URI="&f;ReligiousMarriage"/>
</Declaration>
<Declaration>
<OWLClass URI="&f;Teenager"/>
</Declaration>
<EquivalentClasses>
<OWLClass URI="&f;Teenager"/>
<ObjectIntersectionOf>
<DataSomeValuesFrom>
<DataProperty URI="&f;hasAge"/>
<DatatypeRestriction>
<Datatype URI="&xsd;integer"/>
<DatatypeFacetRestriction facet="&owl11;minInclusive">
<Constant datatypeURI="&xsd;int">13</Constant>
</DatatypeFacetRestriction>
<DatatypeFacetRestriction facet="&owl11;maxExclusive">
<Constant datatypeURI="&xsd;int">20</Constant>
</DatatypeFacetRestriction>
</DatatypeRestriction>
</DataSomeValuesFrom>
<OWLClass URI="&f;Person"/>
</ObjectIntersectionOf>
</EquivalentClasses>
<Declaration>
<OWLClass URI="&f;Woman"/>
</Declaration>
<EquivalentClasses>
<OWLClass URI="&f;Woman"/>
<ObjectIntersectionOf>
<OWLClass URI="&f;Person"/>
<ObjectHasValue>
<ObjectProperty URI="&f;hasGender"/>
<Individual URI="&f;female"/>
</ObjectHasValue>
</ObjectIntersectionOf>
</EquivalentClasses>
<Declaration>
<OWLClass URI="&f;YoungChild"/>
</Declaration>
<EquivalentClasses>
<OWLClass URI="&f;YoungChild"/>
<ObjectIntersectionOf>
<ObjectComplementOf>
<ObjectUnionOf>
<OWLClass URI="&f;Teenager"/>
<OWLClass URI="&f;Adult"/>
</ObjectUnionOf>
</ObjectComplementOf>
<OWLClass URI="&f;Person"/>
</ObjectIntersectionOf>
</EquivalentClasses>
<Declaration>
<Individual URI="&f;Bill"/>
</Declaration>
<ClassAssertion>
<ObjectComplementOf>
<OWLClass URI="&f;Narcissist"/>
</ObjectComplementOf>
<Individual URI="&f;Bill"/>
</ClassAssertion>
<ObjectPropertyAssertion>
<ObjectProperty URI="&f;hasGender"/>
<Individual URI="&f;Bill"/>
<Individual URI="&f;male"/>
</ObjectPropertyAssertion>
<DataPropertyAssertion>
<DataProperty URI="&f;hasAge"/>
<Individual URI="&f;Bill"/>
<Constant datatypeURI="&xsd;integer">13</Constant>
</DataPropertyAssertion>
<Declaration>
<Individual URI="&f;Ellen"/>
</Declaration>
<ClassAssertion>
<DataSomeValuesFrom>
<DataProperty URI="&f;hasAge"/>
<DatatypeRestriction>
<Datatype URI="&xsd;integer"/>
<DatatypeFacetRestriction facet="&owl11;minInclusive">
<Constant datatypeURI="&xsd;int">15</Constant>
</DatatypeFacetRestriction>
<DatatypeFacetRestriction facet="&owl11;maxInclusive">
<Constant datatypeURI="&xsd;int">21</Constant>
</DatatypeFacetRestriction>
</DatatypeRestriction>
</DataSomeValuesFrom>
<Individual URI="&f;Ellen"/>
</ClassAssertion>
<Declaration>
<Individual URI="&f;Emily"/>
</Declaration>
<ClassAssertion>
<DataSomeValuesFrom>
<DataProperty URI="&f;hasAge"/>
<DataOneOf>
<Constant datatypeURI="&xsd;integer">39</Constant>
<Constant datatypeURI="&xsd;integer">49</Constant>
</DataOneOf>
</DataSomeValuesFrom>
<Individual URI="&f;Emily"/>
</ClassAssertion>
<Declaration>
<Individual URI="&f;Jack"/>
</Declaration>
<NegativeDataPropertyAssertion>
<DataProperty URI="&f;hasAge"/>
<Individual URI="&f;Jack"/>
<Constant datatypeURI="&xsd;integer">53</Constant>
</NegativeDataPropertyAssertion>
<Declaration>
<Individual URI="&f;Jeff"/>
</Declaration>
<ClassAssertion>
<ObjectExactCardinality cardinality="2">
<ObjectProperty URI="&f;hasChild"/>
</ObjectExactCardinality>
<Individual URI="&f;Jeff"/>
</ClassAssertion>
<ObjectPropertyAssertion>
<ObjectProperty URI="&f;hasChild"/>
<Individual URI="&f;Jeff"/>
<Individual URI="&f;Ellen"/>
</ObjectPropertyAssertion>
<ObjectPropertyAssertion>
<ObjectProperty URI="&f;hasChild"/>
<Individual URI="&f;Jeff"/>
<Individual URI="&f;Jack"/>
</ObjectPropertyAssertion>
<ObjectPropertyAssertion>
<ObjectProperty URI="&f;hasWife"/>
<Individual URI="&f;Jeff"/>
<Individual URI="&f;Emily"/>
</ObjectPropertyAssertion>
<ObjectPropertyAssertion>
<ObjectProperty URI="&f;loves"/>
<Individual URI="&f;Jeff"/>
<Individual URI="&f;Jeff"/>
</ObjectPropertyAssertion>
<DataPropertyAssertion>
<DataProperty URI="&f;hasAge"/>
<Individual URI="&f;Jeff"/>
<Constant datatypeURI="&xsd;integer">77</Constant>
</DataPropertyAssertion>
<DifferentIndividuals>
<Individual URI="&f;Jeff"/>
<Individual URI="&f;Emily"/>
<Individual URI="&f;Jack"/>
<Individual URI="&f;Ellen"/>
<Individual URI="&f;Susan"/>
</DifferentIndividuals>
<Declaration>
<Individual URI="&f;John"/>
</Declaration>
<ClassAssertion>
<OWLClass URI="&f;Person"/>
<Individual URI="&f;John"/>
</ClassAssertion>
<ObjectPropertyAssertion>
<ObjectProperty URI="&f;hasDaughter"/>
<Individual URI="&f;John"/>
<Individual URI="&f;Susan"/>
</ObjectPropertyAssertion>
<ObjectPropertyAssertion>
<ObjectProperty URI="&f;hasGender"/>
<Individual URI="&f;John"/>
<Individual URI="&f;male"/>
</ObjectPropertyAssertion>
<ObjectPropertyAssertion>
<ObjectProperty URI="&f;hasSon"/>
<Individual URI="&f;John"/>
<Individual URI="&f;Bill"/>
</ObjectPropertyAssertion>
<ObjectPropertyAssertion>
<ObjectProperty URI="&f;hasWife"/>
<Individual URI="&f;John"/>
<Individual URI="&f;Mary"/>
</ObjectPropertyAssertion>
<DataPropertyAssertion>
<DataProperty URI="&f;hasAge"/>
<Individual URI="&f;John"/>
<Constant datatypeURI="&xsd;integer">33</Constant>
</DataPropertyAssertion>
<SameIndividuals>
<Individual URI="&f;John"/>
<Individual URI="&f;Jack"/>
</SameIndividuals>
<DifferentIndividuals>
<Individual URI="&f;John"/>
<Individual URI="&f;Mary"/>
<Individual URI="&f;Bill"/>
<Individual URI="&f;Susan"/>
</DifferentIndividuals>
<Declaration>
<Individual URI="&f;Mary"/>
</Declaration>
<ObjectPropertyAssertion>
<ObjectProperty URI="&f;hasDaughter"/>
<Individual URI="&f;Mary"/>
<Individual URI="&f;Susan"/>
</ObjectPropertyAssertion>
<ObjectPropertyAssertion>
<ObjectProperty URI="&f;hasGender"/>
<Individual URI="&f;Mary"/>
<Individual URI="&f;female"/>
</ObjectPropertyAssertion>
<ObjectPropertyAssertion>
<ObjectProperty URI="&f;hasSon"/>
<Individual URI="&f;Mary"/>
<Individual URI="&f;Bill"/>
</ObjectPropertyAssertion>
<DataPropertyAssertion>
<DataProperty URI="&f;hasAge"/>
<Individual URI="&f;Mary"/>
<Constant datatypeURI="&xsd;integer">31</Constant>
</DataPropertyAssertion>
<Declaration>
<Individual URI="&f;Susan"/>
</Declaration>
<ObjectPropertyAssertion>
<ObjectProperty URI="&f;hasGender"/>
<Individual URI="&f;Susan"/>
<Individual URI="&f;female"/>
</ObjectPropertyAssertion>
<DataPropertyAssertion>
<DataProperty URI="&f;hasAge"/>
<Individual URI="&f;Susan"/>
<Constant datatypeURI="&xsd;integer">8</Constant>
</DataPropertyAssertion>
<Declaration>
<Individual URI="&f;female"/>
</Declaration>
<SameIndividuals>
<Individual URI="&f;female"/>
<Individual URI="&g;feminine"/>
</SameIndividuals>
<DifferentIndividuals>
<Individual URI="&f;female"/>
<Individual URI="&f;male"/>
</DifferentIndividuals>
<Declaration>
<Individual URI="&f;male"/>
</Declaration>
<SameIndividuals>
<Individual URI="&f;male"/>
<Individual URI="&g;masculine"/>
</SameIndividuals>
</Ontology>
RDF/XML синтаксис:
<?xml version="1.0"?>
<!DOCTYPE rdf:RDF [
<!ENTITY owl "http://www.w3.org/2002/07/owl#" >
<!ENTITY owl11 "http://www.w3.org/2006/12/owl11#" >
<!ENTITY rdf "http://www.w3.org/1999/02/22-rdf-syntax-ns#" >
<!ENTITY rdfs "http://www.w3.org/2000/01/rdf-schema#" >
<!ENTITY xsd "http://www.w3.org/2001/XMLSchema#" >
<!ENTITY f "http://example.com/owl/families#" >
<!ENTITY g "http://example.com/owl2/families#" >
<!ENTITY dc "http://purl.org/dc/elements/1.1/#" >
]>
<rdf:RDF xml:base="http://example.com/owl/families"
xmlns="http://example.com/owl/families#"
xmlns:owl="http://www.w3.org/2002/07/owl#">
xmlns:owl11="http://www.w3.org/2006/12/owl11#"
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
xmlns:xsd="http://www.w3.org/2001/XMLSchema#"
xmlns:f="http://example.com/owl/families#"
xmlns:g="http://example.com/owl2/families#"
<owl:Ontology rdf:about="http://example.com/owl/families">
<owl:imports rdf:resource="http://example.com/owl2/families.owl"/>
</owl:Ontology>
<owl:ObjectProperty rdf:about="#hasAncestor">
<rdf:type rdf:resource="&owl;TransitiveProperty"/>
<rdf:type rdf:resource="&owl11;IrreflexiveProperty"/>
</owl:ObjectProperty>
<owl:ObjectProperty rdf:about="#hasChild">
<rdfs:subPropertyOf rdf:resource="#hasAncestor"/>
<rdfs:domain rdf:resource="#Person"/>
<rdfs:range rdf:resource="#Person"/>
<owl:equivalentProperty rdf:resource="&g;child"/>
</owl:ObjectProperty>
<owl:ObjectProperty rdf:about="#hasDaughter">
<rdfs:range>
<owl:Class>
<owl:intersectionOf rdf:parseType="Collection">
<rdf:Description rdf:about="#Person"/>
<owl:Restriction>
<owl:onProperty rdf:resource="#hasGender"/>
<owl:hasValue rdf:resource="#female"/>
</owl:Restriction>
</owl:intersectionOf>
</owl:Class>
</rdfs:range>
<rdfs:range rdf:resource="#Person"/>
<rdfs:domain rdf:resource="#Person"/>
<rdfs:subPropertyOf rdf:resource="#hasChild"/>
<rdfs:domain rdf:resource="#Parent"/>
<owl11:disjointObjectProperties rdf:resource="#hasSon"/>
</owl:ObjectProperty>
<owl:ObjectProperty rdf:about="#hasGender"/>
<owl:ObjectProperty rdf:about="#hasHusband">
<owl:inverseOf rdf:resource="#hasWife"/>
</owl:ObjectProperty>
<owl:ObjectProperty rdf:about="#hasSon">
<rdfs:range>
<owl:Class>
<owl:intersectionOf rdf:parseType="Collection">
<rdf:Description rdf:about="#Person"/>
<owl:Restriction>
<owl:onProperty rdf:resource="#hasGender"/>
<owl:hasValue rdf:resource="#male"/>
</owl:Restriction>
</owl:intersectionOf>
</owl:Class>
</rdfs:range>
<rdfs:subPropertyOf rdf:resource="#hasChild"/>
<rdfs:range rdf:resource="#Person"/>
<rdfs:domain rdf:resource="#Person"/>
<rdfs:domain rdf:resource="#Parent"/>
</owl:ObjectProperty>
<owl:ObjectProperty rdf:about="#hasSpouse">
<rdf:type rdf:resource="&owl;SymmetricProperty"/>
<rdf:type rdf:resource="&owl11;IrreflexiveProperty"/>
</owl:ObjectProperty>
<owl:ObjectProperty rdf:about="#hasWife">
<rdf:type rdf:resource="&owl;InverseFunctionalProperty"/>
<rdf:type rdf:resource="&owl;FunctionalProperty"/>
<rdf:type rdf:resource="&owl11;AsymmetricProperty"/>
<rdf:type rdf:resource="&owl11;IrreflexiveProperty"/>
<rdfs:domain rdf:resource="#Person"/>
<rdfs:range rdf:resource="#Person"/>
<rdfs:subPropertyOf rdf:resource="#loves"/>
<rdfs:range rdf:resource="#Woman"/>
<rdfs:subPropertyOf rdf:resource="#hasSpouse"/>
<rdfs:domain rdf:resource="#Man"/>
</owl:ObjectProperty>
<owl:ObjectProperty rdf:about="#loves">
<rdfs:domain rdf:resource="#Person"/>
</owl:ObjectProperty>
<owl:DatatypeProperty rdf:about="#hasAge">
<rdf:type rdf:resource="&owl;FunctionalProperty"/>
<rdfs:domain rdf:resource="#Person"/>
<rdfs:range rdf:resource="&xsd;integer"/>
<owl:equivalentProperty rdf:resource="&g;age"/>
</owl:DatatypeProperty>
<owl:Class rdf:about="#Adult">
<owl:equivalentClass>
<owl:Class>
<owl:intersectionOf rdf:parseType="Collection">
<rdf:Description rdf:about="#Person"/>
<owl:Restriction>
<owl:onProperty rdf:resource="#hasAge"/>
<owl:someValuesFrom>
<rdf:Description>
<rdf:type rdf:resource="&owl;DataRange"/>
<owl11:onDataRange rdf:resource="&xsd;integer"/>
<owl11:minInclusive rdf:datatype="&xsd;int">21</owl11:minInclusive>
</rdf:Description>
</owl:someValuesFrom>
</owl:Restriction>
</owl:intersectionOf>
</owl:Class>
</owl:equivalentClass>
<owl:equivalentClass rdf:resource="&g;Grownup"/>
</owl:Class>
<owl:Class rdf:about="#Child">
<owl:equivalentClass>
<owl:Class>
<owl:intersectionOf rdf:parseType="Collection">
<rdf:Description rdf:about="#Person"/>
<owl:Class>
<owl:complementOf>
<owl:Restriction>
<owl:onProperty rdf:resource="#hasAge"/>
<owl:someValuesFrom>
<rdf:Description>
<rdf:type rdf:resource="&owl;DataRange"/>
<owl11:onDataRange rdf:resource="&xsd;integer"/>
<owl11:minInclusive rdf:datatype="&xsd;int">21</owl11:minInclusive>
</rdf:Description>
</owl:someValuesFrom>
</owl:Restriction>
</owl:complementOf>
</owl:Class>
</owl:intersectionOf>
</owl:Class>
</owl:equivalentClass>
</owl:Class>
<owl:Class rdf:about="#CivilMarriage" />
<owl:Class rdf:about="#Man">
<rdfs:subClassOf rdf:resource="#Parent"/>
<owl:equivalentClass>
<owl:Class>
<owl:intersectionOf rdf:parseType="Collection">
<rdf:Description rdf:about="#Person"/>
<owl:Restriction>
<owl:onProperty rdf:resource="#hasGender"/>
<owl:hasValue rdf:resource="#male"/>
</owl:Restriction>
</owl:intersectionOf>
</owl:Class>
</owl:equivalentClass>
</owl:Class>
<owl:Class rdf:about="#Marriage">
<owl:equivalentClass>
<owl:Class>
<owl:unionOf rdf:parseType="Collection">
<rdf:Description rdf:about="#CivilMarriage"/>
<rdf:Description rdf:about="#ReligiousMarriage"/>
</owl:unionOf>
</owl:Class>
</owl:equivalentClass>
</owl:Class>
<owl:Class rdf:about="#Narcissist">
<owl:equivalentClass>
<owl:Class>
<owl:intersectionOf rdf:parseType="Collection">
<rdf:Description>
<rdf:type rdf:resource="&owl11;SelfRestriction"/>
<owl:onProperty rdf:resource="#loves"/>
</rdf:Description>
<rdf:Description rdf:about="#Person"/>
</owl:intersectionOf>
</owl:Class>
</owl:equivalentClass>
</owl:Class>
<owl:Class rdf:about="#Parent">
<rdfs:subClassOf rdf:resource="#Parent"/>
<owl:equivalentClass>
<owl:Class>
<owl:intersectionOf rdf:parseType="Collection">
<owl:Restriction>
<owl:onProperty rdf:resource="#hasChild"/>
<owl11:onClass rdf:resource="#Person"/>
<owl:minCardinalityQ rdf:datatype="&xsd;nonNegativeInteger">1</owl:minCardinalityQ>
</owl:Restriction>
<rdf:Description rdf:about="#Person"/>
</owl:intersectionOf>
</owl:Class>
</owl:equivalentClass>
</owl:Class>
<owl:Class rdf:about="#Person">
<rdfs:subClassOf>
<owl:Class>
<owl:intersectionOf rdf:parseType="Collection">
<owl:Restriction>
<owl:onProperty rdf:resource="#hasGender"/>
<owl:allValuesFrom>
<owl:Class>
<owl:oneOf rdf:parseType="Collection">
<rdf:Description rdf:about="#female"/>
<rdf:Description rdf:about="#male"/>
</owl:oneOf>
</owl:Class>
</owl:allValuesFrom>
</owl:Restriction>
<owl:Restriction>
<owl:onProperty rdf:resource="#hasGender"/>
<owl:cardinality rdf:datatype="&xsd;nonNegativeInteger">1</owl:cardinality>
</owl:Restriction>
<owl:Restriction>
<owl:onProperty rdf:resource="#hasAge"/>
<owl:cardinality rdf:datatype="&xsd;nonNegativeInteger">1</owl:cardinality>
</owl:Restriction>
</owl:intersectionOf>
</owl:Class>
</rdfs:subClassOf>
</owl:Class>
<owl:Class rdf:about="#ReligiousMarriage">
<owl:disjointWith rdf:resource="#CivilMarriage"/>
</owl:Class>
<owl:Class rdf:about="#Teenager">
<owl:equivalentClass>
<owl:Class>
<owl:intersectionOf rdf:parseType="Collection">
<rdf:Description rdf:about="#Person"/>
<owl:Restriction>
<owl:onProperty rdf:resource="#hasAge"/>
<owl:someValuesFrom>
<rdf:Description>
<rdf:type rdf:resource="&owl;DataRange"/>
<owl11:minInclusive rdf:datatype="&xsd;int">13</owl11:minInclusive>
<owl11:maxExclusive rdf:datatype="&xsd;int">20</owl11:maxExclusive>
<owl11:onDataRange rdf:resource="&xsd;integer"/>
</rdf:Description>
</owl:someValuesFrom>
</owl:Restriction>
</owl:intersectionOf>
</owl:Class>
</owl:equivalentClass>
</owl:Class>
<owl:Class rdf:about="#Woman">
<rdfs:subClassOf rdf:resource="#Parent"/>
<owl:equivalentClass>
<owl:Class>
<owl:intersectionOf rdf:parseType="Collection">
<rdf:Description rdf:about="#Person"/>
<owl:Restriction>
<owl:onProperty rdf:resource="#hasGender"/>
<owl:hasValue rdf:resource="#female"/>
</owl:Restriction>
</owl:intersectionOf>
</owl:Class>
</owl:equivalentClass>
</owl:Class>
<owl:Class rdf:about="#YoungChild">
<owl:equivalentClass>
<owl:Class>
<owl:intersectionOf rdf:parseType="Collection">
<rdf:Description rdf:about="#Person"/>
<owl:Class>
<owl:complementOf>
<owl:Class>
<owl:unionOf rdf:parseType="Collection">
<rdf:Description rdf:about="#Adult"/>
<rdf:Description rdf:about="#Teenager"/>
</owl:unionOf>
</owl:Class>
</owl:complementOf>
</owl:Class>
</owl:intersectionOf>
</owl:Class>
</owl:equivalentClass>
</owl:Class>
<rdf:Description rdf:about="#Bill">
<rdf:type>
<owl:Class>
<owl:complementOf rdf:resource="#Narcissist"/>
</owl:Class>
</rdf:type>
<hasAge rdf:datatype="&xsd;integer">13</hasAge>
<hasGender rdf:resource="#male"/>
</rdf:Description>
<rdf:Description rdf:about="#Ellen">
<rdf:type>
<owl:Restriction>
<owl:onProperty rdf:resource="#hasAge"/>
<owl:someValuesFrom>
<rdf:Description>
<rdf:type rdf:resource="&owl;DataRange"/>
<owl11:minInclusive rdf:datatype="&xsd;int">15</owl11:minInclusive>
<owl11:onDataRange rdf:resource="&xsd;integer"/>
<owl11:maxInclusive rdf:datatype="&xsd;int">21</owl11:maxInclusive>
</rdf:Description>
</owl:someValuesFrom>
</owl:Restriction>
</rdf:type>
</rdf:Description>
<rdf:Description rdf:about="#Emily">
<rdf:type>
<owl:Restriction>
<owl:onProperty rdf:resource="#hasAge"/>
<owl:someValuesFrom>
<rdf:Description>
<rdf:type rdf:resource="&owl;DataRange"/>
<owl:oneOf>
<rdf:Description>
<rdf:type rdf:resource="&rdf;List"/>
<rdf:first rdf:datatype="&xsd;integer">39</rdf:first>
<rdf:rest>
<rdf:Description>
<rdf:type rdf:resource="&rdf;List"/>
<rdf:rest rdf:resource="&rdf;nil"/>
<rdf:first rdf:datatype="&xsd;integer">49</rdf:first>
</rdf:Description>
</rdf:rest>
</rdf:Description>
</owl:oneOf>
</rdf:Description>
</owl:someValuesFrom>
</owl:Restriction>
</rdf:type>
</rdf:Description>
<owl11:NegativeDataPropertyAssertion>
<rdf:subject rdf:resource="#Jack"/>
<rdf:predicate rdf:resource="#hasAge"/>
<rdf:object rdf:datatype="&xsd;integer">53</rdf:object>
</owl11:NegativeDataPropertyAssertion>
<rdf:Description rdf:about="#Jeff">
<rdf:type>
<owl:Restriction>
<owl:onProperty rdf:resource="#hasChild"/>
<owl:cardinality rdf:datatype="&xsd;nonNegativeInteger">2</owl:cardinality>
</owl:Restriction>
</rdf:type>
<hasAge rdf:datatype="&xsd;integer">77</hasAge>
<hasChild rdf:resource="#Ellen"/>
<hasWife rdf:resource="#Emily"/>
<loves rdf:resource="#Jeff"/>
<hasChild rdf:resource="#Jack"/>
</rdf:Description>
<Person rdf:about="#John">
<hasDaughter rdf:resource="#Susan"/>
<hasGender rdf:resource="#male"/>
<hasWife rdf:resource="#Mary"/>
<hasSon rdf:resource="#Bill"/>
<hasAge rdf:datatype="&xsd;integer">33</hasAge>
<owl:sameAs rdf:resource="#Jack"/>
</Person>
<rdf:Description rdf:about="#Mary">
<hasAge rdf:datatype="&xsd;integer">31</hasAge>
<hasGender rdf:resource="#female"/>
<hasSon rdf:resource="#Bill"/>
<hasDaughter rdf:resource="#Susan"/>
</rdf:Description>
<rdf:Description rdf:about="#Susan">
<hasAge rdf:datatype="&xsd;integer">8</hasAge>
<hasGender rdf:resource="#female"/>
</rdf:Description>
<rdf:Description rdf:about="#female">
<owl:sameAs rdf:resource="&g;feminine"/>
</rdf:Description>
<rdf:Description rdf:about="#male">
<owl:sameAs rdf:resource="&g;masculine"/>
</rdf:Description>
<rdf:Description>
<rdf:type rdf:resource="&owl;AllDifferent"/>
<owl:distinctMembers rdf:parseType="Collection">
<rdf:Description rdf:about="#John"/>
<rdf:Description rdf:about="#Mary"/>
<rdf:Description rdf:about="#Bill"/>
<rdf:Description rdf:about="#Susan"/>
</owl:distinctMembers>
</rdf:Description>
<rdf:Description>
<rdf:type rdf:resource="&owl;AllDifferent"/>
<owl:distinctMembers rdf:parseType="Collection">
<rdf:Description rdf:about="#Jeff"/>
<rdf:Description rdf:about="#Emily"/>
<rdf:Description rdf:about="#Jack"/>
<rdf:Description rdf:about="#Ellen"/>
<rdf:Description rdf:about="#Susan"/>
</owl:distinctMembers>
</rdf:Description>
<rdf:Description>
<rdf:type rdf:resource="&owl;AllDifferent"/>
<owl:distinctMembers rdf:parseType="Collection">
<rdf:Description rdf:about="#male"/>
<rdf:Description rdf:about="#female"/>
</owl:distinctMembers>
</rdf:Description>
<rdf:Description>
<rdf:type rdf:resource="&rdf;List"/>
<rdf:first rdf:resource="#hasSpouse"/>
<rdf:rest rdf:parseType="Collection">
<rdf:Description rdf:about="#hasSon"/>
</rdf:rest>
<rdfs:subPropertyOf rdf:resource="#hasSon"/>
</rdf:Description>
<rdf:Description>
<rdf:type rdf:resource="&rdf;List"/>
<rdf:first rdf:resource="#hasSpouse"/>
<rdf:rest rdf:parseType="Collection">
<rdf:Description rdf:about="#hasDaughter"/>
</rdf:rest>
<rdfs:subPropertyOf rdf:resource="#hasDaughter"/>
</rdf:Description>
</rdf:RDF>
13 Благодарности
Примечание редактора: Здесь будет приведен список всех лиц, чьи комментарии повлияли на изменение данного черновика.
14 Ссылки
- [Профили OWL 2]
- Язык Web-онтологий OWL 2:Профили Bernardo
Cuenca Grau, Boris Motik, Zhe
Wu,
Achille Fokoue, Carsten
Lutz. W3C Working Draft, 11 April 2008, http://www.w3.org/TR/2008/WD-owl2-profiles-20080411/. Latest version available at http://www.w3.org/TR/owl2-profiles/.
- [OWL 2 Манчестерский синтаксис]
- Язык Web-онтологий OWL 2: Манчестерский синтаксис. Matthew Horridge and Peter F. Patel-Schneider and others, 2008.
- [Преобразование OWL 2 в RDF]
- Язык Web-онтологий OWL 2:Преобразование в RDF-графы Bernardo Cuenca Grau, Boris
Motik. W3C Working Draft, 11 April 2008, http://www.w3.org/TR/2008/WD-owl2-mapping-to-rdf-20080411/. Latest version available at http://www.w3.org/TR/owl2-mapping-to-rdf/.
- [Семантики OWL 2]
- Язык Web-онтологий OWL 2:Модельно-теоретические семантики Bernardo Cuenca Grau, Boris
Motik. W3C Working Draft, 11 April 2008, http://www.w3.org/TR/2008/WD-owl2-semantics-20080411/. Latest version available at http://www.w3.org/TR/owl2-semantics/.
- [Спецификация OWL 2]
- Язык Web-онтологий OWL 2:Структурная спецификация и функциональный синтаксис Boris
Motik, Peter F. Patel-Schneider, Ian
Horrocks. W3C Working Draft, 11 April 2008, http://www.w3.org/TR/2008/WD-owl2-syntax-20080411/. Latest version available at http://www.w3.org/TR/owl2-syntax/.
- [Синтаксис XML OWL 2]
- Язык Web-онтологий OWL 2:XML-сериализация Bernardo
Cuenca Grau, Boris
Motik, Peter
Patel-Schneider. W3C Working Draft, 11 April 2008, http://www.w3.org/TR/2008/WD-owl2-xml-serialization-20080411/. Latest version available at http://www.w3.org/TR/owl2-xml-serialization/.
- [Типы данных XML Schema]
- Схемы XML часть 2: Типы данных Второе издание. Paul V. Biron and Ashok Malhotra, eds. W3C Recommendation 28 October 2004.
- [Обзор OWL]
- Обзор OWL. W3C Recommendation 10 Feb 2004. McGuinness, van Harmelen, eds.
- [Руководство OWL]
- Руководство OWL. W3C Recommendation 10 Feb 2004. Smith, Welty, McGuinness eds.
- [Ссылки OWL]
- Ссылки OWL. W3C Recommendation 10 Feb 2004. Dean, Schreiber, eds.
- [Семантики и абстрактный синтаксис OWL]
- Семантики и абстрактный синтаксис OWL. W3C Recommendation 10 Feb 2004. Patel-Schneider, Hayes, Horrocks, eds.
- [Язык Web-онтологий OWL: тестовые варианты]
- Язык Web-онтологий OWL: тестовые варианты. W3C Recommendation 10 Feb 2004. Carroll, De Roo, eds.
- [Язык Web-онтологий OWL: варианты использования и требования]
- Язык Web-онтологий OWL: варианты использования и требования. W3C Recommendation 10 Feb 2004. Heflin, ed.
Этот документ является неофициальным переводом исходной
английской версии. Может содержать неточности и ошибки.
© PhD Щербак Сергей, 2008
Комментарии к переводу оставляйте здесь!|| На главную || Перепечатка?