Introduction

Tawny-OWL is fully programmatic environment for Ontology Development
Presents a different model of ontology development
Very powerful
Allows reuse of commodity tooling

Today

Some taught material
Some "follow-by-leader"
Plenty of time for questions
A flexible tail

Today

Attempted to make decoupled
Aware that people will come in and out
Probably not be entirely successful at this.
Gets more programmatic as we go on
Will not explain all of the programming

Knowledge Prerequisites

Required
- Basic knowledge of ontologies
- Basic knowledge of OWL
- Basic knowledge of biology (amino-acids!)
- For last 1/3: Basic Programming Knowledge
Not Required
- Knowledge of Clojure
- Knowledge of OWL API
- Knowledge of Tawny-OWL

Outcomes

Understand the motivation behind Tawny
Understand and use basic Clojure infrastructure
Build a basic ontology with Tawny
Understanding pattern usage within Tawny
Implementing a pattern
Extending Tawny locally

Secondary Outcomes

Understand how to repurpose software tooling for ontologies

Notes on Notes

All materials are available
These slides (2015_lisbon.html)
As a book with lecture notes (2015_lisbon_book.html)
Same thing as PDF (but less well checked!).

http://homepages.cs.ncl.ac.uk/phillip.lord/download/tawny/icbo_2015

Motivation

Tawny-OWL was initially an accidental tool
We did not start off writing a new environment
We discovered we needed while trying to build an ontology

Use Case (chromosomes)

The human karyotype is complex to describe
Alterations more so

Use Case (karyotypes)

Current, representation comes from ISCN
Written in a book, no computational representation.

47,XXY
46,Xc,+21
46,XY,+21c,-21
45,XY,-10,der(10)t(10;17)(q22;p12)
46,XY,der(7)t(2;7)(q21;q22)ins(7;?)(q22;?)
46,XX,der(8)t(8;17)(p23;q21)inv(8)(p22q13)t(8;22)(q22;q12)
46,XX,der(9)del(9)(p12)t(9;22)(q34;q11.2),der(9)t(9;12)(p13;q22)inv(9)(q13q22)
An ontological representation seems like a nice idea

A partonomy?

What you see is what you get?
There are 23 chromosomes
Around 1000 bands, at different resolution levels.

Protege

Could do this in protege
Technically, it scales well to an ontology of this size

Protege

But the user interface does not
Generating many similar classes is painful
Hard to know how an axiomatisation will perform at the start
Changing them afterwards even worse

Protege

But the user interface does not
We end up more like this.

Can we do this programmatically?

Yes, but painfully
OWL API — used by many, including Protege 4
Java and the OWL API are long-winded
Compile-Code-Test cycle!

OWLClass clsA = df.getOWLClass(IRI.create(pizza_iri + "#A"));
OWLClass clsB = df.getOWLClass(IRI.create(pizza_iri + "#B"));
// Now create the axiom
OWLAxiom axiom = df.getOWLSubClassOfAxiom(clsA, clsB);
// add the axiom to the ontology.
AddAxiom addAxiom = new AddAxiom(o, axiom);
// We now use the manager to apply the change
m.applyChange(addAxiom);

Brain

Written by Samuel Croset, EBI
EL only
Compile/run cycle
How does this fit with Java’s OO?

Brain brain = new Brain();
//Add the OWL classes
brain.addClass("Nucleus");
brain.addClass("Cell");
//Add the OWL object property
brain.addObjectProperty("part-of");
//Assert the axiom
brain.subClassOf("Nucleus", "part-of some Cell");

The Paragon

R provides an interactive, exploratory environment for stats
Command line shell, wrapped by several GUIs
Language is convienient to type and use

It’s not all good!
The syntax can be bizzare
The language semantics are strange

Constraints

Simple to do (structurally) simple ontologies
OWL API — too much code to rewrite
Java (JVM) — because of the OWL API
Pre-existing development tooling

Karyotype Ontology

What have we achieved?
Build by Dr Jennifer Warrender
Around 1000 classes in the karyotype ontology
Similar numbers of tests, structural and reasoner based
Models 10 events, with patterns for downstream use
Multiple levels of ploidy
Performance tested axiomatisation

Tawny-OWL Key Features

Now we move onto Tawny-OWL features
Ontology building tool
Unprogrammatic syntax, minimal baggage
Evaluative
Broadcasting
Patternized
Fully Extensible
Integrated Reasoning
Build on commondity language
Access to fully programming Tool Chain

Ontology Building Tool

Tawny-OWL is an Ontology Building Tool
"A Textual User Interface"
Usable as an API.
But not designed as an API

Unprogrammatic Syntax

Both OWL API and Brain carry Java baggage
You can never forget you are programming
Tawny-OWL aimed to avoid this

(defontology o)

Unprogrammatic Syntax

Are many OWL syntaxes to chose from
Functional, Concrete, XML.
Or RDF (RDF/XML, Turtle, N3)
Manchester (OMN) syntax designed for typing
Frame based, rather than axiom based

Class: o:A

    Annotations:
        rdfs:label "A"@en,
        rdfs:comment "A is a kind of thing."@en

Unprogrammatic Syntax

Tawny-OWL modelled on OMN
Modified to use lisp/clojure syntax
Entities need parens
No longer need commas
Blocks are explicit, so easier to parse

(defclass A
  :label "A"
  :comment "A is a kind of thing.")

Unprogrammatic Syntax

Frame names use :colon and not colon:
Just for fit with lisp
Some names have changed :super rather that SubClassOf:
- Consistent with property (:super not :SubPropertyOf)
- omn is wrong anyway
Some new "convenience" frames
And sub meaning ontologies can be built bottom up or Top-down.
Easy creation of new entities

(defclass B
  :super A
  :label "B")

Unprogrammatic Syntax

Other Differences from OMN:
- Two Comment syntaxes
- Explicit creation of new entities
- Define before use optional
Same syntax for patterns
GCI fully supported
The parser works

Evaluative

Tawny-OWL is "evaluative"
Add new classes, new properties, new frames on-the-fly
Redefine patterns
Add new tests, and rerun
There is no compile cycle

Compiled

There is a compile cycle
But you won’t notice it
Except that Tawny is performant
Tawnyized version of GO loads ~1 min.

Broadcasting

