Assumption-Based Argumentation (ABA) is closely related to abstract argumentation AA. In AA, arguments and attack relationships among these arguments are used to determine which argument sets can be considered 'winning' based on various semantics. In contrast, ABA derives arguments and attacks through rules within a deductive system, incorporating assumptions and their contraries. For a more elaborate introduction to ABA please refer see this Tutorial.

This page complements the theoretical research in ABA by providing an experimentation platform for the practical use of ABA. It is part of the TweetyProject collection of Java libraries for logical aspects of artificial intelligence and knowledge representation which contains implementations of various reasoners for different semantics in ABA. This page serves as documentation to these implementations and provides both a web-based interface for using these implementations and a REST API for integrating them in your own applications.

You can try out different semantics directly below by entering a knowledge base in propositional logic in the field Knowledge base. The syntax used on this page is the one of Boolean expressions in most programming languages (such as Java). Each line in the field is a separate formula and each formula can be composed using arbitrary propositions (starting with a letter or "_" and containing only letters, numbers, and "_") and the connectives "&&" (conjunction), "||" (disjunction), and "!" (negation). The operators follow the usual order of preference ("!">"&&">"||") and parentheses "(" and ")" can be used to override this order.

Once a knowledge base has been entered a set of semantics can be selected (using the button "...") and models or extensions wrt. the given knowledge base are computed using the button "Compute models". The computation can be aborted at any time by pressing the corresponding button (note that for large knowledge bases the computation of some measures can take quite some time). The request is handled on the server and the runtime of a request on the server is also shown.

If you need to integrate Assumption-Based Argumentation in your own applications you can also use this REST API directly. Communication between a client and the server is done using JSON (in UTF-8), the URL of the server is . The API supports two commands:

1. Get list of supported semantics

   Simply send a JSON of the form

   {
      "cmd": "semantics",
      "email": "<your e-mail>"
   }

   to the server. The field "email" serves as an identification of your request. I recommend to use a valid e-mail address as it can also be used if issues arise during the computation and I would like to contact you. However, if you feel uncomfortable with that you may also use any other arbitrary identification string.

   In reply to the above request the server will send you back a JSON of the form

   {
      "semantics":
       [
         {
            "id": "pr",
            "label": "Preffered",
         },
         {
            "id": "CO",
            "label": "Complete",
         },
         ...
       ]
      "reply":"semantics",
      "email":"<your e-mail>"
   }

   which lists all currently available semantics with their id.

2. Retrieve models

   Let id be the id of any semantics currently supported (see above). Then you retrieve the models for the choosen semantics wrt. some given knowledge base (the format is the same as for web-based interface above) by issuing the request

   {
      "cmd": "get_models",
      "email": "<your e-mail>",
      "kb": "<your knowledge base>",
      "kb_format": "pl or fol",
      "fol_signature": :"<your signature if format fol>",
      "semantics":"<id>",
      "timeout":"<your cutoff>",
      "unit_timeout":"<ms or sec>",
   }

   to the server. Calculating only a single extension with the "get_model" command is also possible. In response to this request the server will reply with a JSON of the form

   {
      "reply": "get_models",
      "email": "<your e-mail>",
      "kb": "<your knowledge base>",
      "kb_format": "pl or fol",
      "fol_signature": :"<your signature if format fol>",
      "semantics":"<id>",
      "answer":"<answer>",
      "time":"<0>",
      "status":"<SUCCESS, TIMEOUT or ERROR>",
      "timeout":"<your cutoff>",
      "unit_timeout":"<ms or sec>",
   

You may also want to look at scripts.js which is the JavaScript file underlying the web-based client on this page in order to see how the API is used from within JavaScript.

The source code of the server and all reasoners can be found in the TweetyProject collection of Java libraries for logical aspects of artificial intelligence and knowledge representation. More specifically, a good entry point for the server software is the package org.tweetyproject.web and for the ABA implmentations here. All source code is published under the GNU Lesser General Public License version 3.0 except when this is noted otherwise.

This page and TweetyProject is maintained by Matthias Thimm. If you are interested in participating in the development of TweetyProject or have general comments and/or questions please write an e-mail to matthias@mthimm.de.