Log In Sign Up

Semantic Query Language for Temporal Genealogical Trees

by   Evgeniy Gryaznov, et al.

Computers play a crucial role in modern ancestry management, they are used to collect, store, analyze, sort and display genealogical data. However, current applications do not take into account the kinship structure of a natural language. In this paper we propose a new domain-specific language KISP which is based on a formalization of English kinship system, for accessing and querying traditional genealogical trees. KISP is a dynamically typed LISP-like programming language with a rich set of features, such as kinship term reduction and temporal information expression. Our solution provides a user with a coherent genealogical framework that allows for a natural navigation over any traditional family tree.


page 1

page 2

page 3

page 4


Convolutional Neural Networks over Tree Structures for Programming Language Processing

Programming language processing (similar to natural language processing)...

A Survey on Temporal Reasoning for Temporal Information Extraction from Text (Extended Abstract)

Time is deeply woven into how people perceive, and communicate about the...

XLTime: A Cross-Lingual Knowledge Transfer Framework for Temporal Expression Extraction

Temporal Expression Extraction (TEE) is essential for understanding time...

The Resh Programming Language for Multirobot Orchestration

This paper describes Resh, a new, statically typed, interpreted programm...

Teaching natural language to computers

"Natural Language," whether spoken and attended to by humans, or process...

SchenQL: A query language for bibliographic data with aggregations and domain-specific functions

Current search interfaces of digital libraries are not suitable to satis...

Scene Graph Modification Based on Natural Language Commands

Structured representations like graphs and parse trees play a crucial ro...

1 Introduction

With the advent of computers, we are able to manage genealogies of incredible size. Now, due to the progress in storage engineering, it became possible to maintain and expand existing ancestries of considerable size. But merely keeping data on physical disks is not enough. To sufficiently realize the full potential of computers in genealogy management, one should also provide means of inquiry in ancestral data.

There is another important concept to consider when working with family trees, namely, the concept of time. A genealogy can exist only in specific temporal framework that is imposed on it by the very nature of history itself. As a result, any computer representation of an ancestry that lacks this framework is exorbitantly inadequate. Therefore, its preservation is a crucial feature for any software that is aimed for effective genealogy management.

If we want to teach computers understand lineage, we need to construct some type of artificial language that will allow us to effectively navigate and query any possible family tree. But observe, that an ancestry already has its own idiosyncratic terminology and grammar, which can be successfully utilized as a natural basis for such a language. Our research is an attempt to do exactly that.

2 Related Work

Ontologies find their natural application in the context of our work. Since the original formulation of a concept, a lot of software has been developed to manage ontologies, including such systems as Protege, Inge and others. These systems have already been heavily used in the variety of different fields.

For instance, Tan Mee Ting [1] designed and implemented a genealogical ontology using Protege and evaluated its consistency with Pellet, HermiT and FACT++ reasoners. He showed that it is possible to construct a family ontology using Semantic Web [2] technologies with full capability of exchanging family history among all interested parties. However, he did not address the issue of navigating the family tree using kinship terms.

Ontological can be used to model any kind of family tree, but the problem arises when a user wants to query his relatives using kinship terms. No standard out-of-the-box ontological query language is able to articulate statements such as in our example above. Although an ontology can be tailored to do so, it is not in any way a trivial task. Maarten Marx [3] addressed this issue, but in the different area. He designed an extension for XPath, the first order node-selecting language for XML.

Catherine Lai and Steven Bird [4] described the domain of linguistic trees and discussed the expressive requirements for a query language. They presented a language that can express a wide range of queries over these trees, and showed that the language is first order complete. This language is also an extension of XPath.

Artale et al. [5] did a comprehensive survey of various temporal knowledge representation formalisms. In particular, they analysed ontological and query languages based on the linear temporal logic LTL, the multi-dimensional Halpern-Shoham interval temporal logic, as well as metric temporal logic (MTL). They noted that the W3C standard ontological languages, OWL 2 QL and OWL 2 EL, are designed to represent knowledge over a static domain, and are not well-suited for temporal data.

Modelling kinship with mathematics and programming languages, such as LISP, has been an extensive area of research. Many people committed a lot of work into the field, including Bartlema and Winkelbauer, who investigated [6] structures of a traditional family and wrote a simple program that assigns fathers to children. Their main purpose was to understand how this structure affects fertility, mortality and nuptiality rates. Although promising, small steps has been made towards designing a language to reason about kinship. Also, their program cannot express temporal information.

