<AI> First Order logic

First-order logic (FOL) = = = First-order predicate logic

Informal definition:
The world consists of objects, i.e, things with individual ' identities '
and ' properties ' that is distinguish them from the other objects.
FOL commits to the existence of ' objects ' and ' relations ', it does not
Make an ontological commitment. (No class, Time, Events concepts)

FOL can express anything is programmable.

Formal definition:
FOL gets its name from the fact, one can quantify over objects
(The First-order entities that actually exist on the world)
Relations or functions on those objects.
In contrast, Higher-order logic allows us to quantify over relations and
functions as well as over objects.
Higher-order logics has strictly more expressive power, however, of
Which the problem is undecidable.

Syntax and Semantics:
FOL is made up by both basics: ' sentence ' and ' terms '.
Every expression is a ' sentence ', which represents a fact.
and ' terms ', which represent objects.

' Sentences ' is built by ' quantifiers ' and ' predicate symbols '.
' Terms ' is built by ' Constant symbols ', ' Variables ' and ' Function
Symbols '.

Sentence-Atomic-sentence
| Sentence connective sentence
| Quantifier Variable, ... Sentence
| ¬sentence | (sentence)
Atomic-sentence-Predicate (term, ...) | term = term//Facts
Term---Function (term, ...) | Constant | Variable//objects
Connective->⇒|? |? | ⇔
Quantifier->∀| ∃
A | Constant | X1 | John | ...
A | Variable | x | S
predicate-Before | Hascolor | Raining | ...
Function-Mother | Leftlegof | ...
Operator->λ|?

' Logical connectives ' is used to construct complex sentences.
eg. Brother (Richard, John) ^ brother (John, Richard).
' quantifier ':∀-> Universal quantifier;
∃-> existential quantifier;
∃!-> Uniquenessquantifier.
Negation relationship:∃pred () <=>¬∀¬pred ().

' Operator ':
* Lambda operator (λ):
Useful to construct complex predicates and functions from
Simpler components, or complex terms form simpler ones.
* Uniqueness Operator (?):
More convenient to has a term representing the unique object
Directly. The notation? x P (x) is commonly used.

Axioms:all the results get from First-order logic was based on axioms.
Mathematicians write axioms to capture the basic facts about a
Domain, define other concepts in terms of these basic facts,
And then use the axioms and definitions to prove theorems.

In mathematics, an independent axiom are one that cannot be
Derived from all and the other axioms. Mathematicians strive to
produce a minimal set of axioms that is all independent.

In AI, common to include redundant axioms, isn't because of what
Can is proved, but because they make proof more efficient.

The eight axioms of the domain of sets:
1. The only sets is the empty set and those made by adjoining something
to a set.
2. The empty set has a no elements adjoined into it.
3. Adjoining an element already in the set have no effect. (uniqueness)
4. The only members of a set is the elements that is were adjoined into
it.
5. A set is subset of another IFF all of the first set's members were
members of the second set.
6. The equal IFF, sets is a subset of the other.
7. An object is a member of the intersection of the sets iff it was a
member of each of the sets.
8. An object was a member of the Union of sets if and only if it is a
member of either set.

Logical Agents:
1. ' Reflex Agents '
that is only classify percepts and act accordingly.
2. ' model-based agents '
that construct a internal representation of the world and use
it to act.
3. ' goal-based agents ' (usually also model-based)
that form goals and try to achieve them.

-Model based:
Both main kinds of synchronic rules of deducing Hidden Properties:
1. ' Causal rule ' (deducing from The reason)
reflect the assumed direction of causality in the World:some
hidden property of the world causes Certa In percepts to is
generated.
2. ' Diagnostic rule ' (deducing from the result)
to infer the presence of hidden properties directly from
Percept-de rived information.

Knowledge Engineering Process
1. Identify the task (problem specification/definition)
2. Assemble the relevant knowledge (System analysis)
3. Decide on a vocabulary of predicates, function and constants (design)
4. Encode general knowledge about the domain (coding)
5. Encode a description of the specific problem instance–
Precepts/inputs to handle (coding sub-programs, I/O)
6. Pose queries to get answers (Testing & evaluation)
7. Debug the Knowledge Base (Testing & Evaluation)

<AI> First Order logic