Credulous and Skeptical Acceptance in Incomplete Argumentation Frameworks

Verification in incomplete argumentation frameworks

argumentation frameworks (AFs) are one of the most studied formalisms in AI. In this work, we introduce a certain subclass of AFs which we call compact. Given an extension-based semantics, the corresponding compact AFs are characterized by the feature that each argument of the AF occurs in at least one extension. This not only guarantees a certain notion of fairness; compact AFs are thus also minimal in the sense that no argument can be removed without changing the outcome. We address the following questions in the paper: (1) How are the classes of compact AFs related for different semantics? (2) Under which circumstances can AFs be transformed into equivalent compact ones? (3) Finally, we show that compact AFs are indeed a non-trivial subclass, since the verification problem remains coNP-hard for certain semantics.

We introduce Incomplete Bipolar Argumentation Frameworks (iBAFs), the extension of Dung’s Abstract Argumentation Frameworks (AAFs) allowing the simultaneous presence of supports (borrowed from BAFs – Bipolar AAFs) and of uncertain elements of the argumentation graph (borrowed from iAAFs – incomplete AAFs). We investigate the computational complexity of verification problem (under the possible perspective) and the acceptance problem, by studying its sensitivity to the semantics of supports and the semantics of extensions. On the one hand, we show that adding supports on top of incompleteness does not affect the complexity of the acceptance. On the other hand, surprisingly, we show that the joint use of bipolarity and incompleteness has a deep impact on the complexity of the verification: for the semantics under which the verification over AAFs is polynomial-time solvable, although moving from AAFs to BAFs or to iAAFs does not change the complexity, the complexity of the verification over iBAFs may increase up to NP-complete.

Control argumentation frameworks (CAFs) [4] extend the standard model of argumentation framework (AF) due to Dung [6] in a way that takes unquantified uncertainty regarding arguments and attacks into account. Complementing recent work by Skiba et al. [21] for incomplete argumentation frameworks, we study the (nonempty) existence problem for CAFs and fully analyze its computational complexity for the most common semantics.

The study of computational models for argumentation is a vibrant area of artificial intelligence and, in particular, knowledge representation and reasoning research. Arguments most often have an intrinsic structure made explicit through derivations from more basic structures. Computational models for structured argumentation enable making the internal structure of arguments explicit. Assumption-based argumentation (ABA) is a central structured formalism for argumentation in AI. In this article, we make both algorithmic and complexity-theoretic advances in the study of ABA. In terms of algorithms, we propose a new approach to reasoning in a commonly studied fragment of ABA (namely the logic programming fragment) with and without preferences. While previous approaches to reasoning over ABA frameworks apply either specialized algorithms or translate ABA reasoning to reasoning over abstract argumentation frameworks, we develop a direct declarative approach to ABA reasoning by encoding ABA reasoning tasks in answer set programming. We show via an extensive empirical evaluation that our approach significantly improves on the empirical performance of current ABA reasoning systems. In terms of computational complexity, while the complexity of reasoning over ABA frameworks is well-understood, the complexity of reasoning in the ABA+ formalism integrating preferences into ABA is currently not fully established. Towards bridging this gap, our results suggest that the integration of preferential information into ABA via so-called reverse attacks results in increased problem complexity for several central argumentation semantics.