Another prominent attempt in modelling kinship with LISP was made [7] by Nicholas Findler, who examined various kinship structures and combined them together to create a LISP program that can perform arbitrary complex kinship queries. Although his solution is culture-independent, he did not take the full advantage of LISP as a programming language, and because of that it is impossible to express queries which are not about family interrelations. In contrast, our system does not suffer from that restriction.

More abstract, algebraic approach was taken [8] by D. W. Read, who analysed the terminology of American Kinship in terms of its mathematical properties. His algebra clearly demonstrates that a system of kin terms obeys strict rules which can be successfully ascertained by formal methods. In another article [9] he discusses how software, in the broader sense of intelligent systems, can help anthropologists understand foreign cultures.

Periclev et al. developed [10] a LISP program called KINSHIP that produces the guaranteed-simplest analyses, employing a minimum number of features and components in kin term definitions, as well as two further preference constraints that they propose in their paper, which reduce the number of multiple component models arising from alternative simplest kin term definitions conforming to one feature set. The program is used to study the morphological and phonological properties of kin terms in English and Bolgarian languages.

According to authors [8] and [10] there have been many attempts to create adequate models of kinship based on mathematics and computational systems. For instance, a prominent french mathematician Andre Weil analysed [11] the Murngin system of kinship and marriage using group theory. In particular, he showed how one can embed the nuptial rules of a particular society into the framework of permutation groups . His work was later extended by Bush [12], who proposed the concept of permutation matrices as a more effective tool for analysis. Kemeny, Snell and Thompson were [13] first to systematize the properties of prescriptive marriage systems as an integrated set of axioms. All distinct kinship structures which satisfy these axioms were systematically derived and described by White [14], whose more practical generators set the structural analysis on a more concrete basis.

Similar attempt was made by John Boyd, who also used [15] the apparatus of group theory to give a mathematical characterization of the conditions under which groups become relevant for the study of kinship. He argued that the concept of group extension and its specialization to direct and semi-direct products determine the evolutionary sequences and the coding of these kinship systems.

Ernest Gellner discusses [16], from the pure philosophical point of view, the possibility of constructing an ideal language for an arbitrary kinship structure.

However, despite remarkable progress, there is a certain doubt in the mathematical community about the applicability of such abstract approaches to the study of kinship. For example, White [14] recognized the failure of his structural analysis of societies like Purum or Murngin, which practice matrilateral cross-cousin marriage. Liu addresses [17] this problem with establishing a new mathematical method for the analysis of prescriptive marriage systems.

We also note that none of the works include the temporal element into their formalisms, which provides novelty for our research.

3 Formal Language of Kinship

The study of kin structures has its roots in the field of anthropology. Among the first foundational works was Henry Morgan’s magnum opus ”Systems of Consanguinity and Affinity of the Human Family”[18], in which he argues that all human societies share a basic set of principles for social organization along kinship111Recall that in this paper, the word ”kinship” includes relatives as well as in-laws lines, based on the principles of consanguinity (kinship by blood) and affinity (kinship by marriage).

Following Henry Morgan, we recognize two primary types of family bonds: marital (affinity) and parental (consanguinity). These bonds define nine basic kin terms: father, mother, son, daughter, husband, wife, parent, child and spouse. Observe that combining them in different ways will yield all possible kinship terms that can and do exist.

For instance, cousin is a child of a child of a parent of a parent of a particular person. Another example: mother-in-law is just a mother of a spouse.

Now let us represent a traditional Christian family tree as a special type of ontology with its’ own concepts, attributes, relations and constraints. Concepts are people in a family, their attributes are: name, birth date, birthplace, sex and relations are parental and marital bonds with a wedding date.

Together with the everything stated above, we have the following cultural constraints imposed on our genealogy:

  1. Each person can have any finite number of children.

  2. Each person can have at most two parents of different sex.

  3. Each person can have at most one spouse of different sex.

  4. A spouse cannot be a direct relative, i.e. a sibling or a parent. In other words, direct incest is prohibited.

