This paper presents fast and exact methods for computing the probability of an argument’s acceptance using Dung’s semantics in the Constellation paradigm of Abstract Argumentation. For (directed) Singly-Connected Graphs (SCGs), the problem can now be solved in linearithmic time instead of being exponential in the number of attacks, as reported in the literature. Moreover, in the more general case of Directed Acyclic Graphs (DAGs), we provide an algorithm whose time complexity is linearithmic in the product of the out-degree of dependent arguments, i.e., arguments reaching the argument considered for acceptance through multiple paths in the graph. We theoretically show that this complexity is lower than the lower bound of the (exact) Constellation method, which is also supported by empirical results. Our approach to DAGs is also compared with the (approximate) Monte-Carlo method, which is stopped when exact results are obtained. Within this time constraint, Monte-Carlo still outputs significant errors, underlying the fast computation of our approach.

Abstract The study of Dung-style Argumentation Frameworks in recent years has focused on incorporating time. For example, availability intervals have been added to arguments and relations, resulting in different outputs of Dung semantics over time. This paper examines the probability distribution of arguments over time intervals. Using this temporal probabilistic model, the study explores how these frameworks can be transformed into a probabilistic argumentation according to the constellation approach and how they can be interpreted within the epistemic approach. The epistemic approach relies on the notion of defeat to select significant conflicts based on probability distributions. The study also introduces the temporal acceptability of arguments based on the concept of defence, allowing for more precise results over time. Finally, the models (constellation and epistemic) are extended to account for events that have a duration, i.e. that can occur for several consecutive instants of time.

Steganography has evolved into various forms and remains an effective way to hide sensitive information. Network Steganography, also known as "Covert Channels," is popular in fields such as terrorism and security. As a result, the scientific community created a specific taxonomy to categorize it, and developed several techniques and tools to conceal communication between the parties. In this paper, we have curated a list of available software tools that can be used to create a covert channel at layers 2 to 4 of the ISO/OSI model and related to the HTTP protocol.

We propose a covert channel and its implementation in Windows OS. This storage channel uses the Initial Sequence Number of TCP to hide four characters of text, and the identification field to "sign" the message and thus understand if it has been altered during the transmission. The secret is sent in the first SYN packet to open a connection, and an ACK-RST response acknowledges the receipt. Designed error-correction codes make the protocol more robust and able to handle (IP) packet drops and transmission errors. In this paper, we provide a detailed discussion of the implementation and an evaluation of the stealthiness of the proposed channel.

The black box model used in Machine Learning is considered one of the major problems in the application of Artificial Intelligence techniques [1] as it makes machine decisions non-transparent and often incomprehensible even to experts or developers themselves.In this paper, we provide an argumentative interpretation of both the training process and the results predicted.The goal is to build a Bipolar Argumentation Framework (BAF) [2] showing the dialectical reasoning behind the assignment of a certain class to a given record.Since we make assumptions neither on the dataset nor on the algorithm used, the presented procedure can be applied to existing models without the need for further adjustments.To illustrate our proposal, we use the Titanic dataset from www.kaggle.com,which contains records relating to people involved in the Titanic disaster.We consider three categorical features, namely Survived (the class to predict, with value 1 if the person survived or 0, otherwise), Pclass (ticket class among 1, 2 and 3) and sex (0 for woman and 1 for man), and two numerical features: Age (passenger age, ranging from 0.17 to 76) and Fare (passenger fare with values from 0 to 512).In the following, we describe the step our procedure goes through in order to find an explanation for the class Survived=1.Dataset Clustering.In the first step, starting from the input dataset, we create a new clustered dataset in which numerical features are split into categories that group ranges of values to obtain a more appropriate and concise explanation. BAF Generation.Then we build a BAF based on the correlation matrix computed among the features.By construction, the obtained BAF only has symmetric relations. Breaking Complete Symmetry.Given the correlation matrix, we apply a procedure that removes symmetric edges from the BAF to establish a causal relationship between features.In particular, we use the conditional probability [3] computed for arguments which attack/support each other.We choose the minimum values possible that keep the graph connected. Computing Extensions.To identify the set of arguments which are more likely to be accepted, we compute the semi-stable extensions [4] of the previously obtained 1 This work has been partially supported by: GNCS-INdAM, CUP E55F22000270001;

