El cuerpo del espectador como modificador de la realidad

As described in Section 2.7.3 the IODE system uses Knowledge Framework Lanfuage (KFL) and Extended Comon Logic Interchange Format (ECLIF). In this research, KFL was used to declare relationships, logic and types, whilst ECLIF was used to declare instances

build the queries. The following section describe the basic declarations and formats used in this research.

2.7.4.1 KFL ‘properties’ or types

The following code is an example that declares a type of person called ‘operator’:

:Use MI

:Prop Operator :Inst Type :sup Person :name "Operator"

:rem "An Operator is a Person responsible for operating or carrying out the Process."

The ‘Use’ statement declares the context for this declaration; in IODE the same term can be declared in multiple contexts, which can be explicitly called as by prefixing a term with the context. In this example when instantiating ‘Operator’ in this context it should be called as

‘MI.Operator’. If another context ‘Finance’ existed then a finance operator would be instantiated using the term ‘Finance.Operator’ which would be separate from the

‘MI.Operator’ instance in the knowledge base.

The ‘Prop’ statement introduces the property of whatever is being declared, generally using its name, as described in the ‘Name’ statement, although when the name is impractically long or has spaces in it, this property will be a condensed version. It is this declaration that is used when referring to the declaration in the future e.g. a declaration with the name ‘Group Capital Controller’ may have the property ‘GCController. The IMKS coding conventions have been followed so each word or initial of a property is capitalised.

The ‘Inst’ declares what is being instantiated, in this work the declarations are all ‘Types’. An instance of a type cannot cease to be such while it exists.

The ‘Sup’ statement declares the super-type relationship for this type. In this example

‘Operator’ has the supertype ‘Person’ i.e. an operator is a type of person. A type may have a number of super-types, but it cannot be its own supertype.

The ‘Rem’ statement declares a text based description of the declared property to allow human interpretation of its meaning.

2.7.4.2 KFL relations

Unlike UML KFL does not use ‘attributes’, instead describes entities by relating them to each other or primitive data values. The following code declares two relations called ‘higherThan’

and ‘hasOpAuthorityLevel’

:Rel higherThan :Inst BinaryRel :Inst IrreflexiveBR :Inst TransitiveBR :Sig Top Top

:Rel hasOpAuthorityLevel :Inst BinaryRel

:Sig Top OpAuthorityLevel

:name "has Operational Authority Level"

The ‘Rel’ statement declares the relation, whilst the ‘Inst’ statement declares what relationship it instantiates. The relation types used in this work were:

 Binary Relations: a relation linking two properties

 Irreflexive: the binary must have different properties for each of its arguments e.g. for the ‘higherThan’ relation, A can be higher than B or vice versa, but A cannot be higher than A.

 Transitive: If the relation applies to A and B, and B and C it can be inferred that it will also hold for A and C.

The ‘Sig’ statement declares the signature of the relation; for a binary relation this must be the two properties for which the relation can be valid. This effectively constrains the

relationship validity so it is critical that it is defined at the right level of generalisation. In the

‘higherThan’ example shown above the relation holds for any properties so the signature is declared as ‘Top-Top’ with top being the most general property. For the

‘hasOpAuthorityLevel’ example the signature shows that the relation can apply to any property, but that the other property must be an ‘OperationalAuthorityLevel’.

It was through these sections of code as listed in Appendix E that the UML diagrams in Section 6.2.1 were formalised or codified.

2.7.4.3 KFL logic

The terms and syntax used within KFL use a similar structure to ECLIF (see Sections 2.7.4.4 and 2.7.4.5), and the IODE tool itself does use ECLIF for queries. KFL uses 6 logical

operators of which 5 were used:

 Implication: following the basic ‘if – then’ form this operator uses a first argument (the antecedent) and a second (the conclusion). If the antecedent is true then the

conclusion argument will also be true. The implication statement starts with ‘=>’ and is followed by the two arguments, which look like ECLIF statements in parenthesis.

 Conjunction: this introduces the logical ‘AND’ operator to the logic. The conclusion argument is true if all the linked antecedents are true.

 Disjunction: this introduces the logical ‘OR’ operator. The conclusion argument is true if any of the antecedents are true.

 Negation: this introduces the ‘NOT’ operator. The conclusion is true if the antecedent is false.

 Existential Quantification: this introduces the ‘EXISTS’ statements. If valid instances for the terms in the antecedent can be found then the conclusion is true.

The Universal Quantification (FORALL) operator, which makes the conclusion true if the antecedent is true for all instances, was not required for this work.

This logic was used to form Inference Rules (IRs) that allow knowledge to be inferred about instances. The same logical operators were also used to form Integrity Constraints (ICs) which, if violated result in a reaction based on the strength of the IC. Two of the available four strengths were used: Soft, in which case a violation generates an error message but allows the transaction to complete, and Hard in which case a violation results in a

transaction rollback (i.e. a failure to load).

2.7.4.4 ECLIF instances

ECLIF sentences are declared in parentheses with the predicate (the property or relation) first followed by the entity the predicate applies to:

(Operator Bob) – Bob is declared as an operator (isTallerThan Bob John) – Bob is taller than John

2.7.4.5 ECLIF queries

Both KFL and ECLIF use ‘?’ to identify an unknown variable e.g. ?x. By inserting variables in to declarations or logical statements, queries can be formed:

(isTallerThan Bob ?x) – Will return all things that are taller than Bob

(and(isTallerThan Bob ?x)(Person ?x)) – Will return all things that are taller than Bob but that are also declared as being a ‘person’.