WorkDiary(8.10.05)

Been working on a new syntax for the system. It seems I have a choice between a classical logic based system and a tuple based system.

The logic base gives me lots of advantages, in that in comes with 'batteries included'; On the other hand, it has real limits in terms of controllability.

Tuples give me lots of fiddly detail, but don't have the standard power of logic. I could invent by own form of inference (or adapt one - possibly S.P.'s) to give me what I need.

Underlying this is the question about what we actually want ? Back to Schum & Pollock to get an overview, hopefully.

I suspect that we need typing in arguments, as there seem to real limits in what we can do with untyped predicates. For example, many would accept that if we deal with temporal predicates, only some objects sould be treated as extensional - and so I think we need to type our predicates to differentiate between them.

Forms of Argument

Have been reading the Section III of Perelman & Olbrechts - Tytecha "The New Rhetoric". Much of it is clearly beyond any formal system that I could implement, but a few exceptions stand out:

* Arguments from Part - Whole relationships: If we have such relationships in our ontology (as we will, given any real understanding of anatomy), then we may be able to form arguments by using these relationships. Perelman's examples are drawn more from organisations, but the closer ties of anatomy might let us follow these more closely

* Arguments from Transitivity: If A >B, and B > C, then A > C; if we know B --> X, and C --> Y, then can we make the argument that A --> ??

* Argument from Example: My current work is focussed around justification based on class-membership (i.e. for all X, Y --> Z); example based argument would be:
a was an instance of X; b is also an instance of X, therefore since Y applied to a, Y applies to b

Asymmentry in Argumentation

One of the real issues with Argumentation is the lack of any canonical theory for defeat. My work has so far started to look at how we construct arguments from information; the much more difficult question is how we decide whether one argument defeats another one.

As a result, since we don't always know how to determine if one argument beats another, we often end up having to to look at the number of arguments involved. We can do this just by counting (not good, but as recommended by Benjamin Franklin) or by doing something more complex, like set defeat (Dung-style, where essentially the biggest group of coherent arguments win*). In this situation, the bugbear of argumentation is symmetry: equal numbers of arguments on both sides, and since we can't determine whether one beats the other, we have deadlock.

Ways round this are to:
* Decide how one argument beats another (e.g. value-based)
* Make sure your system is asymmetric

This is where the use of ontologies becomes interesting: There is an inherent asymmentry in an ontology, in that if we have a class structure with:

a
|
------ b
|
------ c
(where b & c are subclasses of a) then an argument for b is necessarily an argument for a, whereas the opposite is not true**. This then provides us with an in built method of generating asymmetric argument frameworks: If we have an argument for b, and an argument for and against a, we derive an additional argument for a, and hence we are now asymmentric at the level of a.

The other interpretation is to include the level of subject in the argument as some form of value (similar to the idea of specificity in arguments, which has been around for a while). This has some nice properties: It stops us developing endless arguments for the top point of the ontology (such as owl:Thing), which is a fairly vacuous exercise. The problem comes in comparing specificities across different branches of an ontology - the only solution I can come up with at the moment is to normalise the metric not just over the distance from or , but over some compound such as distance(class, top)/ distance (top, bottom, this tree branch).

Either way, the asymmentry generated by the use of an ontology takes us a little closer to having something useful.


* Although it isn't normally presented like this, it holds if each argument has the same 'valency'; otherwise, the set with the greatest valency will tend to win, assuming arguments' targets for attack are distributed at random.

** This assumes that we are only dealing with class/ subclass (IS-A) relationships; if we include other useful relationships (such as partOf/ hasPart) we might see some other patterns.

The futility of utility(1)

On Woman's Hour this week, there was a story about a woman who had had Cervical cancer; one of her comments was that she 'could cope with the cancer; what I couldn't cope with was the
infertility'.

This got me thinking (again) about some of the shortcomings of Expected Utility Theory. Much of my work on argumentation has been about trying to overcome some of the shortcomings in EUT.

My fundamental objection to EUT is its insistence on examining the utility of the courses of actions; this may be a valid approach in some circumstances, but in others, it seems less so. How might we characterise these 'utility-poor' areas? I would suggest that they are, generally, areas where we have frequent changes to utility, or those where utilities cannot be easilyf shared. Such a situation has come up when we looked at options following screening for BRCA1 and BRAC2 carriage. The range of options is fairly large, but all have problems with them: the 'obvious' option, in terms of risk reduction, is bilateral mastectomy and oophorectomy - but this has clear downsides.

To follow an EUT approach, it seems we would have to elicit EUs for all the possible outcomes, and then follow the consequences - and these EUs are likely to be fairly unstable from person to person. However, the crucial problem is not this instability; rather it is how we validate these utilities: We would have to run our model, calculate the suggested options and then check them against......the original preferences, to see if we had the 'right' answer. This seems to be a dangerously circular process (avoided where we have larger groups, as we can take a more statistical approach).

Even if we can solve this problem, there still seem to be weaknesses with EUT. It can capture the sort of statement above, but what about other statements? There seem to be some holes here - not so much utility-poor as 'utility empty' areas. I'll come to these soon.

Valuation

So far, my vision has been to value outcomes of the warrant to create an argument; this is based on a 'EU' - type approach to Argumentation.

A better idea is to value all the elements in the warrant; this allows us to talk about valuing the outcome, as well as source, input, etc. The advantages of this are:

* Allows us to use the same code to work on the valuation of arguments by type, source, etc.

* Allows us to do things that EU analysis can't do (directly): We can make an argument against an action, based on both the outcome, but also the action itself.

I guess this will make it into V 0.1.1 - I'm trying to keep the code stable for now....

WorkDiary (27.10.05)

What I've been working on:

* Implementing a basic ontology - argumentation infrastructure
* Writing my first year PhD Viva document (!) (see homepage for a copy)

The code now just about runs (although like a pig-in-treacle). Haven't yet managed to get the 'derived' (i.e. superclass) arguments to work properly, and spent almost a whole day writing a computeLCA function that still doesn't work properly. The code has now also reached spaghetti point, so will spend the weekend refactoring it so that I can understand it again.

Also thinking about some more abstract argumentation stuff - see next few posts

My Work

'A PhD Thesis should comprise a substantial body of novel work'


I'm currently working on an argumentation system that integrates ontology, rules and argumentation.

Such a system isn't actually all that revolutionary, but it is the first time it's been done (hence satisfying the 'novel' requirement) and it's turning out to be a big-ish piece of work (there's the 'substantial'). It's also turning up (or beginning to) some interesting areas for the argumentation community.

As well as devising a syntax & semantics, I've also started work on implementing it. Currently, it's being written as a plugin to the Protege-OWL Ontology editor, using the Jython scripting language.

In the beginning......

Ok, well, my very first post (I wonder how many other blogs start like this ?- most of them, I guess).

Some quick Q&A:

Who: A UK-based academic

Where: See above....

What: Mostly stuff to do with argumentation (my academic area) (although note that I don't think much of the definition here; it's not wrong, so much as just not feeling quite right)

Why: Because I thought it might be fun, and also to give me a way to keep track of ideas


Subjects: Argumentation, Python, Jython, Ontologies, Semantic Web

Disambiguation

Found something here to help explain the name of the blog....