When considering those prerequisites one should bear in mind that we deliberately focused only on rules, taboos and customs of one particular culture, namely American culture in the sense of Read [8]. Under different assumptions and in further studies, these conditions can be relaxed and revisited.

Apart from these four, here are two additional temporal constraints that express the interrelation between birth and wedding dates:

  1. No one can marry a person before he or she was born, i.e. a wedding date can only be strictly after a birth date of each spouse.

  2. A parent is born strictly before all of his (her) children.

Due to the general nature of these two constraints, they are always true in every culture and therefore can be safely assumed in our work.

Every genealogy that meets these six requirements we shall call a traditional family tree. As the name ”tree” suggests, we can indeed view this structure as a graph with its vertices as people and edges as bonds. Observe that every kinship term corresponds exactly to a path between ego and specified relative. Under such view, kin term becomes a set of instructions, telling how to get from the starting vertex A to the end vertex B. For example, consider the term mother-in-law. What is it if not precisely a directive: ”firstly, go to my spouse, then proceed to her mother”. The wonderful thing is that, due to the nature of kinship terminology, we can compose old terms together to create new, even those which do not have their own name. This simple observation shows that we can see kinship terms as paths in a family tree underpins our entire research.

Now, if we want to efficiently query a traditional family tree, we need to further investigate the mathematical features of the language of kinship terms.

Here we present our attempt to model the language of traditional American, in the sense of Read[8], kinship terminology. There are three main characteristics that define every formal language: its syntax (spelling, how words are formed), semantics (what does particular word mean) and pragmatics (how a language is used).

3.1 Syntax

We use Backus-Naur Form to designate the syntax for our formal language. Let be the set of six basic kinship terms: father, mother, son, daughter, husband, wife. Then we can express the grammar as follows:

The first operation is called concatenation, second – fork, third – inverse and the last – dual. We denote this language by .

Here are some examples of ordinary kinship terms expressed in our new language. Note that we deliberately omit superfluous parentheses and the composition sign for the sake of simplicity:

  • Parent is .

  • Child is .

  • Brother is .

  • Sibling is .

  • Uncle is .

  • Daughter-in-law is

  • Co-mother-in-law is

From these examples you can see the real power of this language – the power to express all possible kinship terms. Now the important step towards solving our main goal, developing a language for managing temporal genealogies, is to assign meaning to these words. From now on we distinguish between artificial kinship terms, i.e. well-formed terms of our formalization, and natural kin terms used in ordinary English. By referring to just terms, we mean the former, if nothing else is stated.

3.2 Semantics

Let stand for the set of all possible kin terms generated from the basis using the previously defined syntax. Let be a traditional family tree with as a set of its vertices (people) and as a set of its edges (bonds). Moreover, because is traditional, every person from the set have the following attributes:

  • A father. We will denote him as , a function that returns a set containing at most one element.

  • A mother. We will denote her by .

  • A set of his or her children: .

  • A set of his or her sons:

  • A set of his or her daughters:

  • A spouse: .

  • A husband:

  • A wife:

Due to the constraints stated in 3, result-set of , , , and can contain at most one element.

Now we are ready to introduce Denotational Semantics for . This name was chosen because it highly resembles its namesake semantics of programming languages. Note that we regard kinship terms as functions on subsets of . Each function takes and returns a specific subset of all relatives, so its type is .

We proceed by induction on the syntactic structure of . Let be an element of , then:

  1. If , then , where assigns to each basic kin term its corresponding function from the list 3.2.

  2. Term concatenation is a composition of two functions:

  3. Fork is a set-theoretic union of results of its sub-functions:

  4. Term inverse is exactly the inverse of its function:

The dual operator () is more difficult to define. We want it to mean exactly the same as the term, where the gender of each its basic sub-term is reversed, e.g. dual of ”uncle” is ”aunt”, dual of ”brother” is ”sister” and so on. Here we can use induction once again:

  1. If , then , where is a basic term of opposite sex.

  2. Dual is distributive over concatenation, i.e. dual of concatenation is a concatenation of duals:

  3. Dual is distributive over forking:

  4. Inverse commutes with dual:

Observe that we also have the distributivity of concatenation over forking. This semantics allows us to efficiently navigate any family tree.

3.3 Pragmatics

Now, when syntax and semantics has been defined, let’s discuss the applications of our new formalism.