An idea borrowed from R
R is very flexible with numbers and lists
Add number to list, adds the number of every element of the list

> c(1,2,3) + 4
[1] 5 6 7

Broadcasting

Tawny-OWL does something similar

(defoproperty r)
(defclass C
  :super (owl-some r A B))

C some r A
C some r B

Class: o:C
    SubClassOf:
        o:r some o:B,
        o:r some o:A

Patternized

Tawny-OWL allows patterns
Broadcasting works naturally with patterns
some-only the most common

(defclass D
  :super (some-only r A B))

Expands into three (or n+2) axioms

Class: o:D

    SubClassOf:
        o:r some o:A,
        o:r some o:B,
        o:r only
            (o:A or o:B)

Single syntax Extensible

Tawny-OWL is implemented in Clojure
Tawny-OWL patterns are implemented in Clojure
Tawny-OWL Ontologies are written in Clojure
Therefore, adding new patterns is trivial
Here we introduce two new patterns and use them

(defn and-not [a b]
  (owl-and a (owl-not b)))

(defn some-and-not [r a b]
  (owl-some r (and-not a b)))

(defclass E
  :super (some-and-not r A B))

Which gives

Class: o:E
    SubClassOf:
        o:r some
            (o:A or (not (o:B)))

Reasoned Over

Tawny fully supports reasoning
In this case using hermit
Based on all the examples given so far, F has three subclasses

(defclass F
   :equivalent (owl-some r (owl-or A B)))

;; #{}
(subclasses F)

(reasoner-factory :hermit)

;; #{C D E}
(isubclasses F)

Commodity Language

Built on Commodity Language
Full access to all APIs
- Serialisation
- Spreadsheet reading
- Database access
- Networking
- Logic Programming
- Test Library
- Statistics and Plotting
- Benchmarking

Commodity Toolchain

Editing
- IDEs: Eclipse, IntelliJ, Netbeans
- Power Editors: Emacs, Vim, Sublime
- Web Editors: Catnip, GorrilaRepl
- Novel: LightTable
Version Control: Any
Build and Dependency
- Lein, Maven or Boot
Testing
- Travis-CI, or any CI environment
Linters, Rewriters, Remote Evaluation (nREPL)

Tawny Tutorial

The source for these slides
All the sample code
And an empty workspace
git clone https://github.com/phillord/tawny-tutorial.git
Or download https://github.com/phillord/tawny-tutorial/releases

Other Technical Pre-Requisites

JVM
Leiningen
https://github.com/phillord/tawny-tutorial
Protege

Installing JVM

You will need Java 1.7 or upward
1.8 or upward is recommended
https://java.com/en/download/
Or use your OS package manager
You need JDK, not just Java

Installing Leiningen

This is a Clojure build tool
http://leiningen.org/
Download the shell script (Linux,Mac) and run it!
Or your package manager (leiningen 2 — lein 1 will not work)
For Windows, the installer works
http://leiningen-win-installer.djpowell.net/
Or you can download the batch file and setup manually

Testing the Pre-Requisities

In the terminal/cmd, in tawny-tutorial directory

lein run

There will be a long download period then:

The Tawny Tutorial is Installed and Ready

Protege

Not really a pre-requisite
One part will use it if available

http://protege.stanford.edu

Or: the alternative

Install some Clojure IDE/Environment
Emacs with CIDER is my environment of choice
Eclipse with Counter Clockwise.
VIM Fireplace
Any of the many other options
If you do this, you are on your own…
You will get a much stronger editing environment thanotherwise

Paying the Piper

Tawny-OWL has many benefits, out-of-the-box
Comes with one significant cost
Requires a working Clojure environment
And an understanding of how to use it

Clojure environments

IDEs provide a shrink-wrapped environment
But come with their own baggage

Catnip

I’ve opted for "catnip"
A light and simple Clojure editor
Useful for tutorials!

Catnip

Assuming you have followed pre-requisities launch with:

lein edit

It should print

Catnip running on http://localhost:nnnn

And with luck a web browser will pop up.

Catnip

Open the file src/lisbon/hello.clj
Save the file with Ctrl-S
This also compiles the file
Ctrl-R or click where it says lisbon.hello
Type hello

(ns lisbon.hello)

(def hello "hello world")

What have we achieved

We have defined a new namespace
Created a variable (hello)
Evaluated hello to find it’s value (prosaically "hello world")
This is the basic Clojure workflow

Task 1

Build a Hello World Ontology!

Ontological Hello World

We have a working Clojure "hello world"
Let’s build an ontological one

Ontological Hello World

For everything that follows you have:
- An empty file for trying out the examples (src/lisbon/onto_hello.clj)
- A full file with all the answers (src/lisbon/onto_hello_s.clj)
Better to copy and paste if you can!

The namespace

Clojure has a namespace mechanism
The namespace is the same as the file name
But _ in file name is - in namespace
:use makes tawny.owl namespace available

(ns lisbon.onto-hello
  (:use [tawny.owl]))

Define an Ontology

Using the defontology statement
hello is a new variable
Can be used to refer to the ontology
Becomes "default" for this namespace
All frames are optional
We see more later

(defontology hello
  :iri "http://www.w3id.org/ontolink/tutorial/hello")

Introduce a Class

Use a defclass statement
Statements are delineated with ()
Also called "form" or "sexp" (s-expression)
Hello is also a variable
Hello and hello are different
Cannot use the same name twice
We use the "default" ontology

(defclass Hello)

Properties

Properties use defoproperty
o to distinguish annotation and datatype property
Both defclass and defoproperty take a number of frames
All are optional

(defoproperty hasObject)
(defclass World)

A complex class

Now we use a frame
:super says "everything that follows is a super class"
Or, HelloWorld has a super which is Hello
http://www.russet.org.uk/blog/2985
owl-some is the existential operator
The default operator (or only) operator in many ontologies

(defclass HelloWorld
  :super Hello
  (owl-some hasObject World))

On the use of "owl" (a quick diversion)

It is owl-some rather than some.
But it is only and not owl-only
This avoids a name clash with clojure.core
Have not gone the OWL API route

(owl-some hasObject World)
(only hasObject World)

On the use of "owl"

Full list of "owl" prefixed functions is
- owl-and
- owl-or
- owl-not
- owl-some
- owl-class
- owl-import
- owl-comment
And the variables
- owl-nothing
- owl-thing