The requirement of explainability is gaining more and more importance in Artificial Intelligence applications based on Machine Learning techniques, especially in those contexts where critical decisions are entrusted to software systems (think, for example, of financial and medical consultancy). In this paper, we propose an Argumentation-based methodology for explaining the results predicted by Machine Learning models. Argumentation provides frameworks that can be used to represent and analyse logical relations between pieces of information, serving as a basis for constructing human tailored rational explanations to a given problem. In particular, we use extension-based semantics to find the rationale behind a class prediction.

We present LOGistICS, a monitoring-framework with the aim to study the security of industrial PLC systems. The architecture encompasses different processing components and probes, with different tasks. In particular, this paper focuses on the description of a new medium-interaction honeypot attracting Modbus and S7comm traffic. With respect to related open-projects (e.g. Conpot), our proposal is highly extensible, configurable, and it allows for interacting more with an attacker while remaining less detectable. With LOGistICS the main objective is to study the behaviour of hosts that are interested in attacking industrial services.

We present ConArgLib, a C++ library implemented to help programmers solve some of the most important problems related to extension-based abstract Argumentation. The library is based on ConArg, which exploits Constraint Programming and, in particular, Gecode, a toolkit for developing constraint-based systems and applications. Given a semantics, such problems consist, for example, in enumerating all the extensions, and checking the credulous or sceptical acceptance of an argument passed as parameter. The goal is to let programmers use the library to quickly develop programs on top of it, as, for instance, implementing decision-making procedures based on the strongest arguments, or comparing two frameworks by looking at the differences between their (e.g., stable) semantics. The library features the possibility to use different branching strategies, which we all test and compare on a set of frameworks taken from the International Competition on Computational Models of Argumentation (ICCMA17). Moreover, for some of the tasks, it is possible to perform a parallel search using several workers at the same time: we test the speed-up between using from 1 to 16 threads on a set of ICCMA17 frameworks.

