Default logics allow us to reason about things where there is a general case, true of almost everything, and some exceptions. We met this idea when looking at frame systems and inheritance. Elephants are almost always grey, except Clyde, who's pink. It is very tedious to represent such things in first order predicate logic - you have to specify all the exceptions in the rules, which ends up getting very complex. To avoid this special logics have been developed. There are a variety of such logics, but all (most?) based on the same idea.
Default logics allow you to write rules which refer to whether it is consistent to believe something. So we'd say that if X is an elephant and it's consistent to believe that X is grey then X is grey. This is expressed in various ways in different variants of default logic, but one is to introduce a special operator M, so that M X means ``X is consistent with everything else''. Given the following rule and facts:
X elephant(X)
M grey(X)
grey(X)
grey(clyde)
elephant(nellie)
elephant(clyde)
we would conclude that Nellie was grey
but we wouldn't conclude that Clyde was grey, as it is not
consistent with everything else (ie, grey(clyde)).
If we had a hundred elephants, about ten of which were pink (or blue, or..),
then we could write the general rule, and specify the exceptions
by adding facts like: grey(albert),
grey(edward)..
If we bought a new elephant we'd just add a new fact of this sort.
However, if we were using ordinary predicate logic we'd have to modify the
general rule itself, which might look like:
If we have more complex defaults then the advantages of using a default logic become more compelling. For example, we might want to say that elephants are generally grey, circus elephants are generally pink, but Nellie is in fact grey. Dealing with all these nested defaults and exceptions explicitly in predicate logic gets very complex.
Default logics can be used to provide a semantics for inheritance type reasoning in frame systems. However, remember that in frame systems you sometimes had to choose which parent class to inherit from - if Clyde is both a circus animal and an elephant, is he likely to be tame or not? We have the same problem in default logics. There may be alternative, inconsistent conclusions, and the logic doesn't (usually) specify which is the right one. If we have a default rule that says that circus animals are generally not grey, if it is consistent to believe that they aren't grey, then we won't know whether our circus elephant is grey or not. Different alternative sets of facts we could believe are referred to as different extensions of the knowledge base.
To see how new information may change the truth value of certain facts, assume initially we only know that Clyde is an elephant. We immediately conclude that he is grey. We are then told that he's not grey (or told some fact that allows us to deduce this). In default logic this would mean that the truth value of the fact grey(clyde) would change. Unlike in predicate logic, we can deal with an incomplete, changing knowledge base in a reasonable way.
To implement these ideas computationally people generally use reason maintenance systems, which allow you to keep a track of what facts depend on what and the different extensions are possible. These are discussed in Rich &Knight, 7.5.