On the use of "owl"

There are also some "short-cuts"
- &&, || and !
A "long-cuts" (owl-only)
And consistent but clashing names in tawny.english.

Save the Ontology

Either add this form to the file and Ctrl-S
Or just type into REPL (window with prompt)
Open o.omn either in Catnip, a text editor or Protege to check

(save-ontology "o.omn" :omn)

More Frames

Can add new frames to existing definition with refine
Could also just change defclass form and re-evaluate
:label and :comment add annotations using OWL built-in
:annotation is general purpose frame
We add a label in Portugese
Re-save the ontology

(refine HelloWorld
        :label "Hello World"
        :comment "Hello World is a kind of greeting directed generally at everything."
        :annotation (label "Olá mundo" "pt"))

Task 1: Conclusions

Tawny-OWL uses frames
We look like Manchester syntax
But in a lispy way
Easy to type, including short-cuts

Task 2: Defining a Tree

For the next section, we build an amino acid ontology
We do this in several ways
First, we start with a simple hierarchy

Amino Acids

Chemical Molecules
Central Carbon, with an amino and acid group
And a "side chain" or "R" group which defines the differences
Have a number of chemical properties
There are 20

A namespace

You can should create your ontology in the file lisbon/amino_acid_tree.clj
The full code in these slides can be found in lisbon/amino_acid_tree_s.clj

(ns lisbon.amino-acid-tree
  (:use [tawny.owl]))

Tree

So, we define our (flat) tree

(defontology aa)

(defclass AminoAcid)

(defclass Alanine
          :super AminoAcid)

(defclass Arginine
          :super AminoAcid)

(defclass Asparagine
          :super AminoAcid)

;; and the rest...

Disjoint

Let’s make everything disjoint
Asparagine is not the same as Alanine or Arginine
With three amino-acids, this is painful and error-prone
With twenty it would untenable

(defclass Alanine
    :super AminoAcid
    :disjoint Arginine Asparagine)

Disjoint

But there is a more serious problem
Change Arginine to this
This will now crash (probably)

(defclass Arginine
    :super AminoAcid
    :disjoint Alanine Asparagine)

Explict Definition

Tawny uses explicit definition
Variables must be defined before use
This is deliberate!
Can be avoided by using Strings
But that is error-prone

Simplifying the definition

We can use the as-subclasses form
Adds AminoAcid as super to all arguments
This syntax also protects against future additions.

(defclass AminoAcid)

(as-subclasses
  AminoAcid

  (defclass Alanine)
  (defclass Arginine)
  (defclass Asparagine)
  ;; and the rest...
  )

And disjoint!

This simplifies the disjoint behaviour also
We add :disjoint keyword

(defclass AminoAcid)

(as-subclasses
 AminoAcid
 :disjoint

 (defclass Alanine)

 (defclass Arginine)

 (defclass Asparagine)

 ;; and the rest...
 )

And, finally, covering

We might also want to say
These are the only amino-acids there are
To do this we use a "covering" axiom
Interesting ontology! Biologically true, chemically not.

And, finally, covering

This is also easy to implement
Here with all the amino-acids in full
Again, the source code grouping is useful!

(defclass AminoAcid)

(as-subclasses
 AminoAcid
 :disjoint :cover

 (defclass Alanine)
 (defclass Arginine)
 (defclass Asparagine)
 (defclass Aspartate)
 (defclass Cysteine)
 (defclass Glutamate)
 (defclass Glutamine)
 (defclass Glycine)
 (defclass Histidine)
 (defclass Isoleucine)
 (defclass Leucine)
 (defclass Lysine)
 (defclass Methionine)
 (defclass Phenylalanine)
 (defclass Proline)
 (defclass Serine)
 (defclass Threonine)
 (defclass Tryptophan)
 (defclass Tyrosine)
 (defclass Valine))

And, finally, covering

And, here is a subset of the equivalent OMN

Class: aa:AminoAcid
    EquivalentTo:
        aa:Alanine or aa:Arginine or aa:Asparagine
        or aa:Aspartate or aa:Cysteine or aa:Glutamate
        or aa:Glutamine or aa:Glycine or aa:Histidine
        or aa:Isoleucine or aa:Leucine or aa:Lysine
        or aa:Methionine or aa:Phenylalanine or aa:Proline
        or aa:Serine or aa:Threonine or aa:Tryptophan
        or aa:Tyrosine or aa:Valine

DisjointClasses:
    aa:Alanine, aa:Arginine, aa:Asparagine, aa:Aspartate,
    aa:Cysteine, aa:Glutamate, aa:Glutamine, aa:Glycine,
    aa:Histidine, aa:Isoleucine, aa:Leucine, aa:Lysine,
    aa:Methionine, aa:Phenylalanine, aa:Proline, aa:Serine,
    aa:Threonine, aa:Tryptophan, aa:Tyrosine, aa:Valine

Task 2: Conclusions

It is easy to build simple hierarchies
We can group parts of the tree
There is support for disjoints
There is support for covering axioms

Task 3 — Defining some properties

A List of amino acids only gets us so far
Now we define some properties
First, we do this the long-hand way.

Namespace

By now you shold be familiar with the name space definition
It is different.
The :use clause means "use both tawny.owl and tawny.pattern".

(ns lisbon.amino-acid-props
  (:use [tawny owl pattern]))

Starting our ontology

As before, we define (yet another!) amino acid ontology

(defontology aa)

(defclass AminoAcid)

Amino Acid properties

Amino Acids have many properties
Most of these are continuous
Hard to model Ontologically

The Value Paritition

We introduce the "value partition"
We split a continous range up into discrete chunks
Like the colours of the rainbow
First we define the partition itself
AminoAcid’s have a size, and only one size!

(defclass Size)
(defoproperty hasSize
  :domain AminoAcid
  :range Size
  :characteristic :functional)

Value Partition

Now we define the values
Three values, and only three values
All of which are different

(as-subclasses
 Size
 :disjoint :cover

 (defclass Tiny)
 (defclass Small)
 (defclass Large))

Using the values

We can now create our amino-acids using these three sizes.
We only create three amino-acids here
More would be needed.