The article addresses the problem of evaluating the computational complexity of basic cascade GL-models used for modeling the behavior of fault-tolerant multiprocessor systems in the flow of failures. The purpose of this work is to reduce the complexity of such models by optimal selection of their parameters. It has been demonstrated that a single system usually corresponds to an entire family of cascade GL-models, differing in cascade depth and parameters, with each having its own computational complexity. To simplify the process of modeling the system behavior under a flow of failures, it is advisable to choose the cascade GL-model configuration with the lowest complexity. However, additional constraints on the model, such as cascade depth limitations, must also be considered. This work applies an empirical-analytical research method. An analysis of computational complexity for cascade GL-models was conducted using specially developed software, which automated model construction for various combinations of parameters. Subsequently, a comparative analysis of the complexity of their edge function expressions was performed to identify dependencies on parameter values. Experimental studies were carried out for fault-tolerant multiprocessor systems with varying numbers of processors and different maximum allowable failure multiplicities (but not exceeding half of the total number of processors in the system). It was shown that cascade GL-models typically have significantly lower computational complexity compared to standard basic GL-models, especially for systems with a small maximum number of allowed failures. However, in cases where the allowed number of failures equals or exceeds half of the processor count, standard models may become less complex. Based on the conducted analysis, practical recommendations for selecting the parameters of cascade GL-models were formulated for the first time. In particular, the lowest complexity is achieved when the fault tolerance coefficient of the auxiliary model is minimized at each cascade level; however, this leads to a maximal cascade depth. If cascade depth is limited, the lowest complexity is achieved by evenly or nearly evenly distributing the fault-tolerance coefficients among auxiliary models. If an even distribution is impossible, it is advisable to place higher-value coefficients at deeper cascade levels. Experimental results demonstrate that the application of the proposed recommendations can significantly reduce the overall complexity of edge function expressions in the cascade GL-model compared to the basic GL-model, with the effectiveness of the approach increasing as the system size grows.

This paper studies a new class of single-machine scheduling problems, that are faced by Just-in-Time-suppliers satisfying a given demand. In these models the processing of jobs leads to a release of a predefined number of product units into inventory. Consumption is triggered by predetermined time-varying, and product-specific demand requests. While all demands have to be fulfilled, the objective is to minimize the resulting product inventory. We investigate different subproblems of this general setting with regard to their computational complexity. For more restricted problem versions (equal processing times and equal number of released products) strongly polynomial time algorithms are presented. In contrast to this, NP-hardness in the strong sense is proven for more general problem versions (varying processing times or varying number of released products). Moreover, for the most general version, even finding a feasible solution is shown to be strongly NP-hard.

K-Nearest Neighbor (KNN) and Support Vector Machine (SVM) are the two Supervised Machine Learning Algorithms which have been used extensively in solving classification and regression problems in various application domains—medical diagnosis, pattern recognition, and image classification being the popular ones. KNN has been attractive for its simplicity—SVM has been considered as complex. Computational complexity of KNN is less compared to SVM. However, accuracy of SVM in general has been higher compared to KNN. This paper carries out an analysis of complexity of KNN and SVM and then looks at the alternative strategies to reduce the complexity. Accuracies of both SVM and KNN are analyzed from literature survey of experimental results with different training datasets. Reduction of number of training instances and usage of kernel functions are found to be the solutions for reducing SVM complexity. Factors impacting KNN accuracy are analyzed and possible alternatives are assessed. Kernel functions and distance-weighted KNN are concluded as the solution to improve KNN accuracy to compete with SVM accuracy. To utilize the best potential of the two algorithms, the option of a hybrid algorithm combining both KNN and SVM is also proposed.

Coding efficiency gains in the High Efficiency Video Coding (H.265/HEVC) standard are achieved by improving many aspects of the traditional hybrid coding framework. Motion compensated prediction, and in particular the interpolation filter, is one of the areas that was improved significantly over H.264/AVC. This paper presents the details of the motion compensation interpolation filter design of the H.265/HEVC standard and its improvements over the interpolation filter design of H.264/AVC. These improvements include discrete cosine transform based filter coefficient design, utilizing longer filter taps for luma and chroma interpolation and using higher precision operations in the intermediate computations. The computational complexity of HEVC interpolation filter is also analyzed both from theoretical and practical perspectives. Experimental results show that a 4.5% average bitrate reduction for the luma component and 13.0% average bitrate reduction for the chroma components are achieved compared to interpolation filter of H.264/AVC. The coding efficiency gains are significant for some video sequences and can reach up to 21.7%.

Multicast is an internetwork service that provides efficient delivery of packets from a single source to multiple recipients. When there are large number of members in the group, security and scalability problems arise and an attempt to solve this, gives rise to additional computational complexities at the server. A model is said to be highly efficient if only it has less computational complexity at the server for all membership events and highly secure only when it requires large number of computations to successfully break the multicast model. In this paper, the computational complexities are determined and analyzed for different multicast models. Theoretical evaluation and experimental results prove that for all the membership events, the recently proposed multicast model named LeaSel [3] has computational complexity of O(NSG) when compared to other models which has computational complexity of O(N), where N ≫ NSG. It is also shown that to successfully break LeaSel, the computational complexity is O(SaN) when compared to other models whose computational complexity is O(Sn).

