🚀 go-pugleaf

In article <6921.26ebb2bb@abo.fi>, hvirtanen@abo.fi (Harry Virtanen) writes:
> I have recently been developing the theoretical foundations for a Fuzzy
> Prolog system, called LukLog, a connection between Lukasiewicz logic and
> logic programming.

> LukLog is however built on the following functions/connectors
> 		a'    = 1-a
> 		a^b   = max(a+b-1,0)
> 		avb   = max(a,b)
> 		a<-b  = min(1-b+a,1)

Would you care to say something about the relationship between "fuzzy" and
whichever of Lukasiewicz's logics you have in mind?

For a system without negation, Udi Shapiro had a paper in a conference
years ago on logic programming with certainty factors.  Basically, if
you have
	head <-[f]- goal1 & ... & goaln
meaning
	certainty(head) >= f(certainty(goal1), ..., certainty(goaln))
where f is monotone (details spelled out in the paper), the usual
T^w(P) fixed point approach carries over just fine.

The really exciting thing about this is that *numeric* certainties
are (a) too limited and (b) too detailed:  (b) people can never figure
out what the numbers are to be (whereas with a coarse classification
-- say four certainty levels, as used in some medical programs --
they can often manage) but (a) when strange things go happen there isn't
enough information in the numbers to figure out _why_.  Shapiro's approach
applies to *any* complete lattice used as a certainty space.  (There isn't
the least reason for fuzzy logic to be confined to numbers.  There was an
MSc thesis done at Auckland University Mathematics Department about 11
years ago that generalised fuzzy stuff to other lattices.)

After reading Shapiro's paper I started to write a paper on the
generalisation to other lattices, but someone from MIRU convinced
me that it was too trivial to be worth writing up.  (There were some
interesting details about cutoffs when you haven't got numbers, but
alas, I've forgotten how I was going to solve the problem.)

Handling negation with certainty factors in something resembling Prolog
is going to be at least as hard as handling "simple" negation; I find it
incredible that doing something like
	non G has certainty 1-X if G has certainty X
would work.  Surely you must be doing something much cleverer than that?
-- 
Heuer's Law:  Any feature is a bug unless it can be turned off.