One of the main goals in constructing our language was achieving cultural independence. That is, the language should assign a unique term to every relative in genealogy without relying on labels and kinship words from a particular society. Although we use terms such as father, daughter and husband from English for the basis of the language, we do that only for readability, since they can be easily replaced with abstract placeholders like or .

The proposed formalism finds its natural application in the field of machine translation. Languages drastically, and often even incompatibly, differ in the way they express kinship information. The correct translation of kinship terms still poses a challenge for linguists and anthropologists. For example, in Russian there is a word for a son of a brother of ones’ wife, but no corresponding term in English. With our formalism we can encode the meaning of such words and use it to provide a more adequate translation between any possible pair of natural languages.

We can also apply the formalism to the problem of cross-cousin marriage: given the description of a particular society, a genealogy of a family from that society and two individuals from it, ascertain whether the rules of their community allow them to marry. This problem is extensively studied in the field of computational anthropology. What makes it especially difficult is that each culture has its own peculiar set of regulations and laws regarding this subject. In every case, one of the important steps towards solving the problem is to research and establish a correct model of that society. With our new formalism we can facilitate this process.

4 Term Reduction

Our artificial language has a problem: its too verbose. Indeed, to encode such ubiquitous kin terms as ”uncle” or ”great-nephew” one must use quite lengthy phrases that are hard to write and read. It is therefore important to have some sort of reduction mechanism for our language that will shorten long terms into a small set of common kinship relations to help understand them.

Firstly, let us analyse the problem. We have the following mapping between and the set of English kinship terms

This dictionary allows us to effectively translate between kin terms of our artificial language and their usual English equivalents. We can also view this mapping as a regular grammar in the sense of Chomsky hierarchy[19]. However, note that we strictly prohibit mixing these two collections and therefore we deliberately avoid using words from the RHS in the LHS, because otherwise the grammar will lose its regularity and become at least context-free, making the problem even more challenging. Let us define another function on top of that will replace the first sub-term in a term :

Here the only change in meaning of is that the substitution takes place only once.

Now the task can be stated thusly: given a term find its shortest (in terms of the number of concatenations) translation under , i.e. which sub-terms need to be replaced and in what order.

This problem can be easily reduced to that of of finding the desired point in the tree of all possible substitutions. Moreover, this vertex is actually a leaf, because otherwise it is not the shortest one. But the latter can be solved by just searching for this leaf in-depth. Unfortunately, the search space grows exponentially with the number of entries in the dictionary , thus making the naive brute-force approach unfeasible.

Here we propose a heuristic greedy algorithm

1 that, although does not work for all cases, provides an expedient solution to the reduction problem in time. Firstly, it finds the longest sub-term that exists in the dictionary , then divides the term into two parts: left and right from , after that it applies itself recursively to them, and finally it concatenates all three sub-terms together.

Now let’s analyze the time complexity of this algorithm:

Theorem 1.

The execution time of the algorithm listed in 1 belongs to .


Let be the execution time of the algorithm, where stands for the number of concatenations in a kin term. First of all, observe that obeys the following recurrence:


Indeed, we make a recursive call exactly two times and each call receives roughly the half of the specified term. During execution the function passes through two nested cycles, so one call costs us .

Secondly, to solve a recurrence, we use the Master Method from the famous book Introduction to Algorithms[20] by Cormen et al. In our case , , and . Observe, that if we take to be any positive real number below one: , then .

Let us show that satisfies the regularity criterion: for some constant . Indeed, just pick :

Thus, we can use the third case from the Master Method, which tells us that . ∎

4.1 Pursuing Confluence

Current approach listed in 1 has one major disadvantage: like any other greedy algorithm it can fail to choose a correct reduction path between two terms with equal amount of concatenations. We can alleviate this by augmenting our rewriting system, based on dictionary, with a feature called confluence, also known as Church-Rosser property:

Definition 1.

An abstract term rewriting system is said to possess confluence, if, when two terms and can be yielded from , then they can be reduced to the single term . Figure 1 depicts this scenario.

Not only we can fix our reduction algorithm by introducing this property, but also we can improve the time complexity, making it linear.

Figure 1: Confluence in a term rewriting system.