This special issue of Fundamenta Informaticae publishes extended and revised versions of the best papers presented at the 1st edition of the track on Knowledge Representation and Reasoning (

The issue of handling dynamics is a central problem in Argumentation Theory. In order to understand how dynamics work, we extended the ConArg suite with Rob, a tool that is able to display Abstract Argumentation Frameworks and their corresponding sets of extensions, in a way suitable to understand what happens to the semantics when a modification to the graph occurs. In particular, Rob allows to inspect for a particular framework all the corresponding sets of extensions, and for every extension all the frameworks which admit it for some semantics.

An Abstract Argumentation Framework (AAF) is an abstract structure consisting of a set arguments, whose origin, nature, and possible internal organisation is not specified, and by a binary relation of attack on the set of arguments, whose meaning is not specified either. Subjective logic provides a standard set of logical operators, intended for use in domains containing uncertainty. In this paper, we define an extension of AAFs in which each argument and attacks is evaluated with an opinion, by revisiting the constellations approach developed for probabilistic AAFs. In this way, different agents can merge their opinions on how much arguments and attacks are “trustworthy”, e.g., they do not represent fallacies or enthymemes. Finally, subjective logic operators can be used to fuse the belief of different possible worlds (i.e., a constellation of sub-graphs in the original AAF) containing different arguments and attacks.

In Probabilistic Abstract Argumentation, arguments and attacks (nodes and edges) in a graph instance are associated with a probability value. These probabilities can be interpreted in different ways: for instance, in the constellation approaches, the probabilities introduce uncertainty in the topology of the graph. In this paper we use MetaProbLog, a ProbLog framework where facts in a logic program are annotated by probabilities; the purpose is to compute the probability of possible worlds of arguments. The tool is integrated in the web interface of ConArg, a constraint-programming based tool aimed to solve different problems in Abstract Argumentation.

We test different solvers dedicated to the solution of classical problems in Abstract Argumentation, as enumeration/existence of extensions, and sceptical/credulous acceptance of arguments. We handle a subset of the solvers tested in ICCMA15, and a superset of graphs used in the same competition. The goal is to provide considerations that can help future comparisons and competitions as ICCMA15. We offer a detailed report of this comparison from the point of view of different graphs, solvers, problems and timeouts. We show that the characteristics of graphs impact on the performance of solvers and on their final ranking. In addition, we extract other general considerations, e.g., reducing the computation timeout does not change the same ranking.

Bitcoin is a cryptocurrency and a peer-to-peer payment system, where transactions directly take place between pseudo-anonymous users, without any centralised authority. Since the block-chain (i.e., the public ledger where transactions are registered) is an example of Big Data, a straightforward visualisation is not very informative. For this reason, we employ techniques from Visual Analytics to filter out undesired information in order to obtain a tool to visually analyse the transactions and help its analysis. For instance, different views can highlight miners, or sources and leaves of bitcoin flows, together with the balance of each address and transaction. Moreover, the main view sees transactions as grouped into disconnected "islands", making it possible to focus on only one of them at once.

We present ConArgLib, a C++ library implemented to help programmers solve some of the most important problems related to extension-based Abstract Argumentation. The library is based on ConArg, which exploits Constraint Programming and, in particular, Gecode, a toolkit for developing constraintbased systems and applications. Given a semantics, such problems consist, for example, in enumerating all the extensions, and checking the credulous or sceptical acceptance of an argument passed as parameter. The goal is to let programmers use the library to quickly develop programs on top of it, as, for instance, implementing decision-making procedures based on the strongest arguments, or comparing two frameworks by looking at the differences between their (e.g., stable) semantics.

We propose a ranking-based semantics to sort the arguments in an Abstract Argumentation Framework, according to their level of acceptability. This approach is based on a two- criteria method and is a direct extension of the classical three-level justification status of arguments into more layers. Then, we compare such a semantics with the literature, by showing which of the classical properties of ranking-based semantics hold. This leads us to rediscuss some of the existing properties: Self Contradiction and Non-attacked Equivalence.

Partial Model-Checking (PMC) is an efficient tool to reduce the combinatorial explosion of a state-space, arising in the verification of loosely-coupled software systems. At the same time, it is useful to consider quantitative temporal-modalities. This allows for checking whether satisfying such a desired modality is too costly, by comparing the final score consisting of how much the system spends to satisfy the policy, to a given threshold. We stir these two ingredients together in order to provide a Quantitative PMC function (QPMC), based on the algebraic structure of semirings. We design a method to extract part of the weight during QPMC, with the purpose to avoid the evaluation of a modality as soon as the threshold is crossed. Moreover, we extend classical heuristics to be quantitative, and we investigate the complexity of QPMC. Keyword: Partial Model Checking, Semirings, Optimisation, Quantitative Modal Logic Quantitative Process Algebra, Quantitative Evaluation of Systems.

In this paper, we study weighted trust-networks (but also unweighted), where each edge is associated with either a positive or a negative score. Hence, we consider a distrust relationship as well, allowing a user to rate poor experiences with other individuals in his web of acquaintances. We propose an algorithm to compose two of such networks in a single one, in order to merge the knowledge obtained in two different communities of individuals (possibly partially-overlapping), through two different trust management-systems. Our algorithm is based on semiring algebraic-structures, in order to have a parametric computational-framework. Such composition can be adopted whenever two trust-based communities (with the same scope) need to be amalgamated: for instance, two competitor-companies that need to unify the trust-based knowledge on their (sub-) suppliers.

ConArg is a tool for solving different problems related to extension-based semantics: e.g., enumeration of extensions, sceptical and credulous acceptance of arguments. We have extended it in order to deal with Weighted Abstract Argumentation Frameworks, where each attack is associated with a strength score. Classical notions of defence and conflict-freeness have been redefined with the purpose to have different (weighted) degrees of their relaxation. The ultimate aim is to let an agent choose between a higher internal consistency or a stronger defence.

We propose an exploratory study on arguments in Amazon.com reviews. Firstly, we extract positive (in favour of purchase) and negative (against it) arguments from each review concerning a selected product. We accomplish this information extraction manually, scanning all the related reviews. Secondly, we link extracted arguments to the rating score, to the length, and to the date of reviews, in order to undertand how they are connected. As a result, we show that negative arguments are quite sparse in the beginning of such social review-process, while positive arguments are more equally distributed along the timeline. As a final step, we replicate the behaviour of reviewers as agents, by simulating how they assemble reviews in the form of arguments. In such a way, we show we are able to mirror the measured experiment through a simulation that takes into account both positive and negative arguments.

Argumentation has been proved as a simple yet powerful approach to manage conflicts in reasoning with the purpose to find subsets of “surviving” arguments. Our intent is to exploit such form of resolution to support the administration of security in complex systems, e.g., in case threat countermeasures are in conflict with non-functional requirements. The proposed formalisation is able to find the required security controls and explicitly provide arguments supporting this selection. Therefore, an explanation automatically comes as part of the suggested solution, facilitating human comprehension.

We compare four different implementations of reasoning-tools dedicated to Abstract Argumentation Frameworks. These systems are ArgTools, ASPARTIX, ConArg2, and Dung-O-Matic. They have been tested over three different models of randomly-generated grap

Abstract We propose a timed and soft extension of Concurrent Constraint Programming. The time extension is based on the hypothesis ofbounded asynchrony: The computation takes a bounded period of time and is measured by a discrete global clock. Action prefixing is then considered as the syntactic marker that distinguishes a time instant from the next one. Supported by soft constraints instead of crisp ones,tellandaskagents are now equipped with a preference (or consistency) threshold, which is used to determine their success or suspension. In this paper, we provide a language to describe the agents' behavior, together with its operational and denotational semantics, for which we also prove the compositionality and correctness properties. After presenting a semantics using maximal parallelism of actions, we also describe a version for their interleaving on a single processor (with maximal parallelism for time elapsing). Coordinating agents that need to take decisions on both preference values and time events may benefit from this language.

In this paper we show how deductive and abductive reasoning in distributed authorisation can be efficiently ported to Android. Such logical-inference processes prove to be important tools due to the intrinsic autonomic-nature of these mobile devices. Both deduction and abduction are represented by using Constraint Handling Rules (CHR), a high-level declarative constraint programming-language, and implemented in JCHR (CHR embedded into Java). To represent credentials we elaborate on RTW, a weighted Role-based Trust-management family of languages: CHR programs are developed after such languages. In general, having weights associated with credentials leads to a more informative reasoning, for instance, access can be granted only if the total uncertainty is less than 20%.

In this paper we test four different implementations of reasoning tools dedicated to Abstract Argumentation Frameworks. These systems are ASPARTIX, dynPARTIX, Dung-O-Matic, and ConArg2. The tests are executed over three different models of randomly-generated graphs, i.e., the Erdős-Rényi model, the Kleinberg small-world model, and the scale-free Barabasi-Albert model. We compare these four tools with the purpose to test the search of all the possible stable extensions. Then we benchmark dynPARTIX and ConArg2 on the credulous and skeptical acceptance of arguments. Finally, we also evaluate ConArg2 to check the existence of a stable extension.

We compare three different implementations of reasoning tools dedicated to Abstract Argumentation Frameworks. These systems are ASPARTIX, ConArg2, and Dung-O-Matic. They have been tested over three different random graph-models, corresponding to the Erdös-Rényi model, Kleinberg small-world model, and scale-free Barabasi model.

We provide an extensive testing on how efficiently state-of-the art solvers are capable of solving credulous and sceptical argument-acceptance for lower-order extensions. In fact, as our benchmark we consider three different random graph-models to represent random Abstract Argumentation Frameworks: Barabasi and Erdos-Renyi networks, and, in addition, we also rework balanced trees by randomise their structure, with the purpose to obtain random trees of different height. Therefore, we test two reasoners, i.e., Con Arg2 and dyn PARTIX, on such benchmark, by comparing their performance on NP/co-NP-complete decision problems related to argument acceptance in admissible, complete, and stable semantics.

Coordination languages, as Reo, have emerged for the specification and implementation of interaction protocols among concurrent entities. In this paper, we propose a framework for generating partially-distributed, partially-centralized implementations of Reo connectors to improve 1) build-time compilation and 2) run-time throughput and parallelism. Our framework relies on the definition of a new formal product operator on constraint automata (Reo's formal semantics), which enables the formally correct distribution of disjoint parts of a coordination scheme over different machines according to several possible motivations (e.g., performance, privacy, QoS constraints, resource availability, network topology). First, we describe the design and a proof-of-concept implementation of our framework. Then, in a case study, we show and explain how a generated connector implementation can be executed in the Cloud and supports Big Data coordination.

In this paper we study weighted trust-networks, where each edge is associated with either a positive or negative score. Hence, we consider a distrust relationship as well, allowing a user to rate poor experiences with other individuals in his web of acquaintances. We propose an algorithm to compose two of such networks in a single one, in order to merge the knowledge obtained in two different communities of individuals (possibly partially-overlapping), through two different trust management-systems. Our algorithm is based on semiring algebraic-structures, in order to have a parametric computational-framework. Such composition can be adopted whenever two trust-based communities (with the same scope) need to be amalgamated: for instance, two competitor-companies that need to unify the trust-based knowledge on their (sub-) suppliers.

We present a fine-grained security model to enforce the access control on the shared constraint store in Concurrent Constraint Programming (CCP) languages. We show the model for a non-monotonic version of Soft CCP (SCCP), that is an extension of CCP where the constraints have a preference level associated with them. Crisp constraints can be modeled in the same framework as well. In the considered non-monotonic soft version (NmSCCP), it is also possible to remove constraints from the store. The language can be used for coordinating agents on a common store of information that represents the set of shared resources. In such scenarios, it is clearly important to enforce the integrity and confidentiality rights on the resources, in order, for instance, to hide part of the information to some agents, or to prevent an agent to consume too many resources. Finally, we present a bisimulation relation to check equivalence between two programs written in this language.

The aggregation of generic items into coalitions leads to the creation of sets of homogenous entities. In this paper we accomplish this for an input set of arguments, and the result is a partition according to distinct lines of thought, i.e., groups of “coherent” ideas. We extend Dung's Argumentation Framework (AF) in order to deal with coalitions of arguments. The initial set of arguments is partitioned into not-intersected subsets. All the found coalitions show the same property inherited by Dung, e.g., all the coalitions in the partition are admissible (or conflict-free, complete, stable): they are generated according to Dung's principles. Each of these coalitions can be assigned to a different agent. We use Soft Constraint Programming as a formal approach to model and solve such partitions in weighted AFs: semiring algebraic structures can be used to model different optimization criteria for the obtained coalitions. Moreover, we implement and solve the presented problem with JaCoP, a Java constraint solver, and we test the code over a small-world network.

Semiring-based constraint models and frameworks have been extensively used in literature to optimize different security-related metrics, in order to represent trust scores, levels of security and, in general, quantitative information on shared resources to be securely managed. In this tutorial, we summarize four approaches that show an application of these formal models to different security-related problems, as Access Control List-like rights, policy-based access with weighted credentials, propagation of trust on trust-networks, and the cascade vulnerability problem.

In this article, we present a mixed qualitative and quantitative approach for evaluation of information technology (IT) security investments. For this purpose, we model security scenarios by using defense trees, an extension of attack trees with countermeasures and we use economic quantitative indexes for computing the defender's return on security investment and the attacker's return on attack. We show how our approach can be used to evaluate economic profitability of countermeasures and their deterrent effect on attackers, thus providing decision makers with a useful tool for performing better evaluation of IT security investments during the risk management process.

In this paper we focus on solving Fuzzy Distributes Constraint Satisfaction Problems (Fuzzy DCSPs) with an algorithm for Naming Games (NGs): each word on which the agents have to agree on is associated with a preference represented as a fuzzy score. The solution is the agreed word associated with the highest preference value. The two main features that distinguish this methodology from Fuzzy DCSPs methods are that the system can react to small instance changes and and it does not require pre-agreed agent/variable ordering.

We propose ConArg, a tool based on Constraint Programming, to model and solve various problems related to the Argumentation research field. Constraint Satisfaction Problems (CSPs) offer a wide number of efficient techniques (as inference and search algorithms) that can tackle the complexity in finding all the possible Dung's conflict-free, admissible, complete, stable, preferred and grounded extensions in Argumentation Frameworks. Moreover, we can use the tool to solve some computationally hard problems presented in [1]. To implement ConArg, we have used JaCoP, a Java library which provides the user with a Finite Domain Constraint Programming paradigm, to model and solve these two problems. ConArg is able to randomly generate two different kinds of small-world networks in order to find Dung's extensions on such interaction graphs. We present the main features of ConArg and the reported performance in time.

We present an extension of the Soft Concurrent Constraint language that allows the non-monotonic evolution of the constraint store. To accomplish this, we introduce some new operations: retract(c) reduces the current store by c, update X (c) transactionally relaxes all the constraints of the store that deal with the variables in the set X, and then adds a constraint c; nask(c) tests if c is not entailed by the store. The new retraction operators also permit to reason about Belief Revision, i.e. the process of changing beliefs to take into account a new piece of information. We present this framework as a possible solution to the negotiation of resources (e.g. web services and network resource allocation) that need a given Quality of Service (QoS). For this reason we also show the the new operators of the language satisfy the Belief Revision postulates [20], which can be used in the negotiation process. The QoS requirements (expressed as semiring levels) of all the parties should converge on a formal agreement through a negotiation process, which specifies the contract that must be enforced.

Abstract Multitrust provides a flexible approach to encoding trust metrics whereby definitions for trust propagation and aggregation are specified in terms of a semiring. Determining the degree of trust between principals across a trust network (TN) is, in turn, programmed as a (semiring‐based) soft‐constraint satisfaction problem. In this paper, we consider the use of semiring‐based metrics in reasoning about trust between coalition‐forming principals. The configurable nature of multitrust makes it well‐suited to modeling trust within coalitions: whether adding more principals to a coalition increases trust or decreases trust is captured by the definition of trust aggregation within the semiring. Copyright © 2010 John Wiley & Sons, Ltd.

We present a formal model to represent and solve the unicast/multicast routing problem in networks withquality-of-service(QoS) requirements. To attain this, first we translate the network adapting it to a weighted graph (unicast) orand-orgraph (multicast), where the weight on a connector corresponds to the multidimensional cost of sending a packet on the related network link: each component of the weights vector represents a different QoS metric value (e.g., bandwidth). The second step consists in writing this graph as a program insoft-constraint logic programming(SCLP): the engine of this framework is then able to find the best paths/trees by optimizing their costs and solving the constraints imposed on them (e.g.delay≤ 40 ms), thus finding a solution to QoS routing problems.C-semiringstructures are a convenient tool to model QoS metrics. At last, we provide an implementation of the framework over scale-free networks and we suggest how the performance can be improved. The article highlights the expressivity of SCLP.

We extend the Datalog language (we call it Datalogw) in order to deal with weights on ground facts and to consequently compute a feedback result for the goal satisfaction. The weights are chosen from a proper c-semiring. As a second step, in order to show the usefulness of the language, we use Datalogwas the basis to give a uniform semantics to declarative RTW (Trust Management) language family, in order to represent trust levels based on c-semirings. In this way it is possible to manage a score corresponding to a preference or cost associated to the revealed credentials, instead of a plain "yes or no" authorization result. Clearly, such a solution is more informative and allows us to treat uncertainty of facts and rules application, or different preferences for the entity roles. Trust can be then derived by choosing the best chain. The approach is rather generic and could be applied to other trust management languages.