This paper describes our experience in modeling two significant parallel applications: ARC2D, a 2-dimensional Euler solver; and, Xtrid, a tridiagonal linear solver. Both of these models were expressed in BDL (Behavior Description language) and simulated on an iPSC/860 Hypercube modeled using Axe (Abstract eXecution Environment). BDL models consist of abstract communicating objects: blocks of sequential code are modeled by single RUN statements; all communication operations in the original code are mirrored by corresponding BDL operations in the model. Our ARC2D model was built by first profiling the program to locate the significant loops and then timing the basic blocks within those loops. Simulated completion times were (except in one case) within 8% of measured execution times. Lengthy simulations were necessary for predicting the performance of large-scale runs. For Xtrid, only the loops surrounding communications were modeled; other loops were absorbed into large sequential blocks whose complexity was estimated using statistical regression. This approach yielded a much smaller model whose computation and communication complexities were clearly manifest. Analysis of complexity allowed rapid prediction of large-scale performance without lengthy simulations! Analytically predicted speed-ups were within 7% of those predicted by simulation. Simulated completion times were within 5% of measured execution times. The second approach provides a more effective methodology for simulation-based performance-tuning.

Complexity Analysis of Multilayer Perceptron Neural Network Embedded into a Wireless Sensor Network

A secure cryptosystem could be very complicated, time consuming and hard to implement. Therefore, the complexity of the cryptosystem should be taken into account during design and implementation. In this work, the authors introduce a comprehensive and platform independent complexity analysis for a class of symmetric block cryptosystems, by which it will be easier to evaluate the performance of some used cryptosystems. Previous works lacked the comprehensiveness in their analysis, due to the fact that the memory access time was completely ignored, which greatly degrades the accuracy of the analysis and limits it to one data block only. In this paper the authors analytically compute the complexity for a class of symmetric cryptosystems in terms of the number of the clock cycles required and in terms of the required time for encryption/decryption, independently of the hardware or software used in the encryption/decryption process. Moreover, this is the first complexity analysis that considers the required time to access and retrieve information from memory, which makes the analysis more comprehensive and accurate than previous work as well as being general for any number of encryption data blocks. In addition, computer simulations are used to truly evaluate the accuracy of the analysis and to show how the analytical results match the simulation results.

Possibilistic fuzzy c-means (PFCM) clustering is a kind of hybrid clustering method based on fuzzy c-means (FCM) and possibilistic c-means (PCM), which not only has the stability of FCM but also partly inherits the robustness of PCM. However, as an extension of FCM on the objective function, PFCM tends to find a suboptimal local minimum, which affects its performance. In this paper, we rederive PFCM using the majorization-minimization (MM) method, which is a new derivation approach not seen in other studies. In addition, we propose an effective optimization method to solve the above problem, called MMPFCM. Firstly, by eliminating the variable V∈Rp×c, the original optimization problem is transformed into a simplified model with fewer variables but a proportional term. Therefore, we introduce a new intermediate variable s∈Rc to convert the model with the proportional term into an easily solvable equivalent form. Subsequently, we design an iterative sub-problem using the MM method. The complexity analysis indicates that MMPFCM and PFCM share the same computational complexity. However, MMPFCM requires less memory per iteration. Extensive experiments, including objective function value comparison and clustering performance comparison, demonstrate that MMPFCM converges to a better local minimum compared to PFCM.

Argumentation is a widely applied framework for modeling and evaluating arguments and its reasoning with various applications. Popular frameworks are abstract argumentation (Dung’s framework) or logic-based argumentation (Besnard-Hunter’s framework). Their computational complexity has been studied quite in-depth. Incorporating treewidth into the complexity analysis is particularly interesting, as solvers oftentimes employ SAT-based solvers, which can solve instances of low treewidth fast. In this paper, we address whether one can design reductions from argumentation problems to SAT-problems while linearly preserving the treewidth, which results in decomposition-guided (DG) reductions. It turns out that the linear treewidth overhead caused by our DG reductions, cannot be significantly improved under reasonable assumptions. Finally, we consider logic-based argumentation and establish new upper bounds using DG reductions and lower bounds.