(as-subclasses
 AminoAcid
 :disjoint :cover

 (defclass Alanine
   :super (owl-some hasSize Tiny))

 (defclass Arginine
   :super (owl-some hasSize Large))

 (defclass Asparagine
   :super (owl-some hasSize Small)))

Using Facets

Many classes are associated with properties
Call these "facets" after "facetted classification".
Value Partition is a good example
Define Charge using the same pattern as Size.

(defclass Charge)
(defoproperty hasCharge
  :domain AminoAcid
  :range Charge
  :characteristic :functional)

(as-subclasses
 Charge
 :disjoint :cover

 (defclass Positive)
 (defclass Neutral)
 (defclass Negative))

Facet

Now define the values as facet of hasCharge
facets are extra-logical
They do not change the semantics of ontology statements
They are visible in the ontology

(as-facet
 hasCharge

 Positive Neutral Negative)

Using the facet

Can now give just the class
Again, using refine although could just alter the code
(facet Neutral) rather than (owl-some hasCharge Neutral)
Saves some typing


(refine Alanine
        :super (facet Neutral))

(refine Arginine
         :super (facet Positive))

(refine Asparagine
        :super (facet Neutral))

And others

Does not save that much typing
Let’s add Hydrophobicity

(defclass Hydrophobicity)
(defoproperty hasHydrophobicity
  :domain AminoAcid
  :range Hydrophobicity
  :characteristic :functional)

(as-subclasses
 Hydrophobicity
 :disjoint :cover

 (defclass Hydrophobic)
 (defclass Hydrophilic))

(as-facet
 hasHydrophobicity

 Hydrophilic Hydrophobic)

Using Facets

And Polarity.

(defclass Polarity)
(defoproperty hasPolarity)

(as-subclasses
 Polarity
 :disjoint :cover

 (defclass Polar)
 (defclass NonPolar))

(as-facet
 hasPolarity

 Polar NonPolar)

Using Facets

facet broadcasts
We can apply two at once
A different property can be used for each
We could do all four value partitions at once!

(refine
 Alanine
 :super (facet Hydrophobic NonPolar))

(refine
 Arginine
 :super (facet Hydrophilic Polar))

(refine
 Asparagine
 :super (facet Hydrophilic Polar))

Using Facets

And the output.

Class: aa:Alanine

    SubClassOf:
        aa:hasCharge some aa:Neutral,
        aa:AminoAcid,
        aa:hasSize some aa:Tiny,
        aa:hasHydrophobicity some aa:Hydrophobic,
        aa:hasPolarity some aa:NonPolar

Task 3: Conclusions

Can use value partitions to split up numerical ranges
Can define facets to ease the use of object properties
Can apply several facets at once

Task 4 Patternising

Make full use of an existing pattern from Tawny

Patternising

We still have a lot of typing
The value partition has lots of bits
Easy to get wrong (Polarity was wrong)
Tawny supports this pattern directly

Namespace

The value partition pattern is found in tawny.pattern
We use it here

(ns lisbon.amino-acid-pattern
  (:use [tawny owl pattern]))

And the preamble

This is the same as before

(defontology aa)

(defclass AminoAcid)

The size value partition

This is a new form
Syntactically similar to what we seen before
defpartition defines that we will have a partition
[Tiny Small Large] are the values
hasSize is implicit — it will be created

(defpartition Size
  [Tiny Small Large]
  :domain AminoAcid)

The size value partition

And (some of) the OMN.

ObjectProperty: aa:hasSize
    Domain:
        aa:AminoAcid

    Range:
        aa:Size

    Characteristics:
        Functional


Class: aa:Size
    EquivalentTo:
        aa:Large or aa:Small or aa:Tiny

More value partitions

Adding partitions for all the properties is easy.

(defpartition Charge
  [Positive Neutral Negative]
  :domain AminoAcid)

(defpartition Hydrophobicity
  [Hydrophobic Hydrophilic]
  :domain AminoAcid)

(defpartition Polarity
  [Polar NonPolar]
  :domain AminoAcid)

(defpartition SideChainStructure
  [Aromatic Aliphatic]
  :domain AminoAcid)

Using these partitions

defpartition also applies the as-facet function
So, we can use facet also
Syntactically, the ontology has simplfied
Same semantics underneath

(as-subclasses
 AminoAcid

 (defclass Alanine
   :super (facet Neutral Hydrophobic NonPolar Aliphatic Tiny))

 (defclass Arginine
   :super (facet Positive Hydrophilic Polar Aliphatic Large))

 (defclass Asparagine
   :super (facet Neutral Hydrophilic Polar Aliphatic Small))

 (defclass Aspartate
   :super (facet Negative Hydrophilic Polar Aliphatic Small))

 ;; and the rest
 )

Task 4: Patternising

Tawny directly supports the value partition
This integrates with facets
Together can simply this (very common!) form of ontology

Task 5: Understanding Names

Understand how tawny uses three namespaces
See how to use them independently
Understand how they allow OBO ID support

Background

Ontology Entities need names
Tawny has different requirements for names
But we need to support alternative workflows
So, Tawny is flexible
With "sensible" defaults

OWL

Tawny is build on the OWL API
Underneath, therefore, it is part of the web
OWL uses IRIs (i.e. URIs or URLs)
IRIs provide a single, shared global namespace
With a (social) mechanism for uniqueness

Symbols

Tawny uses symbols to identify entities
Easy to type (A rather than "A")
Provides define-before-use semantics
Comes directly from Clojure
Supported in the IDEs

Namespace

We will use tawny.obo later to show numeric IDs
clojure.string is for string manipulation.