One way to achieve confluence is to attach a single kinship term to any possible path in a family tree. Observe, that English kinship terms have a specific pattern that we can exploit. All relatives who are distant enough from ego have the following structure of their kin term:

In-laws also have their own pattern, where the ending ”-in-law” is appended to a valid consanguine kinship term. However, this applies only to people, who are linked together by only one nuptial bond. For instance, there is no single term for a husband of ego’s wife’s sister. These relations can be accounted for by prefixing ”-in-law” with an ordinal, which shows the number of marital bonds that one should pass in order to go to such person. Under this representation, last example will receive the term ”brother twice-in-law”. After generalizing that scheme we get a pattern that looks like this:

We can also view this as an attribution of a distinct natural number to every vertex with ego as an offset, thus imposing a natural ordering on the set of all vertices. This assignment can be made in such a way that reducing a kinship term will correspond exactly to the calculation of from some arithmetic expression like , thus providing a translation between the language of all valid arithmetic expressions and our formal language of kinship .

However, it is not the topic of this paper, so we are leaving it to the considerations of future researches.

5 Incorporating Time

Now the only matter that is left to address is an adequate representation of time. Historically, there are two main approaches for modelling time: point-based and interval-based. The former treats time as a single continuous line with distinguished points as specific events, and the latter uses segments of that line to represent time entries. The latter method was used in Allen’s interval algebra[21]. For the sake of simplicity we chose the former approach, because it can easily imitate intervals by treating them as endpoints of a line segment.

Not only we want to be able to express different events by modelling them as points on a line, but also we want to orient ourselves on that line, i.e. to know where we are, which events took place in the past and which will happen in the future. Thus, we need to select exactly one point that will stand for the present moment and we call it ”now”. Then all points to the left will be in the past, and all point to the right will be in the future. Also, notice that any set with total ordering on it will suffice, because the continuous nature of a line is redundant in point-based model. Collecting everything together, we have the following formalisation of time:

Where is a non-empty set with arbitrary elements, , and is a total ordering relation on .

Within this model we can reason about which event comes before or after, what events took place in the past or in the future, and so on.

When considering family trees it is necessary to define only five predicates:

  1. is true iff .

  2. is true iff .

  3. is true iff .

  4. is true iff .

  5. is true iff .

Those relations are the basis from which all other operations on can be defined. It is also interesting to note that, since any ordering relation generates a topology over its structure, we can speak about time in terms of its topological properties.

6 KISP Language Specification

6.1 Grammar and Lexical Structure

Since KISP is a dialect of LISP, it inherits some syntax from the predecessor, but generally it is a new programming language. The grammar is presented with the help of Bacus-Naur notational technique. For the sake of simplicity, we omit angle brackets and embolden non-terminal words. A plus, a star sign in a superscript and a question mark have the same meaning as in regular expressions.


As we can see from the definition, there are three kinds of terminals in the grammar: literals, references and atom functions, which are called simply atoms. Literals are instances of primitive types, such as Numeral, String or Boolean, or special keywords. They stands for the following: ”void” represents NULL type, ”people” – a list of all persons in a family tree, ”now” – the current time entry and ”vacant” – an empty list. References are used as definientia in ”define” terms and as names for parameters in lambda terms. It is possible for a reference to end in a question mark, which means that it denotes an instance of Boolean type. References can we written in so-called dash case, so ”long-name” and ”very-long-name” are both legal. The only exception are names which start with the dash like ”-illegal”, they are invalid.

Note that we allow niladic lambdas, so, for instance, this is a valid expression: (lambda () ’Hello, World!’). But at the same time () is not a well-formed term. We also prohibit ”define” terms inside other terms, so this would not work: (+ 2 (define three 3)). Strings are nested in single quotes. Integers, in KISP we call them ”numerals”, can start with a zero and be prefixed by a negative sign.

Here is the complete list of all keywords in KISP: true, false, define, lambda, people, now, void, if, vacant. The rule is that you can use as a reference everything you want as long as it is not a keyword, so you cannot redefine their standard behaviour, thus a programmer is unable to tamper with inner workings of the interpreter.

As in all other dialects of LISP, a term (f a b c ...) means the execution of a function with the specified arguments . Of course, we can construct and call the higher-order functions as usual: ((twice square) 2) will yield , or ((compose inc inc) 0) which just prints .

6.2 Query Examples

