Warning:
This wiki has been archived and is now read-only.

Argumentation and Explainable Automated Decision-making

From Argumentation Community Group
Jump to: navigation, search

Introduction

A set of C# interfaces are indicated, showcasing some relationships between annotation, argumentation, and explainable automated decision-making.

Annotation

See also: https://www.w3.org/TR/annotation-model/

Here are the interfaces of IAnnotateable and IAnnotation.

Via the IServiceProvider interface, discussed below, the annotations of an IAnnotateable can be enumerated. 

public interface IAnnotateable { }
public interface IAnnotation
{
    IReadOnlyList<IAnnotateable> Target { get; }
    IReadOnlyList<ILiteral> Body { get; }

    DateTime CreationTime { get; }

    // ...
}

Argumentation

One can consider expanding upon the annotation model, above, to include a type of recursion where some annotations can be viewed as claims and can, themselves, be annotated. We can extend IAnnotateable and IAnnotation, then, into IArgueable and IArgument. 

public interface IArgueable : IAnnotateable { }
public interface IArgument : IArgueable, IAnnotation
{
    // ...
}

Natural language statements in contexts

See also: https://www.w3.org/TR/annotation-model/#selectors

IStatement could extend IArgueable, representing a portion of or segment of natural language in a context, e.g. a selected sentence from a document. 

public interface IStatement : IArgueable, ISelection
{
    // ...
}

Predicate calculus expression trees

IExpression could extend IArgueable, representing a predicate calculus expression tree. 

public interface IExpression : IArgueable
{
    string Predicate { get; }
    IReadOnlyList<IArgueable> Arguments { get; }
}

Service providers

Here is a sketch of a service provider interface. 

public interface IServiceProvider
{
    bool IsReadOnly { get; }

    IEnumerable<IAnnotation> GetAnnotations(IAnnotateable annotateable, DateTime from, DateTime to);
    IEnumerable<IArgument> GetArguments(IArgueable argueable, DateTime from, DateTime to);

    bool AddAnnotation(IAnnotateable annotateable, IAnnotation annotation);
    bool AddArgument(IArgueable argueable, IArgument argument);

    //...

    // https://en.wikipedia.org/wiki/Analytic%E2%80%93synthetic_distinction
    IArgueable IsAnalytic(IArgueable argueable);
    IArgueable IsSynthetic(IArgueable argueable);

    // https://en.wikipedia.org/wiki/A_priori_and_a_posteriori
    IArgueable IsAPriori(IArgueable argueable);
    IArgueable IsAPosteriori(IArgueable argueable);

    IArgueable IsIndeterminate(IArgueable argueable);
    IArgueable IsDeterminate(IArgueable argueable);

    IArgueable IsTrue(IArgueable argueable);
    IArgueable IsFalse(IArgueable argueable);

    // ...
}

Automated decision-making

Towards automated decision-making, one can consider an IDecisionMakingAlgorithm interface which, via its Decide() method, processes an IArgueable to return an IDecision. The IDecisionMakingAlgorithm uses an IServiceProvider to explore arguments about a claim. During the decision-making process, an IDecisionMakingAlgorithm could also ask questions about the world using an IKnowledgeBase. Such an IKnowledgeBase would, usefully, be able to provide provenance, evidence, explanation, and argumentation for its answers about the world for this data to be passed through to a resultant IDecision. 

public interface IDecisionMakingAlgorithm
{
    IDecision Decide(IArgueable input, IServiceProvider service, IKnowledgeBase world, IReadOnlyDictionary<IArgueable, IServiceProvider> assumptions);
}

Explainable artificial intelligence

Towards explainable artificial intelligence, an IDecision interface can provide the generator of, input to, decision of, and explanation of or trace of the generator's decision-making process. 

public interface IDecision
{
    IDecisionMakingAlgorithm Generator { get; }
    IArgueable Input { get; }
    IServiceProvider Service { get; }
    IKnowledgeBase World { get; }
    IReadOnlyDictionary<IArgueable, IServiceProvider> Assumptions { get; }
    bool? Value { get; }
    IWorkflow Process { get; }

    DateTime CreationTime { get; }

    // ...
}

Conclusion

A set of C# interfaces were indicated, showcasing some relationships between annotation, argumentation, and explainable automated decision-making.

Retrieved from "https://www.w3.org/community/argumentation/wiki/index.php?title=Argumentation_and_Explainable_Automated_Decision-making&oldid=610"