(ns lisbon.whats-in-a-name
  (:use [tawny owl obo])
  (:require [clojure.string :as s))

Symbols and IRIs

What is the relationship between symbols and IRIs?
In tawny, this is a per-ontology setting
We use the :ontology frame
By default the symbol forms the fragment of the IRI

(defontology o)

;; => #<OWLClassImpl <8d9d3120-d374-4ffb-99d8-ffd93a7d5fdd#o#A>>
(defclass A
  :ontology o)

Symbols and IRIs

We should identify our ontologies correctly
We use the :iri frame for our second ontology
Again, the class uses the symbol name as the fragment

(defontology i
   :iri "http://www.w3id.org/ontolink/example/i")

;; => #<OWLClassImpl <http://www.w3id.org/ontolink/example/i#B>>
(defclass B
  :ontology i)

Symbols and IRIs

The relationship is programmatically defined
We can change it to what ever we want
Using the :iri-gen frame to supply a function
Here we reverse the symbol name
We call the symbol name: "the tawny name"

(defontology r
  :iri "http://www.w3id.org/ontolink/example/r"
  :iri-gen (fn [ont name]
             (iri (str (as-iri ont)
                       "#"
                       (s/reverse name)))))

;; => #<OWLClassImpl <http://www.w3id.org/ontolink/example/r#EDC>>
(defclass CDE
  :ontology r)

The iri-gen function

(fn [ont name]          ;; <1>
  (iri                  ;; <2>
   (str                 ;; <3>
    (as-iri ont)        ;; <4>
    "#"                 ;; <5>
    (s/reverse name)))) ;; <6>

This is the first function we have seen so, we go through it in detail

Create an anonymous function, with parameters ont and name
Create an IRI object from the string
Concatentate all arguments
Get the Ontology IRI
"#"
Reverse the name passed in!

OBO identifiers

OBO identifiers present a challenge
Source code is the ultimate in WYSIWYG

(defclass GO:00004324
  :super (owl-some RO:0000013 GO:00003143)
  :annotation (annotation IAO:0504303 "Transporters are..."))

OBO Identifiers

Tawny provides an OBO style ID iri-gen function.
We set that here

(defontology obo
  :iri "http://www.w3id.org/ontolink/example/obo"
  :iri-gen tawny.obo/obo-iri-generate)

Will explain this bit later!

(tawny.obo/obo-restore-iri obo "./src/lisbon/whats_in_a_name.edn")

OBO Identifiers

Now we can eval these forms
Each gets a numeric identifier, OBO style
The identifier is stable

;; => #<OWLClassImpl <http://purl.obolibrary.org/obo/EXAM_000003>>
(defclass F
  :ontology obo)

;; => #<OWLClassImpl <http://purl.obolibrary.org/obo/EXAM_000002>>
(defclass G
  :ontology obo)

;; => #<OWLObjectPropertyImpl <http://purl.obolibrary.org/obo/EXAM_000001>>
(defoproperty ro
  :ontology obo)

OBO Identifiers

This one does not!

;; => #<OWLClassImpl <http://purl.org/ontolink/preiri/#4b463bc1-414b-4730-89a3-7ff72902c744>>
(defclass H
  :ontology obo)

How OBO Identifiers work

The mapping is stored in a file
The obo-restore-iri line above reads this file
If a symbol has no mapping, we use the "pre-iri" form.

How OBO Identifiers work

The mapping file is generated
Human readable, and line-orientated
Deterministically ordered
Will version!
Uses EDN format.

("ro"
 "http://purl.obolibrary.org/obo/EXAM_000001"
 "G"
 "http://purl.obolibrary.org/obo/EXAM_000002"
 "F"
 "http://purl.obolibrary.org/obo/EXAM_000003")

How OBO identifiers

Stable pre-iri’s
No need for a server such as URIgen

;; this stores any new IDs we have created
(comment
  (tawny.obo/obo-store-iri obo "./src/lisbon/whats_in_a_name.edn"))

How OBO Identifers work

How to create permanent IDs
Needs to be co-ordinated, since IDs are incremental
Use version-control to co-ordinate
One person, or as part of a release process

;; this coins permanent IDS, in a controlled process!
(comment
  (tawny.obo/obo-generate-permanent-iri
   "./src/lisbon/whats_in_a_name.edn"
   "http://purl.obolibrary.org/obo/EXAM_"))

How OBO Identifiers work

I think having no server is nice
Reusing version control makes sense
It’s programmatic! You are free to disagree.

Tawny Names

It is possible not to use symbols
The iri-gen function takes a string not a symbol!
This string is the tawny name
Consider the following

;; String building!
(defontology s)

(owl-class "J" :ontology s)
(object-property "r" :ontology s)
(owl-class "K"
           :ontology s
           :super (owl-some "r" "J"))

Tawny Name

These forms do NOT define symbols
This WILL NOT work
Neither r nor J have been defined

(comment
  (owl-class "L"
             :ontology s
             :super (owl-some r J)))

Tawny Name

Danger!
Consider this statement.
But we did not define "L"
But we have used it.

(owl-class "M"
           :ontology s
           :super "L")

And so, it becomes defined

Class: s:M
    SubClassOf:
        s:L

Class: s:L

Why use strings?

Partly, there for implementation
But made public as string manipulation is easier
Most useful for development

Summary

The relationships are summarized as follows
We will look at the arrow on the right next!

Task 5: Conclusions

There are three namespaces in use
- tawny-name
- clojure symbols
- IRIs
The relationship between the three is fluid
Generally, just use symbols!

Task 6: Importing Other Ontologies

Understand how to import and use another tawny ontology

Importing

Many Ontologies import other ontologies
Allows cross-linking, and resuse of work
Tawny supports this also

J’accuse reuse

Now I will rant!
Is a belief that reuse is automatically good
You should always use terms from another ontology
I disagree! Consequences are serious!
Duplicate, Duplicate, Duplicate
After you’ve used five or six terms, then consider refactoring
Now I will stop ranting!

An ontology to import

However, reuse is inevitable
And sometimes good
So, how do we do it.
In tawny, there are two steps, use and import

(ns lisbon.abc
  (:use [tawny.owl]))

(defontology abc
  :iri "http://www.w3id.org/ontolink/example/abc.owl")

(defclass A)
(defclass B)
(defclass C)

Using this ontology

Using

We have seen use many times before
A namespace with an ontology can be use'd like any other
Here we use require
Helps to avoid name collisons

(ns lisbon.use-abc
  (:use [tawny.owl])
  (:require [lisbon.abc]))

Using

Normally, using is not enough
We also need to explicitly import the ontology
Only after import will its axioms become available
Warning! Clojure has an import function and it does not do the same thing.

(defontology useabc)

(owl-import lisbon.abc/abc)

Using

Of course, we can also use IRIs direct from the imported ontology
For which we need to use the iri function.
This works with any ontology

(defclass MyA
  :super (iri "http://www.w3id.org/ontolink/example/abc.owl#A"))

Using

The require statement also allows us to use symbols
Here, we use an explicit name space lisbon.abc
And a symbol B.

(defclass MyB
  :super lisbon.abc/B)

Using

The final output is the same in both cases
The symbolic approach (as always) protects against spelling mistakes!

Class: useabc:MyA
    SubClassOf:
        abc:A

Class: useabc:MyB
    SubClassOf:
        abc:B

Task 6: Summary

require or use is a part of Clojure
Gives us access to symbols from another namespace
Ontologies still need to use owl-import

Task 7: Reading an Ontology

Understand what reading an ontology achieves
Use a simple example

The problem

In the previous example, abc.owl was developed in Tawny-OWL
We need the Tawny-OWL source code for this to work
What if we do not have it?
Or, worse, what if it does not exist?

Namespace

As usual, we define a namespace for our experiments!

(ns lisbon.read-abc-s
  (:use [tawny.owl])
  (:require [tawny.read]))

Solution 1

We could owl-import a IRI
And refer to all entities by IRI
Painful
Error prone
And with OBO identifiers, untenable

Solution 2

Tawny-OWL provides a solution called reading
Reading makes all entities available as symbols
In this case, a file abcother.owl has been saved locally
Can read from any URL.

(tawny.read/defread abc
  :iri "http://www.w3id.org/ontolink/example/abcother.owl"
  :location (tawny.owl/iri (clojure.java.io/resource "abcother.owl")))

Reading

Now we define our new ontology and import ABC

(defontology myABC)

(owl-import abc)

Reading

And access it’s value by symbol
Symbols must be defined.

(defclass MyA
  :super A)

(defclass MyB
  :super B)

Task 7: Conclusion

Tawny-OWL supports a read mechanism
Ontologies only available as OWL files can be used transparently

Task 8: Programming an Autosave

Extend Tawny, so that it saves the ontology on every change

Extending Tawny

Tawny is implemented directly in Clojure
We can extend in the same syntax
Can extend in general and ontology specific ways

Namespace

The namespace definition here is a bit different
Require tawny.owl through an alias
Also import an OWL API interfaces

(ns lisbon.autosave
  (:require [tawny.owl :as o])
  (:import [org.semanticweb.owlapi.model.OWLOntologyChangeListener]))

Saving the Listener

We need a variable in which to save our listener
Clojure variables are immutable
Stores a atom and change that

(def auto-save-listener
  "The current listener for handling auto-saves or nil." (atom nil))

The auto-save function

OWL API has an listener for ontology changes
We address it directly here.

(defn auto-save
  "Autosave the current ontology everytime any change happens."
  ([o filename format]
   (let [listener (proxy [org.semanticweb.owlapi.model.OWLOntologyChangeListener]
               []
             (ontologiesChanged[l]
               (o/save-ontology o filename format)))]
     (reset! auto-save-listener listener)
     (.addOntologyChangeListener
      (o/owl-ontology-manager) listener)
     listener)))

auto-save in detail

Instantiate an object which implements OWLOntologyChangeListener
Implement a single method of this
Just save the ontology
proxy is a closure
o, filename, format are closed over

(proxy [org.semanticweb.owlapi.model.OWLOntologyChangeListener]
       []
   (ontologiesChanged[l]
      (o/save-ontology o filename format)))

auto-save in detail

save the listener
discarding any existing one!

   (reset! auto-save-listener listener)

auto-save in detail

The o/owl-ontology-manager function returns an OWLOntologyManager
Clojure uses the . syntax to call methods
So, call addOntologyChangeListener on the manager
With listener as an argument

(.addOntologyChangeListener
     (o/owl-ontology-manager) listener)

Remove the auto-save

And a function to reverse the process
@ dereferences the atom

(defn auto-save-off
  "Stop autosaving ontologies."
  []
  (when @auto-save-listener
    (.removeOntologyChangeListener
     (o/owl-ontology-manager)
     @auto-save-listener)))

auto-save

There is already an auto-save function in tawny.repl
And an on-change function

Task 8: Conclusion

Clojure provides easy interop with Java
We can use this to extend Tawny-OWL capabilities

Task 9: Create New Syntax

Create new syntax describing the amino-acids
Create some defined defined classes
Create all the defined classes
Use the reasoner

The Finale

This is rather more advanced
But pulls together most of the strands
Demonstrates the value of a programmatic environment
Possible to build ontologies without this.
Sometimes only lambda is enough!
The biology is quite cute also

The namespace

Lots of namespaces involved here
Tawny-OWL does have more namespaces
But not many

(ns lisbon.amino-acid-build
  (:use [tawny owl pattern reasoner util]))

The Upper Ontology

Nothing new here!

(defontology aabuild)

(defclass AminoAcid)

(defclass PhysicoChemicalProperty)

(defpartition Size
  [Tiny Small Large]
  :domain AminoAcid
  :super PhysicoChemicalProperty)

(defpartition Charge
  [Positive Neutral Negative]
  :domain AminoAcid
  :super PhysicoChemicalProperty)

(defpartition Hydrophobicity
  [Hydrophobic Hydrophilic]
  :domain AminoAcid
  :super PhysicoChemicalProperty)

(defpartition Polarity
  [Polar NonPolar]
  :domain AminoAcid
  :super PhysicoChemicalProperty)

(defpartition SideChainStructure
  [Aromatic Aliphatic]
  :domain AminoAcid
  :super PhysicoChemicalProperty)

Defining our AminoAcids

Done this before
It involves too much typing
Want new syntax
Also to help ensure consistency

Defining out AminoAcid

The function is relatively easy
defdontfn gives default ontology handling
& properties is variadic or "one or more args".
owl-class function does NOT define a new variable

(defdontfn amino-acid [o entity & properties]
  (owl-class o entity
     :super
     (facet properties)))

Making a new variable

If we want to create a new symbol tawny provides defentity
It does a few other things as well

(defentity defaminoacid
  "Defines a new amino acid."
  'amino-acid)

Define Lots of Amino Acids

Lets define all the amino-acids at once
Pass definitions as a list (of lists)
Call using map
The anonymous function destructures
->Named packages name and entity together

(defdontfn amino-acids [o & definitions]
  (map
   (fn [[entity & properties]]
     ;; need the "Named" constructor here
     (->Named entity
              (amino-acid o entity properties)))
   definitions))

And make variables

We want to use symbols and define a new variable.
Tawny has some support for this
Not going to explain in detail

(defmacro defaminoacids
  [& definitions]
  `(tawny.pattern/intern-owl-entities
    (apply amino-acids
     (tawny.util/name-tree ~definitions))))

Define the amino-acids

Now we can define all the amino-acids in one go.
The syntactic regularity means we are unlikely to miss something.
For me, this makes the effort worth while.
We also define subclasses, disjoints and covering.
Pay attention to the :cover

(as-subclasses
 AminoAcid
 :disjoint :cover

 (defaminoacids
   [Alanine        Neutral  Hydrophobic NonPolar Aliphatic Tiny]
   [Arginine       Positive Hydrophilic Polar    Aliphatic Large]
   [Asparagine     Neutral  Hydrophilic Polar    Aliphatic Small]
   [Aspartate      Negative Hydrophilic Polar    Aliphatic Small]
   [Cysteine       Neutral  Hydrophobic Polar    Aliphatic Small]
   [Glutamate      Negative Hydrophilic Polar    Aliphatic Small]
   [Glutamine      Neutral  Hydrophilic Polar    Aliphatic Large]
   [Glycine        Neutral  Hydrophobic NonPolar Aliphatic Tiny]
   [Histidine      Positive Hydrophilic Polar    Aromatic  Large]
   [Isoleucine     Neutral  Hydrophobic NonPolar Aliphatic Large]
   [Leucine        Neutral  Hydrophobic NonPolar Aliphatic Large]
   [Lysine         Positive Hydrophilic Polar    Aliphatic Large]
   [Methionine     Neutral  Hydrophobic NonPolar Aliphatic Large]
   [Phenylalanine  Neutral  Hydrophobic NonPolar Aromatic  Large]
   [Proline        Neutral  Hydrophobic NonPolar Aliphatic Small]
   [Serine         Neutral  Hydrophilic Polar    Aliphatic Tiny]
   [Threonine      Neutral  Hydrophilic Polar    Aliphatic Tiny]
   [Tryptophan     Neutral  Hydrophobic NonPolar Aromatic  Large]
   [Tyrosine       Neutral  Hydrophobic Polar    Aromatic  Large]
   [Valine         Neutral  Hydrophobic NonPolar Aliphatic Small]))

Defined Classes

Defined Classes can be reasoned over.
Anything with a Small facet is a SmallAminoAcid

(defclass SmallAminoAcid
  :equivalent (facet Small))

And some more

There are lots of these
We can combine them in many ways.

(defclass
  SmallPolarAminoAcid
  :equivalent (owl-and (facet Small Polar)))

(defclass LargeNonPolarAminoAcid
  :equivalent (owl-and (facet Large NonPolar)))

Where to stop

Where to stop
3? 10?
Why not do them all?
We are using a programmatic tool
How would we do this

A defined class function

Similar to before
This does not create variables

(defn amino-acid-def [partition-values]
  (owl-class
   (str
    (clojure.string/join
     (map
      #(.getFragment
        (.getIRI %))
      partition-values))
    "AminoAcid")
   :equivalent (owl-and (facet partition-values))))

Doing them all

"Doing them all" actually means the cartesian product
Surprisingly there is not a function for this
This is pure Clojure, not doing to describe it

(defn cart [colls]
  (if (empty? colls)
    '(())
    (for [x (first colls)
          more (cart (rest colls))]
      (cons x more))))

Doing them all

Call the amino-acid-def function on cartesian product
This creates 453 defined classes

(doall
 (map
  amino-acid-def
  ;; kill the empty list
  (rest
   (map
    #(filter identity %)
    ;; combination of all of them
    (cart
     ;; list of values for each partitions plus nil
     ;; (so we get shorter versions also!)
     (map
      #(cons nil (seq (direct-subclasses %)))
      ;; all our partitions
      (seq (direct-subclasses PhysicoChemicalProperty))))))))

Reasoning

Finally, we reason over this.
We choose to use hermit
And check consistency
This takes a second or two

(reasoner-factory :hermit)
(consistent?)

Reasoning

We can count numbers
We have reasoned many subclases of AminoAcid

(count (subclasses AminoAcid))
(count (isubclasses AminoAcid))

Reasoning

But we are not coherent!
In fact, we have many unsatisfiable classes
What is happening?

(coherent?)

(count (unsatisfiable))

Visualising

Are many ways to visualize our ontology
Saving it and opening in Protege is easiest

(save-ontology "o.owl" :owl)

Visualising

Many defined classes are equiavlent
Many are unsatifisable
Happens because there are 20 amino-acids
But 700 defined classes
Many defined classes have necessarily the same extent
Many can have no individuals (Negative and Hydrophobic)
Only happens with the covering axiom

As a query

Using defined classes as a query
Not that useful
Most of the infered subclasses are defined!

(count
 (isubclasses SmallAminoAcid))

As a query

We have a full programming language
So, we filter for only undefined classes

(count
 (filter
  #(not (.isDefined % aabuild))
  (isubclasses SmallAminoAcid)))

Conclusions

We can use highly programmatic nature of Tawny
We can generate many defined classes
To do so is useful
In this case one axiom can have a large effect
Results depend on the choices we make in the modelling

Hiatus

Hope that I have shown basic and advanced functionality
Key feature of Tawny is extensibility
Reuse of existing tooling
Would welcome feedback
Never used catnip in this sense before, glad to know if it worked for you

Questions and Answers

Remainder of tutorial will be audience driven
Welcome to take any questions
Also have set of potential questions with prepared answers
Can get full tutorial, with notes
Readable http://homepages.cs.ncl.ac.uk/phillip.lord/download/tawny/icbo_2015/
Source http://github.com/phillord/tawny-tutorial

Questions

Can I add annotations on axioms?
How does this affect ontology deployment?
How do you version your ontology?
How do you test your ontology?
How do you continously integrate your ontology?
What about advanced documentation for ontologies?
How do I collaboratively develop my ontology?
Can I internationalise my ontology?
Can I scaffolding my ontology from existing sources?
What happens if the labels of read ontologies change?
How do you convert an existing ontology to Tawny?
How fast is tawny?
Can I integrate more tightly with protege?
How does Tawny affect dependency management with ontologies?
Can I link ontologies into software?
What’s this :super? why not :subclass?

Can I add annotations on axioms?

OWL allows annotation of axioms, for provenance for example
Tawny provides a syntax for this
Annotates SubClassOf axiom between Man and Person with a comment.
http://www.russet.org.uk/blog/3028

(defclass Man
 :super
 (annotate Person
           (owl-comment "States that every man is a person")))

How does this affect ontology deployment

Potentially none — Tawny generates an OWL file
Potentially automatable
- In project source, or through leiningen plugin
Or can publish as a maven artefact
- Ontology can be downloaded as a software artefact
- Separates out ontology identifier and download location

How do you version your ontology?

Tawny-OWL uses a line-orientated syntax
You edit source code not a visualisation of an XML file
Like various OBO flat file syntaxes, it works well in git or any VCS
Leiningen supports release versioning, using Semantic Versioning

How do you test your ontology

Clojure supports one or more unit tests frameworks
We use the default (core.test) framework
Tawny-OWL provides some fixtures
Also use spreadsheet generated testing
- Paper – http://arxiv.org/abs/1505.04112
- Tawny-Karyotype – http://github.com/jaydchan/tawny-karyotype
- Plain English Summary - http://www.russet.org.uk/blog/3074

How do you continuously integrate your ontology?

We can test ontologies with standard frameworks
These can run directly from leiningen
This workflow allows the use of standard CI environment with no changes
We use github/travis-CI
Note, iff you import ontologies via URI, you may not get a repeatable build.

What about advanced documentation for Ontologies?

Tawny-OWL ontologies are readable text
It is possible to embed rich readable comments
Also can use literate programming tools
noweb, or org-mode use traditional approach
I have also developed "lentic" which integrates with editor

How do I collaborative develop by ontology?

The same was as all software
Version control for asynchronous, fork and merge with git
Collaborative chat use gerrit, or skype
Synchronous editing, try floobits, a web editor

Can I internationalise my ontology?

Can add internationalised labels

(label "Ciao" "it")

Can define internationalized function calls

(defn etichetta [l]
  (label l "it"))

Can use tawny.polyglot to use property bundles

Can I scaffold my ontology from existing source

Can "import" ontology terms from spreadsheet, XML or a database
Can work over existing source
Therefore can generate core of ontology
And expand it with manually annotated crosslinks
See paper in ICBO 2015!
http://www.russet.org.uk/blog/3076

What happens if the labels of read ontologies change

OBO ontologies use numeric IDs
These are unreadable, so we syntactically transform labels
If label changes (but ID remains the same) is a problem
Can use tawny.memorize to remember mappings
Which adds aliases to those now missing (with optional "deprecated" warnings)

How do you convert an existing ontology to Tawny

tawny.render can perform a syntactic transformation
Given OWL provides equivalent Clojure code
Used interactively to provide documentation
Can be used to port an ontology
Currently "patternising" ontology is manual
See Jennifer Warrenders PhD thesis where she did this with SIO

How Fast is Tawny

For raw, un-patternized ontology tawny takes about 2x as reading OWL/XML
Tested by rendering and load GO
About 56Mb of lisp
Loads in about 1min
Most of excess time is in parsing, (Clojure also compiles)
Patternized ontology would involve less parsing

Can I integrate more tightly with protege?

We have built a GUI shell into Protege
Can also use Protege to open a Clojure REPL via a socket
Protege then displays directly the state of Tawny
Good for demonstration
But a little flaky for normal use
Having Protege reload an OWL file easier

https://vimeo.com/79395370

How does Tawny affect dependency management with ontologies?

Clojure uses maven dependency management
We can now publish ontologies as maven artefacts
And specify dependencies, with versions, and tooling
Can publish on Maven central or Clojars (no infrastructure to maintain!)
Separates ID and download location — disobeys LOD principles
But fulfils, SLOD principles.

Can I link ontologies into software?

OWL API objects become first class entities in Clojure
Can refer to them directly
We integrated Overtone — a music generation system
Added in Tawny-OWL and the Music Ontology
We now have software that plays a tune
And provides OWL metadata about that tune
More to investigate here.

What’s this `:super`? why not `:subclass`?

Manchester syntax uses SubClassOf:
Tawny uses :super for the same purpose!
Confusing!
Manchester syntax is actually backward
In tawny, all frames are A has :frame B
In Manchester A is a SubClassOf: B
http://www.russet.org.uk/blog/2985

Conclusions

Hope the tutorial was worthwhile!
Tawny can change the way you build ontologies
Will actively support use
Always interested in future collaborations.

Acknowledgements

Jennifer Warrender, Karyotype Ontology, Tawny-OWL
Anthony Moorman, Driving use case
Ignazzio Palmizziano, OWL API Support
Matt Horridge, Protege, OWL API Support
Robert Stevens, Amino Acid Ontology

Building Ontologies with Tawny-OWL

Introduction

Today

Today

Knowledge Prerequisites

Outcomes

Secondary Outcomes

Notes on Notes

Motivation

Use Case (chromosomes)

Use Case (karyotypes)

A partonomy?

Protege

Protege

Protege

Can we do this programmatically?

Brain

The Paragon

Constraints

Karyotype Ontology

Tawny-OWL Key Features

Ontology Building Tool

Unprogrammatic Syntax

Unprogrammatic Syntax

Unprogrammatic Syntax

Unprogrammatic Syntax

Unprogrammatic Syntax

Evaluative

Compiled

Broadcasting

Broadcasting

Patternized

Single syntax Extensible

Reasoned Over

Commodity Language

Commodity Toolchain

Tawny Tutorial

Other Technical Pre-Requisites

Installing JVM

Installing Leiningen

Testing the Pre-Requisities

Protege

Or: the alternative

Paying the Piper

Clojure environments

Catnip

Catnip

Catnip

What have we achieved

Task 1

Ontological Hello World

Ontological Hello World

The namespace

Define an Ontology

Introduce a Class

Properties

A complex class

On the use of "owl" (a quick diversion)

On the use of "owl"

On the use of "owl"

Save the Ontology

More Frames

Task 1: Conclusions

Task 2: Defining a Tree

Amino Acids

A namespace

Tree

Disjoint

Disjoint

Explict Definition

Simplifying the definition

And disjoint!

And, finally, covering

And, finally, covering

And, finally, covering

Task 2: Conclusions

Task 3 — Defining some properties

Namespace

Starting our ontology

Amino Acid properties