In this section we will demonstrate how one can use KISP to perform various queries in a genealogical tree. Particularly, we focus our attention on statements that express kinship terms.

Let’s start with a simple task of selecting people based on a certain boolean condition. Suppose we want to query only those, who have at least one child. This can be accomplished as follows:

(filter (lambda (p) (< 0 (count (children p)))) people)

Here we iterate through the list of all people in a tree and take only those, on who defined lambda predicate evaluated to true. The number of children for a particular person is calculated by counting elements of the list (children p).

The next task is to select all husbands, that is, all men who are married. This can be done in two ways: either select only males and then discard all bachelors, or combine the two operations together in a single boolean predicate using and clause:

(filter (lambda (p) (not (= void (spouse p))))
        (filter (lambda (p) (= ’MALE’ (attr p ’sex’)))
(filter (lambda (p) (and (= ’MALE’ (attr p ’sex’))
                        (not (= vacant (spouse p)))))

The advantage of the second approach is that the list people will be iterated only once.

Now to the more advanced queries; suppose that the term ego stands for the user’s node in an ancestry, and he wants to know how many cousins he has:

(define parents (lambda (p) (join (mother p) (father p))))
(define cousins
(lambda (p) (children (children (parents (parents p))))))
(- (count (cousins ego)) 1)

This is where the expressive power of KISP truly comes into play. Although cousins is not a standard KISP function, we can easily implement it using kinship framework of KISP, which successfully utilizes the structure of natural kinship terms. Moreover, notice how the function parents is expressed. Since a parent is either a mother or a father, it corresponds to the formal kinship term , which is implemented as a join of two or more lists. And because every cousin is a grand-child of one’s grandparents, it corresponds to:

The last decrement was made because in this scheme the ego itself will be included to the resulting list.

Finally, temporal queries can be expressed with the help of the type Date. For instance, if we need to know, who, among our relatives, was born during the WWII, we just need to evaluate:

(define WWII-start (date ’01.09.1939’))
(define WWII-end (date ’02.09.1945’))
(filter (lambda (p) (during (attr p ’birthdate’) WWII-start WWII-end))

The type Date provides all the necessary functions for working with temporal information.

Because KISP is Turing-complete and inherits LISP’s capabilities of meta-programming, one can easily extend it with any functionality that one wants.

7 Conclusion

In this work we designed a new programming language KISP for effectively navigating and querying temporal family trees. We described a formal mathematical model of traditional kinship, on which KISP is based. Additionally, we tackled the problem of term reduction and discussed the possibilities for achieving confluence.

There are three requirements that we want our language to satisfy:

  1. Expressiveness. The language should allow for any possible consanguine as well as affinal relations to be described.

  2. Speed. The response time must not exceed the standard for an interpreted language.

  3. Simplicity. Language should be able to express natural kinship and temporal terms as straightforward as possible.

Here the phrase ”response time” stands for the time passed between the start and finish of a programs evaluation. The last quality is what truly distinguishes our approach from the rest, allowing for the most obvious representation of genealogical and temporal information. We are certain that our presented solution fully covers every one of them.

8 Future Work

However, there are some topics yet left to tackle in the area of kinship and genealogy management. On the theoretical side, there is a problem of total term reduction and formal language enrichment. It is also interesting to shift attention to other languages and cultures with different kinship structures, such as Russian or Hawaiian. The constructed formalism can be considered from the algebraical side, focusing on its many mathematical properties as a special type of an algebraic system.

On the practical side, one can consider to improve the virtual assistant component. Besides already mentioned Voice Generation & Recognition technology, it can be made context-aware, which will increase its intelligence. Additionally, the family ontology can be enhanced to incorporate information about divorces and deaths. The performance of the interpreter can be significantly improved by introduction of Just-in-Time compilation.

Another important step towards improvement of existing system is addressing its current limitations, such as static nature of our genealogical database and execution time of KISP queries. It’s no doubt that the schema-less approach is much more versatile, because it does not depend on traditions and customs of a particular culture.

Further advancement may also include new data types and standard functions for KISP language. Specifically, it is beneficial to add a char type that represents individual characters in a string. Another useful feature is support for variadic lambdas and closures, which will significantly increase the versatility of KISP.

Moreover, one can also consider including capabilities for a logical reasoning into KISP. They will be applicable for inferring implicit time constraints for events, whose exact date is unknown. For instance, if we are uninformed about a birthday of a person, but we do know his parents and his children birthdays, we can justifiably bound this missing date to a specific time interval.


1input: kinship term .
2note:  is a dictionary of kinship terms.
3note: leftPart(t, u)” and rightPart(t, u)” return the sub-term of 
4note: from the left of sub-term  or from the right respectively.
5note: Function subterm(t, i, j)” returns the
6note: sub-term of the kinship term  between indices  and .
7output: reduced kin term.
8function shorten(t)
10    maxShortenableSubterm  empty
11    currentSubterm  empty
12    for i  0 to length(t) do
13    begin
14        for j  length(t) - i to 0 do
15        begin
16            currentSubterm  subterm(t, i, j)
17            if length(currentSubterm)  length(maxShortenableSubterm)
18                and (currentSubterm) is not empty
19            then
20                maxShortenableSubterm = currentSubterm
21        end
22    end
23    return shorten(leftPart(t, maxShortenableSubterm))
25             shorten(rightPart(t, maxShortenableSubterm))
Listing 1: Kinship Term Reduction


  • [1] T. M. Ting, “Building a family ontology to meet consistency criteria,” Master’s thesis, University of Tun Hussien, 2015.
  • [2] J. B. F. B. T. Furche and S. Schaffert, “Web and semantic web query languages a survey.”
  • [3] M. Marx, “Xcpath the first order complete xpath dialect.”
  • [4] C. Lai and S. Bird, “Querying linguistic trees,” 2009.
  • [5] A. A. R. K. A. K. V. R. F. Wolter and M. Zakharyaschev, “Ontology-mediated query answering over temporal data: A survey,” 24th International Symposium on Temporal Representation and Reasoning, vol. 1, no. 1, pp. 1–37, 2017.
  • [6] J. Bartlema and L. Winkelbauer, “Modelling kinship with lisp; a two-sex model of kin-counts,” IIASA Working Papers, vol. WP-96-069, no. 1, p. 48, 1961.
  • [7] N. V. Findler, “Automatic rule discovery for field work in antropology,” Computers and the Humanities, vol. 26, no. 1, pp. 285–292, 1992.
  • [8] D. W. Read, “An algebraic account of the american kinship terminology,” Current Antropology, vol. 25, no. 49, pp. 417–429, 1984.
  • [9] D. Read, “Computer representation of cultural constructs : New research tools for the study of kinship systems,” Computer Aplications in Anthropology, vol. 1, no. 1, pp. 228–50, 1990.
  • [10] V. Periclev and R. E. Valdes-Perez, “Automatic componental analysis of kinship semantics with a proposed structural solution to the problem of multiple models,” Anthropological Linguistics, vol. 40, no. 2, pp. 272–317, 1998.
  • [11] A. Weil, “On the algebraic study of certain types of marriage laws,” pp. 221–29, 1969.
  • [12] R. Bush, “An algebraic treatment of rules of marriage and descent,” 1963.
  • [13] J. Kemeny and L. Snell, “Mathematical models in the social sciences,” 1962.
  • [14] H. White, An anatomy of kinship.   Englewood Cliffs, 1963.
  • [15] J. Boyd, “The algebra of group kinship,” Journal of Mathematical Psychology, vol. 6, no. 1, pp. 139–67, 1972.
  • [16] E. Gellner, “Ideal language and kinship structure,” Philosophy of Science, vol. 24, no. 3, pp. 235–242, 1975.
  • [17] P. Liu, “Murngin: A mathematical review,” Current Anthropology, vol. 14, no. 1-2, pp. 2–9, 1973.
  • [18] L. H. Morgan, Systems of consanguity and affinity of the human family.   Smithsonian Institution, 1870.
  • [19] N. Chomsky, “Three models for the description of language,” IRE Transactions on Information Theory, vol. 2, no. 1, pp. 113–124, 1956.
  • [20] T. H. C. C. E. L. R. L. R. C. Stein, Introduction to Algorithms, 3rd ed.   The MIT Press, 2009.
  • [21] J. F. Allen, “Maintaining knowledge about temporal intervals,” Communications of the ACM, vol. 26, no. 11, 1983.