Abstract Modelling the interactions and reasoning processes of multiple agents in a dynamic environment presents a significant challenge, requiring tools that effectively capture diverse interaction types (such as persuasion and deliberation) while supporting agents in decision-making and consensus-building. We extend the Timed Concurrent Language For Argumentation (TCLA) to support the specification of agents equipped with local argument memories and private knowledge reasoning. This extension enables the full formalization of Symmetric Strategic Argumentation Dialogues and Multi-Agent Decision Making with Privacy Preserved problems within TCLA, for which we also introduce general translation functions to automatically obtain TCLA programs. To demonstrate practical applications of TCLA, we provide examples that model the two studied problems and make use of the translation functions.

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.

International audience

Nowadays, creating a blockchain-based system for supply chain tracing is a complex task. This paper defines a model, a graphical domain specific language, and a set of tools aimed at helping supply chain domain experts to create blockchain based tracing systems for their supply chains. Starting from a graphical representation of the supply chain, the solidity smart contracts implementing the related tracing system are automatically generated by our framework. Small interventions of programmers are required to customize and finalize such smart contracts. A set of web based interfaces to interact with such smart contracts are also automatically generated. We are confident that our results will increase blockchain usage for supply chain traceability thanks to the automatic process of smart contract generation.

Abstract The timed concurrent language for argumentation (tcla) is a framework to model concurrent interactions between communicating agents that reason and take decisions through argumentation processes, also taking into account the temporal duration of the performed actions. Time is a crucial factor when dealing with dynamic environments in real-world applications, where agents must act in a coordinated fashion to reach their own goals. However, modelling complex interactions and concurrent processes may be challenging without the help of proper languages and tools. In this paper, we discuss the use of tcla for practical purposes and provide a working implementation of the language, endowed with a user interface available online, that serves the dual purpose of aiding the research in this field and facilitating the development of multi-agent systems based applications.

Abstract Computational Argumentation provides tools for both modelling and reasoning with controversial information. Abstract Argumentation Frameworks represent the building blocks in this field and allow one to model the relationships between arguments with the ultimate goal of establishing their acceptability. Arguments can be evaluated through sets of criteria, called semantics, which distinguish among various justification states. For example, an argument may be accepted, rejected, ignored or even marked as undecided. This paper considers Weighted Argumentation Frameworks and proposes a novel labelling semantics that differentiates four states and generalizes existing approaches.

Abstract Time is a crucial factor in modelling dynamic behaviours of intelligent agents: activities have a determined temporal duration in a real-world environment, and previous actions influence agents’ behaviour. In this paper, we propose a language for modelling concurrent interaction between agents that also allows the specification of temporal intervals in which particular actions occur. Such a language exploits a timed version of Abstract Argumentation Frameworks to realise a shared memory used by the agents to communicate and reason on the acceptability of their beliefs with respect to a given time interval. An interleaving model on a single processor is used for basic computation steps, with maximum parallelism for time elapsing. Following this approach, only one of the enabled agents is executed at each moment. To demonstrate the capabilities of the language, we also show how it can be used to model interactions such as debates and dialogue games taking place between intelligent agents. Lastly, we present an implementation of the language that can be accessed via a web interface.

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.

Abstract Argumentation Theory provides tools for both modelling and reasoning with controversial information and is a methodology that is often used as a way to give explanations to results provided using machine learning techniques. In this context, labelling-based semantics for Abstract Argumentation Frameworks (AFs) allow for establishing the acceptability of sets of arguments, dividing them into three partitions: in, out and undecidable (instead of classical Dung acceptable and not acceptable sets). This kind of semantics have been studied only for classical AFs, while the more powerful weighted and preference-based frameworks have not been studied yet. In this paper, we define a novel labelling semantics for Weighted Argumentation Frameworks (WAFs), extending and generalizing the crisp one, and we provide some insights towards a definition of strong admissibility for WAFs.

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.

