Created on Feb. 6, 2013, 2:28 p.m. by Hevok & updated by Hevok on May 2, 2013, 5:35 p.m.

**Rules** are a set of`explicit or understood regulations`

or Principles governing conduct with a particular system.

Complicated facts can be represented with the help of Rules. Rules can be expressed in `Description Logics`

, e.g.:

```
Ax.By.hasDeathDate(x, y) ^ Person(x) ^ Date(y) -> DeadPeople(x)
```

With Rules things can be expressed that can not be expressed with standard or simple Description Logics.

Rules are always build with a simple Schema.

There is the following condition:

```
IF A ... THEN B ...
A -> B
```

If something holds than it there is an Effect.

The interpretation of a Rule depends on the Context. Considering the Rule as General Inference then one has a Premise. From the Premise one can draw a Conclusion. On the other hand if one considers it as an Hypothesis then one has Cause and Effect. One can aslo look at it as a Production Rule, where one has a condition or pre-condition that is followed by an action that has been induced by that condition.

- Interpretation of a Rule depends on Context
- General Inference:
`Premise -> Conclusion`

- General Inference:
- Hypothesis:
`Cause -> Effect`

- Production
`Condition -> Action`

In First Order Logics one has Logical Rules that are First Order Logic Implications. An Implication is equivalent to a Disjuction. With these kind of Rules one can extend ones Knowledge Base which usely is somehow static. In First Order Logic where one has an Open World there are declarative Rules and declarative Syntax. In an Open World everything that is not explicitly negated is possible.

There are also Procidural or Production Rules. These are Rules similiar to those in Programming Languages. If condition X holds then do Y or else do Z. These are usually executable machine Instructions and these Rules are Operational and the Semantics is the effect at Application time of these Rules.

A third kind of Rules are the Rules in Logic Programming as for example in expert systems like Prolog or F-Logic. There Rules are written somehow in the way of an Assignment in Proedural Programming Languages. For example the Implication can be point in the other direction, but it is read like a First Order Logic Rule. For instance one might say "A woman is a person that is not a man". So one reads the Implication simply the other way around. The olny difference to Logical Rules is that first that they are somehow semi-declarative as they are procedure elements and it is most times about a Closed World, where the Knowledge Base is completly static and what is not given as Knoweldge can be considered as its Negation.

**Logical Rules**(FOL Implication):`F -> G is equivalent with ¬F ∨ G`

- Logical extension of KB (static)
- Open World, declarative

**Procedural Rules**(e.g. Production Rules):`If X then Y else Z`

- executable machine Instructions (dynamic)
- operational (Semantics = Effect at application)

**Logic Programming Rules**(e.g. Prolog, F-Logic):`woman(X) <- person(x) AND NOT man(X)"`

- Approximation of logical Semantics with operational Aspects
- Closed World (mostly), semi-declarative

## Comment on This Data Unit