net.sf.tweety.arg.aspic

Class AspicArgumentationTheory<T extends Invertable>

java.lang.Object

net.sf.tweety.arg.aspic.AspicArgumentationTheory<T>

Type Parameters:

T - is the type of the language that the ASPIC theory's rules range over

All Implemented Interfaces:

BeliefBase

public class AspicArgumentationTheory<T extends Invertable>
extends java.lang.Object
implements BeliefBase

Author:

Nils Geilen According to Modgil and Prakken (http://www.cs.uu.nl/groups/IS/archive/henry/ASPICtutorial.pdf) this represents an argumentation theory (AS, KB) with - AS argumentation system (e.g. inference rules) - KB knowledge base and/or a corresponding structured argumentation framework (A,C,<=) with - A set of arguments - C set of attacks - <= order on the arguments and/or a corresponding abstract argumentation framework (A, D) with - A set of arguments - D defeat relationship

Field Summary

Fields

Modifier and Type	Field and Description
private java.util.Comparator<AspicArgument<T>>	order An order over this system's arguments, needed for their defeat relation
private RuleFormulaGenerator<T>	rfgen Used to transform ASPIC inference rules into words of the language they range over
private java.util.Collection<InferenceRule<T>>	rules The inference rules this system's arguments will be created from, correesponds to an argumentation theory (AS, KB) with - AS argumentation system = rules with premises (p -> c) - KB knowledge base = rules without premises (-> c)

Constructor Summary

Constructors

Constructor and Description
AspicArgumentationTheory(RuleFormulaGenerator<T> rfgen) Constructs a new ASPIC argumentation theory

Method Summary

Modifier and Type	Method and Description
void	addAxiom(T axiom) Adds an additional axiom, i.e.
void	addOrdinaryPremise(T prem) Adds an additional ordinary, i.e.
void	addRule(InferenceRule<T> rule) Adds an additional inference rule
DungTheory	asDungTheory() This method transfers this Aspic+ theory into a Dung style srhumentation system
java.util.Collection<AspicArgument<T>>	getArguments() Expands this systems's inference rules into a tree arguments
java.util.Comparator<AspicArgument<T>>	getOrder()
java.util.Collection<InferenceRule<T>>	getRules()
Signature	getSignature() Returns the signature of the language of this knowledge base.
void	setOrder(java.util.Comparator<AspicArgument<T>> order) Sets a new order over the arguments
void	setRuleFormulaGenerator(RuleFormulaGenerator<T> rfg) Set a new generator to transform rules into words of the language they range over
java.lang.String	toString()

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Field Detail

rules

private java.util.Collection<InferenceRule<T extends Invertable>> rules

The inference rules this system's arguments will be created from, correesponds to an argumentation theory (AS, KB) with - AS argumentation system = rules with premises (p -> c) - KB knowledge base = rules without premises (-> c)

order

private java.util.Comparator<AspicArgument<T extends Invertable>> order

An order over this system's arguments, needed for their defeat relation

rfgen

private RuleFormulaGenerator<T extends Invertable> rfgen

Used to transform ASPIC inference rules into words of the language they range over

Constructor Detail

AspicArgumentationTheory

public AspicArgumentationTheory(RuleFormulaGenerator<T> rfgen)

Constructs a new ASPIC argumentation theory

Parameters:

rfgen - function to map defeasible rules to labels

Method Detail

setRuleFormulaGenerator

public void setRuleFormulaGenerator(RuleFormulaGenerator<T> rfg)

Set a new generator to transform rules into words of the language they range over

Parameters:

rfg - is the new formula generator

addRule

public void addRule(InferenceRule<T> rule)

Adds an additional inference rule

Parameters:

rule - the rule to be added

addAxiom

public void addAxiom(T axiom)

Adds an additional axiom, i.e. a strict rule without premise

Parameters:

axiom - the axiom's conclusion

addOrdinaryPremise

public void addOrdinaryPremise(T prem)

Adds an additional ordinary, i.e. a defeasible inference rule without premise

Parameters:

prem - the premise's conclusion

asDungTheory

public DungTheory asDungTheory()

This method transfers this Aspic+ theory into a Dung style srhumentation system

Returns:

a dung theory constructed out of this system's arguments and their defeat relation according to order

getArguments

public java.util.Collection<AspicArgument<T>> getArguments()

Expands this systems's inference rules into a tree arguments

Returns:

the arguments constructed from this systems's inference rules

setOrder

public void setOrder(java.util.Comparator<AspicArgument<T>> order)

Sets a new order over the arguments

Parameters:

order - the new order

getOrder

public java.util.Comparator<AspicArgument<T>> getOrder()

Returns:

the order over the systems's arguments

getRules

public java.util.Collection<InferenceRule<T>> getRules()

Returns:

the inference rules

toString

public java.lang.String toString()

Specified by:

toString in interface BeliefBase

Overrides:

toString in class java.lang.Object

getSignature

public Signature getSignature()

Description copied from interface: BeliefBase

Returns the signature of the language of this knowledge base.

Specified by:

getSignature in interface BeliefBase

Returns:

the signature of the language of this knowledge base.