About Ontologies
2010-06-05, last updated 2014-03-04
About Ontologies
Ontology of relations
Statements | Interpretation |
---|---|
Nonary statements (propositions) | |
true | (true) |
Humans are mortal | (humansAreMortal) |
Unary relations (predicates) | |
X exists | (exist X) |
X is heavy | (isHeavy X) |
X is green | (isGreen X) |
Binary relations (triples) | |
X equals Y | (equals X Y) |
X likes Y | (like X Y) |
X’s weight is Y | (weight X Y) |
X’s colour is Y | (colour X Y) |
Ternary relations | |
X was introduced to Y by Z | (introducedToBy X Y Z) |
X bought Y from Z | (boughtFrom X Y Z) |
X is between Y and Z | (between X Y Z) |
Higher order relations: | |
X loaned Y from Z between Q and R in exchange for S | (loanedFromBetweenFor X Y Z Q R S) |
Variable relations | |
X has friends A and B and C and … | (friends X A B C …) |
X prefers A then B then C … | (preference X A B C …) |
Higher order relations:
X loaned Y from Z between Q and R in exchange for S.
X: Person Y: Object Z: Person Q: Time R: Time S: Object
X thinks (statement)
X heard (statement)
Ontologies in programming languages
c = mul(a, b)
(q, r) = div(n, d)
(x, y) = extended_gcd(a, b)
Ontologies in formal mathematics
Ontologies in semantic web
A compromise?
Layer 1: Nodes
The entire data set consists of a set of nodes, $mathcal N$. The nodes contain a bitstring value, but have an identity separate of their value (so two different nodes can have the same bitstring).
This is everything there is to know about layer one.
Layer 2: Tuples
In layer two the value of some nodes are intepretted to represent tuples of nodes, $left(n_1, n_2, dots right)$ where $n_i in mathcal N$.
Old version:
$left( mathcal N, mathcal R right)$
Where $mathcal N$ is a set of nodes, which contain a bitstring $B(n)$.
Where $mathcal R$ is a set of relations of the form:
$left(n_1, n_2, dots right) where n_i in mathcal N$
The first object is interpreted as the kind of relation.
The second object is interpreted as the object of a relation and
That is, ordered lists of two or more nodes. This can represent a variety of statements such as:
$left(n_{statement}right)$
$left(n_{predicate}, n_{subject}right)$
$left(n_{verb}, n_{subject}, n_{object}right)$
$left(n_{property}, n_{subject}, n_{value}right)$
$left(n_{function}, n_{variable}, n_{variable}, n_{variable}, n_{variable}right)$
Node: a bitstring, can be zero to N bits long, in increments of eight. Interpretation depends on other information available, but the following encodings are recommended: DateTime, UTF-8.
Equivalence of content does not mean that the nodes are identical. The nodes have their own identity. How this identity is achieved (i.e. by an unique identification number, memory pointer or other means) is an implementation detail which should be hidden from the programmer.
Tuple: Represents a statement. It is a list of minimal two nodes, the first node represents the subject of the node, the second represents the property described to the first node. The other nodes are optional parameters to this property.
Example use cases are
(UserJoe, IsMale) or (UserJoe, Gender, Male)
(IsMale, UserJoe) or (Gender, UserJoe, Male)
(FavoriteBands, UserJoe, Beatles, RollingStones, Metallica, ACDC)
Reification
The following example defines a node wich represents the statement “Humans are mortal”:
(humansAreMortal isa statement)
(humansAreMortal verb are)
(humansAreMortal subject humans)
(humansAreMortal object mortal)
With this node defined, one can now claim that humans are mortal:
(humansAreMortal)
Which is a reification of the statement:
(are humans mortal)
Binding
The previous example can be considered as a special case of binding, where all variables are bound.
Queries
Basic queries, should be O(1):
Does (predicate, object) exist?
Does (verb, object, subject) exist?
For which value does (property, object, value) exist?
For which values (x1, x2, …) does (property, object, x1, x2, …) exist?
More advanced, maximum O(n):
For which objects does (predicate, object) exist?
For which objects does (predicate, object) exist?
The element of change/time
Change the nodes
Create node
Delete node
Replace node value
Change the relations
Create relation
Delete relation
Replace relation predicate
Replace relation subject
Change the argument
Change the argument
Add node at position
Remove node from position
Swap node positions
Revision management
Random stuff
x = n × ( n + 1 ) / 2 = x ÷ × n + n 1 2
(t1 + n 1) (t2 × n t1) (x ÷ t2 2)
(x ÷ (. × n (. + n “1”)) “2”)
Example using unicode string instead of bitstrings
""[
. "Type"[]
. "Name"[]
. "Male"[]
. "User"[]
. ""[
. Type User
. Name "Joe"[]
. Male
]
]