Sometimes I understand abduction, other times, not. I'm a bit of a fan of logic programming so I try to describe the three inference modes using definite clauses.

Deduction: we go from facts (positive literals) and rules (definite clauses) to facts:

  swan(alice).   white(X) ← swan(X).
  ----------------------------------
            white(alice)

(If we know that Alice is a swan, and all swans are white, we can infer that alice is white).

Induction: we go from facts and rules to new rules:

  has_feathers(X) ← bird(X).  bird(X) ← swan(X).
  ----------------------------------------------
             has_feathers(X) ← swan(X).

(If we know that all birds have feathers and all swans are birds, we can infer that all swans have feathers).

Abduction: we go from facts and rules to _goals_ (negative literals):

  white(alice).   white(X) ← swan(X).
  -----------------------------------
            swan(alice)

(If we know that Alice is white and all swans are white, we can infer that Alice is a swan).

The last inference is of course not sound, as such - Alice could be white because she's a yogurt, say. But, if we operate under the assumption that only what we can prove is true (the so-called "closed world assumption") and the only rule we have about the concept of "white" is that "all swans are white", then the reasoning step becomes sound: the only way that we know for Alice to be white is for her to be a swan.

What if we know multiple ways for an "X" to be white? For example, what if we have the rule "white(X) ← yogurt(X)"? Well then, we can make this inference also:

  white(alice).   white(X) ← yogurt(X).
  -------------------------------------
            yogurt(alice)

And now we have two contradictory hypotheses about Alice: either she's a swan, or she's a yogurt^. We can resolve the contradiction when we learn more about yogurts and swans, and Alice. For example, if we have the information that Alice has feathers, we can figure out that Alice is a swan.

The closed world assumption is the simplest way to handle uncertainty (or in any case there are no simpler methods). It is also non-monotonic, in that new facts and rules can change the truth value of facts inferred from a theory. Which is great because that way we 're not stuck with the conclusions of initial premises.

Anyway, that's my logic-programmer's model for abduction. And it may be horribly wrong at places (my model for logic programming was horribly wrong the first ten years so...).

_______________

^Correction: Actually... alice can be a swan _and_ a yogurt. swan(alice) and yogurt(alice) are not contradictory unless we have some proof that they are.