Internet topology discovery consists of inferring the inter-router connectivity (“links”) and the mapping from IP addresses to routers (“alias resolution”). Current topology discovery techniques use TTL-limited “traceroute ” probes to discover links and use direct router probing to resolve aliases. The often-ignored record route (RR) IP option provides a source of disparate topology data that could augment existing techniques, but it is difficult to properly align with traceroute-based topologies because router RR implementations are under-standardized. Correctly aligned RR and traceroute topologies have fewer false links, include anonymous and hidden routers, and discover aliases for routers that do not respond to direct probing. More accurate and feature-rich topologies benefit overlay construction and network diagnostics, modeling, and measurement. We present DisCarte, a system for aligning and cross-validating RR and traceroute topology data using observed engineering practices. DisCarte uses disjunctive logic programming (DLP), a logical inference and constraint solving technique, to intelligently merge RR and traceroute data. We demonstrate that the resultant topology is more accurate and complete than previous techniques by validating its internal consistency and by comparing to publicly available topologies. We classify irregularities in router implementations and introduce a divide-and-conquer technique used to scale DLP to Internet-sized systems.

We elaborate a uniform approach to computing answer sets of disjunctive logic programs based on state-of-theart Boolean constraint solving techniques. Starting from a constraint-based characterization of answer sets, we develop advanced solving algorithms, featuring backjumping and conflict-driven learning using the First-UIP scheme as well as sophisticated unfounded set checking. As a final result, we obtain a competitive solver for Σ P 2-complete problems, taking advantage of Boolean constraint solving technology without using any legacy solvers as black boxes.

We elaborate upon a recently proposed approach to finding an answer set of a logic program based on concepts from constraint processing and satisfiability checking. We extend this approach and propose a new algorithm for enumerating answer sets. The algorithm, which to our knowledge is novel even in the context of satisfiability checking, is implemented in the clasp answer set solver. We contrast our new approach to alternative systems and different options of clasp, and provide an empirical evaluation.

Abstract. In the last few years, significant improvements characterized state-ofthe-art Answer Set Programming (ASP) systems. It is now well accepted that their applicability is becoming more and more suited for real world applications requiring complex reasoning tasks. Among the available ASP systems, DLV recently came up with a large variety of language extensions, front-ends and variants that significantly widened its range of applicability. This paper presents an integrated development environment, customized for DLV and some of its extensions, which aims to simplify both the development-and-test process and the coupling of this ASP system with DBMSs. 1

Competitive native solvers for Answer Set Programming (ASP) perform a backtracking search by assuming the truth of literals. The choice of literals (the heuristic) is fundamental for the performance of these systems. Most of the efficient ASP systems employ a heuristic based on look-ahead, that is, a literal is tentatively assumed and its heuristic value is based on its deterministic consequences. However, looking ahead is a costly operation, and indeed lookahead often accounts for the majority of time taken by ASP solvers. For Satisfiability (SAT), a radically different approach, called look-back heuristic, proved to be quite successful: Instead of looking ahead, one uses information gathered during the computation performed so far, thus looking back. In this approach, atoms which have been frequently involved in inconsistencies are preferred. In this paper, we carry over this approach to the framework of disjunctive ASP. We design a number of look-back heuristics exploiting peculiarities of ASP and implement them in the ASP system DLV. We compare their performance on a collection of hard ASP programs both structured and randomly generated. These experiments indicate that a very basic approach works well, outperforming all of the prominent disjunctive ASP systems — DLV (with its traditional heuristic), GnT, and CModels3 — on many of the instances considered.

Abstract. We elaborate upon a recently proposed approach to finding an answer set of a logic program based on concepts from constraint processing and satisfiability checking. We extend this approach and propose a new algorithm for enumerating answer sets. The algorithm, which to our knowledge is novel even in the context of satisfiability checking, is implemented in the clasp answer set solver. We contrast our new approach to alternative systems and different options of clasp, and provide an empirical evaluation. 1

One of the most significant language extensions to Answer Set Programming (ASP) has been the introduction of aggregates. A significant amount of theoretical and practical work on aggregates in ASP has been published in recent years. In spite of these developments, aggregates are treated in a quite straightforward and ad-hoc way in most ASP systems. For the system DLV, several specialized techniques for aggregates have been described in [6], however still leaving a lot of room for improvement. In this paper, we build upon work on look-back optimization techniques done recently for DLV, and extend its reason calculus for backjumping to include reasons from aggregates. Furthermore, we describe how these reasons can be used in order to tune look-back heuristic counters. We present a preliminary experimental analysis, including also other state-of-the-art ASP systems, showing that our approach is promising. 1

Abstract not found

Abstract. DLV is the state-of-the-art system for evaluating disjunctive answer set programs. As in most Answer Set Programming (ASP) systems, its implementation is divided in a grounding part and a propositional model-finding part. In this paper, we focus on the latter, which relies on an algorithm using backtracking search. Recently, DLV has been enhanced with “backjumping ” techniques, which also involve a reason calculus, recording causes for the truth or falsity of atoms during the search. This reason calculus allows for looking back in the search process for identifying areas in the search space in which no answer set will be found. We can also define heuristics which make use of the information about reasons, preferring literals that were the reasons of more inconsistent branches of the search tree. This heuristics thus use information gathered earlier in the computation, and are therefore referred to as look-back heuristics. In this paper, we focus on the experimental evaluation of these look-back techniques that we have implemented in DLV. We have conducted a wide experimental analysis considering both randomly-generated and structured instances of the 2QBF problem (the canonical problem for the complexity classes Σ P 2 and Π P 2). We have also evaluated the same benchmark using “native ” QBF solvers, which were among the best solvers in recent QBF Evaluations. The comparison shows that DLV endowed with look-back techniques is competitive with the best available QBF solvers. 1

Abstract. The introduction of aggregates has been one of the most relevant language extensions to Answer Set Programming (ASP). Aggregates are very expressive, they allow to represent many problems in a more succinct and elegant way compared to aggregate-free programs. A significant amount of research work has been devoted to aggregates in the ASP community in the last years, and relevant research results on ASP with aggregates have been published, on both theoretical and practical sides. The high expressiveness of aggregates (eliminating aggregates often causes a quadratic blow-up in program size) requires suitable evaluation methods and optimization techniques for an efficient implementation. Nevertheless, in spite of the above-mentioned research developments, aggregates are treated in a quite straightforward way in most ASP systems. In this paper, we explore the exploitation of look-back techniques for an efficient implementation of aggregates. We define a reason calculus for backjumping in ASP programs with aggregates. Furthermore, we describe how these reasons can be used in order to guide look-back heuristics for programs with aggregates. We have implemented both the new reason calculus and the proposed heuristics in the DLV system, and have carried out an experimental analysis on publicly available