The paper provides an initial study on how ranking semantics in argumentation have to be handled when leaving the purely abstract setting. We employ claim-augmented frameworks where each argument is associated to a claim it stands for. We propose liftings from argument- to claim-level in two veins: for desired properties and for actual rankings. Our main contribution is to investigate whether the satisfaction of properties by argument-based ranking semantics carries over to the lifted, claim-based, variants of the corresponding properties and semantics.

ConArg is a suite of tools that offers a wide series of applications for dealing with argumentation problems. In this work, we present the advances we made in implementing a ranking-based semantics, based on computational choice power indexes, within ConArg. Such kind of semantics represents a method for sorting the arguments of an abstract argumentation framework, according to some preference relation. The ranking-based semantics we implement relies on Shapley, Banzhaf, Deegan-Packel and Johnston power index, transferring well know properties from computational social choice to argumentation framework ranking-based semantics.

Although Bitcoin is a relatively new subject in Economics, contributions in this topic are growing very fast. Several papers evidenced a bubble behaviour in exchange rates between Bitcoin and traditional currencies. In this paper we explore and give validation to such conjecture, proving also that the bubble effect is due to confidence in Bitcoin future values. This means that Bitcoin price/exchange rate is influenced both by future and past events, but that the bubble behaviour is strictly connected to trust on the future of the Bitcoin system.

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 (

In argumentation with incomplete information, an agent often needs to outsource justification of its arguments to other agents, having not sufficient arguments of its own to defend them. Formal characterisation of the impact of such common practice on agents' decision over which of its arguments are acceptable has not been well-investigated. We present an epistemic agent argumentation theory in which an agent can outsource justification of its arguments to its benefactors either by argumentation sharing or relegation. Semantics will be formulated.

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.

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.

Fog computing paradigm is emerging after a decade's dominance of cloud‐based system design and architecture. Now, instead of centralising the computation and coordination to remote services, these are deployed and distributed to all over physical surroundings and network nodes, including cloud services, smart gateways, and network edge devices. At the moment, the majority of the Internet of things (IoT) systems and software has built on top of open Web‐based technologies. The authors assume that with the ever‐growing number and heterogeneity of connected devices, it becomes ever‐more crucial to have open standards that support interoperability and enable interactions. They review the current technological space for architecting Web technology‐based IoT software in the coming era of fog computing. They focus on fundamental research challenges and discuss the emerging issues.

"23rd RCRA International workshop on “Experimental evaluation of algorithms for solving problems with combinatorial explosion”." Journal of Experimental & Theoretical Artificial Intelligence, 30(4), pp. 479–480

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.

The main aim of data mining techniques and tools is that of identify and extract, from a set of (big) data, implicit patterns which can describe static or dynamic phenomena. Among these latter business processes are gaining more and more attention due to their crucial role in modern organizations and enterprises. Being able to identify and model processes inside organizations is for sure a key asset to discover their weak and strong points thus helping them in the improvement of their competitiveness. In this paper we describe a prototype system able to discover business processes from an event log and classify them with a suitable level of abstraction with reference to a related business ontology. The identified process, and its corresponding level of abstraction, depends on the knowledge encoded in the reference ontology which is dynamically exploited at runtime. The tool has been validated by considering examples and case studies from the literature on process mining.

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.

Formal voting theories are established and can be used to determine if a voting system is fair or not in order to preserve democracy. There are a lot of voting systems described in the literature, with several properties, useful in many contexts. The Argumentation Framework is based on the exchange and the evaluation of interacting arguments which may represent information of various kinds. We show that Argumentation Frameworks can be interpreted within a voting theory and considered as voting methods. Using a mapping that associates an argument to a candidate and attacks to votes, we define a bidirectional mapping between the two theories and investigate how fairness criteria defined for voting systems can be re-interpreted within Argumentation Framework. We also show how voting ballots can be seen as suitable semantics for Argumentation Frameworks.

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.

This special issue of Fundamenta Informaticae publishes extended and revised versions of the best papers orally presented at the 22nd RCRA International Workshop (RCRA 2015). 1 This event follows the series of the RCRA (the working group of the AI*IA association on Knowledge Representation and Automated Reasoning) annual meetings, held since 1994, and that from 2007 became an international workshop.RCRA 2015 was held in Ferrara, Italy, on 22 September 2015 as a satellite workshop of the 14th Conference of the Italian Association for Artificial Intelligence (AI*IA 2015).The success of all these events shows that RCRA is nowadays established as a major forum for exchanging ideas and proposing experimentation methodologies for algorithms in Artificial Intelligence.

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.

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.

Preferences and uncertainty are common in many real-life problems. In this article, we focus on bipolar preferences and uncertainty modelled via uncontrollable variables, and we assume that uncontrollable variables are specified by possibility distributions over their domains. To tackle such problems, we concentrate on uncertain bipolar problems with totally ordered preferences, and we eliminate the uncertain part of the problem, while making sure that some desirable properties hold about the robustness of the problem and its relationship with the preference of the optimal solutions. We also consider several semantics to order the solutions according to different attitudes with respect to the notions of preference and robustness.

Constraint solving problems (CSPs) are the formalization of a large range of problems that emerge from computer science. The solving methodology described here is based on the naming game. The two main features that distinguish this methodology from

Real-life problems present several kinds of preferences. We focus on problems with both positive and negative preferences, which we call bipolar preference problems. Although seemingly specular notions, these two kinds of preferences should be dealt with differently to obtain the desired natural behaviour. We technically address this by generalising the soft constraint formalism, which is able to model problems with one kind of preference. We show that soft constraints model only negative preferences, and we add to them a new mathematical structure which allows to handle positive preferences as well. We also address the issue of the compensation between positive and negative preferences, studying the properties of this operation. Finally, we extend the notion of arc consistency to bipolar problems, and we show how branch and bound (with or without constraint propagation) can be easily adapted to solve such problems.

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 provide a reformulation of the constraint hierarchies (CHs) framework based on the notion of error indicators. Adapting the generalised view of local consistency in semiring-based constraint satisfaction problems, we define constraint hierarchy k-consistency (CH-k-C) and give a CH-2-C enforcement algorithm. We demonstrate how the CH-2-C algorithm can be seamlessly integrated into the ordinary branch-and-bound algorithm to make it a finite domain (FD) CH solver. Experimentation confirms the efficiency and robustness of our proposed solver prototype. Unlike other FD CH solvers, our proposed method works for both local and global comparators. In addition, our solver can support arbitrary error functions.

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.

In this paper 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 attack 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 effectiveness and economic profitability of countermeasures as well as 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.

Soft constraints extend classical constraints to represent multiple consistency levels, and thus provide a way to express preferences, fuzziness, and uncertainty. While there are many soft constraint solving formalisms, even distributed ones, as yet there seems to be no concurrent programming framework where soft constraints can be handled. In this article we show how the classical concurrent constraint (cc) programming framework can work with soft constraints, and we also propose an extension of cc languages which can use soft constraints to prune and direct the search for a solution. We believe that this new programming paradigm, called soft cc (scc), can be also very useful in many Web-related scenarios. In fact, the language level allows Web agents to express their interaction and negotiation protocols, and also to post their requests in terms of preferences, and the underlying soft constraint solver can find an agreement among the agents even if their requests are incompatible.

When formalizing security protocols, different specification languages support very different reasoning methodologies, whose results are not directly or easily comparable. Therefore, establishing clear mappings among different frameworks is highly de

The security of a network configuration is based not just on the security of its individual components and their direct interconnections, but also on the potential for systems to interoperate indirectly across network routes. Such interoperation has

The partial constraint satisfaction paradigm focuses on solving relaxations of problems that either do not admit solutions, or that are either impractical or impossible to solve completely. The semiring-based framework for soft constraints is a unifying model for a variety of extensions of the constraint satisfaction formalism. For example, the semiring-based framework can represent weighted, fuzzy, probabilistic and set-based constraint satisfaction problems. We discuss how the semiring-based framework for soft constraints can be used to model partial constraint satisfaction problems. We show how the semiring framework can be used to capture a notion of distance between a solution and a problem based on the known distance metrics used in the partial constraint satisfaction literature. These solution-problem distance metrics can be seen as providing lower-bounds on the distance between a problem and its relaxation.

Soft constraints are a generalization of classical constraints, which allow for the description of preferences rather than strict requirements. In soft constraints, constraints and partial assignments are given preference or importance levels, and constraints are combined according to combinators which express the desired optimization criteria. On the other hand, constraint handling rules (CHR) constitute a high‐level natural formalism to specify constraint solvers and propagation algorithms. We present a framework to design and specify soft constraint solvers by using CHR. In this way, we extend the range of applicability of CHR to soft constraints rather than just classical ones, and we provide a straightforward implementation for soft constraint solvers.

Security protocols stipulate how the remote principals of a computer network should interact in order to obtain specific security goals. The crucial goals of confidentiality and authentication may be achieved in various forms, each of different strength. Using soft (rather than crisp) constraints, we develop a uniform formal notion for the two goals. They are no longer formalised as mere yes/no properties as in the existing literature, but gain an extra parameter, the security level. For example, different messages can enjoy different levels of confidentiality, or a principal can achieve different levels of authentication with different principals. The goals are formalised within a general framework for protocol analysis that is amenable to mechanisation by model checking. Following the application of the framework to analysing the asymmetric Needham-Schroeder protocol (Bella and Bistarelli 2001; Bella and Bistarelli 2002), we have recently discovered a new attack on that protocol as a form of retaliation by principals who have been attacked previously. Having commented on that attack, we then demonstrate the framework on a bigger, largely deployed protocol consisting of three phases, Kerberos.

We provide a reformulation of the constraint hierarchies (CHs) framework based on the notion of error indicators . Adapting the generalized view of local consistency in semiring-based constraint satisfaction problems (SCSPs), we define constraint hierarchy k -consistency (CH- k -C) and give a CH-2-C enforcement algorithm. We demonstrate how the CH-2-C algorithm can be seamlessly integrated into the ordinary branch-and-bound algorithm to make it a finite domain CH solver. Experimentation confirms the efficiency and robustness of our proposed solver prototype. Unlike other finite domain CH solvers, our proposed method works for both local and global comparators. In addition, our solver can support arbitrary error functions. These keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

Soft constraints are very flexible and expressive. However, they are also very complex to handle. For this reason, it may be reasonable in several cases to pass to an abstract version of a given soft constraint problem, and then to bring some useful information from the abstract problem to the concrete one. This will hopefully make the search for a solution, or for an optimal solution, of the concrete problem, faster. In this paper we propose an abstraction scheme for soft constraint problems and we study its main properties. We show that processing the abstracted version of a soft constraint problem can help us in finding good approximations of the optimal solutions, or also in obtaining information that can make the subsequent search for the best solution easier. We also show how the abstraction scheme can be used to devise new hybrid algorithms for solving soft constraint problems, and also to import constraint propagation algorithms from the abstract scenario to the concrete one. This may be useful when we don't have any (or any efficient) propagation algorithm in the concrete setting.

We extend the Constraint Logic Programming (CLP) formalism in order to handle semiring-based constraints. This allows us to perform in the same language both constraint solving and optimization. In fact, constraints based on semirings are able to model both classical constraint solving and more sophisticated features like uncertainty, probability, fuzziness, and optimization. We then provide this class of languages with three equivalent semantics: model-theoretic, fix-point, and proof-theoretic, in the style of classical CLP programs.

We introduce a general framework for constraint satisfaction and optimization where classical CSPs, fuzzy CSPs, weighted CSPs, partial constraint satisfaction, and others can be easily cast. The framework is based on a semiring structure, where the set of the semiring specifies the values to be associated with each tuple of values of the variable domain, and the two semiring operations (+ and X) model constraint projection and combination respectively. Local consistency algorithms, as usually used for classical CSPs, can be exploited in this general framework as well, provided that certain conditions on the semiring operations are satisfied. We then show how this framework can be used to model both old and new constraint solving and optimization schemes, thus allowing one to both formally justify many informally taken choices in existing schemes, and to prove that local consistency techniques can be used also in newly defined schemes.