Conflict-directed Backjumping Research Articles

Efficient Authorization of Graph-database Queries in an Attribute-supporting ReBAC Model

Neo4j is a popular graph database that offers two versions: an enterprise edition and a community edition . The enterprise edition offers customizable Role-based Access Control features through custom developed procedures , while the community edition does not offer any access control support. Being a graph database, Neo4j appears to be a natural application for Relationship-Based Access Control (ReBAC), an access control paradigm where authorization decisions are based on relationships between subjects and resources in the system (i.e., an authorization graph). In this article, we present AReBAC, an attribute-supporting ReBAC model for Neo4j that provides finer-grained access control by operating over resources instead of procedures. AReBAC employs Nano-Cypher, a declarative policy language based on Neo4j’s Cypher query language, the result of which allows us to weave database queries with access control policies and evaluate both simultaneously. Evaluating the combined query and policy produces a result that (i) matches the search criteria, and (ii) the requesting subject is authorized to access. AReBAC is accompanied by the algorithms and their implementation required for the realization of the presented ideas, including GP-Eval, a query evaluation algorithm. We also introduce Live-End Backjumping (LBJ), a backtracking scheme that provides a significant performance boost over conflict-directed backjumping for evaluating queries. As demonstrated in our previous work, the original version of GP-Eval already performs significantly faster than the Neo4j’s Cypher evaluation engine. The optimized version of GP-Eval , which employs LBJ, further improves the performance significantly, thereby demonstrating the capabilities of the technique.

Correction to: Enhanced Multiple-Point Statistical Simulation with Backtracking, Forward Checking and Conflict-Directed Backjumping

In the original version of this article, unfortunately Figure 9 was wrong due to a typesetting mistake. The original article has been corrected.

Enhanced Multiple-Point Statistical Simulation with Backtracking, Forward Checking and Conflict-Directed Backjumping

During a conventional multiple-point statistics simulation, the algorithm may not find a matched neighborhood in the training image for some unsimulated pixels. These pixels are referred to as the dead-end pixels; the existence of the dead-end pixels means that multiple-point statistics simulation is not a simple sequential simulation. In this paper, the multiple-point statistics simulation is cast as a combinatorial optimization problem, and the efficient backtracking algorithm is developed to solve this optimization problem. The efficient backtracking consists of backtracking, forward checking, and conflict-directed backjumping algorithms that are introduced and discussed in this paper. This algorithm is applied to simulate multiple-point statistics properties of some synthetic training images; the results show that no anomalies occurred in any of the produced realizations as opposed to previously published methods for solving the dead-end pixels. In particular, in simulating a channel system, all the channels generated by this method are continuous, which is of paramount importance in fluid flow simulation applications. The results also show that the presence of hard data does not degrade the quality of the generated realizations. The presented method provides a robust algorithmic framework for performing MPS simulation.

The Mechanical Verification of a DPLL-Based Satisfiability Solver

Recent years have witnessed dramatic improvements in the capabilities of propositional satisfiability procedures or SAT solvers. The speedups are the result of numerous optimizations including conflict-directed backjumping. We use the Prototype Verification System (PVS) to verify a satisfiability procedure based on the Davis–Putnam–Logemann–Loveland (DPLL) scheme that features these optimizations. This exercise is a step toward the verification of an efficient implementation of the satisfiability procedure. Our verification of a SAT solver is part of a larger program of research to provide a secure foundation for inference using a verified reference kernel that contains a verified SAT solver. Our verification exploits predicate subtypes and dependent types in PVS to capture the specification and the key invariants.

𝒞𝒪𝒞𝒪𝒩ℱ: Conceptual language-based configuration

This article deals with the configuration task. Configuring means assembling a set of predefined components in order to build a composite object that meets a set of requirements. Here we present COCONF, an approach to configuration based on a conceptual encoding of the configuration knowledge, directly exploitable by a software configuration system to compute configurations. In particular, we show how Conflict-Directed Backjumping can be adapted to the proposed framework and in which way the efficiency of the configurator may be still enhanced by two look-ahead mechanisms, which exploit the characteristics of the modeling language and the explicit representation of both the compositional structure and the taxonomic relations among component types. The configuration algorithms are explained in detail; the assumptions and the properties which they are based on are explicitly stated. Formal proofs are provided for the basic properties. A set of experimental results on three different real-world domains are presented, which prove the suitability of the approach.

Intelligent search strategies based on adaptive Constraint Handling Rules

The most advanced implementation of adaptive constraint processing with Constraint Handling Rules (CHR) allows the application of intelligent search strategies to solve Constraint Satisfaction Problems (CSP). This presentation compares an improved version of conflict-directed backjumping and two variants of dynamic backtracking with respect to chronological backtracking on some of the AIM instances which are a benchmark set of random 3-SAT problems. A CHR implementation of a Boolean constraint solver combined with these different search strategies in Java is thus being compared with a CHR implementation of the same Boolean constraint solver combined with chronological backtracking in SICStus Prolog. This comparison shows that the addition of “intelligence” to the search process may reduce the number of search steps dramatically. Furthermore, the runtime of their Java implementations is in most cases faster than the implementations of chronological backtracking. More specifically, conflict-directed backjumping is even faster than the SICStus Prolog implementation of chronological backtracking, although our Java implementation of CHR lacks the optimisations made in the SICStus Prolog system.

Efficient solution techniques for disjunctive temporal reasoning problems

Over the past few years, a new constraint-based formalism for temporal reasoning has been developed to represent and reason about Disjunctive Temporal Problems (DTPs). The class of DTPs is significantly more expressive than other problems previously studied in constraint-based temporal reasoning. In this paper we present a new algorithm for DTP solving, called Epilitis, which integrates strategies for efficient DTP solving from the previous literature, including conflict-directed backjumping, removal of subsumed variables, and semantic branching, and further adds no-good recording as a central technique. We discuss the theoretical and technical issues that arise in successfully integrating this range of strategies with one another and with no-good recording in the context of DTP solving. Using an implementation of Epilitis, we explore the effectiveness of various combinations of strategies for solving DTPs, and based on this analysis we demonstrate that Epilitis can achieve a nearly two order-of-magnitude speed-up over the previously published algorithms on benchmark problems in the DTP literature.

Solution Techniques for Constraint Satisfaction Problems

A wide range of problems in Artificial Intelligence can be represented as instances of the Constraint Satisfaction Problem (CSP), and then be solved using some of the existing techniques for solving CSPs. In this paper, we start by defining the concept of CSP and showing how some combinatorial problems can be modelled as CSPs. Next, we give a detailed description of the basic techniques for constraint satisfaction: constraint propagation algorithms (node consistency, arc consistency, and kconsistency), search algorithms (generate and test, backtracking, backjumping, and conflict-directed backjumping), and hybrid algorithms (forward checking, and maintaining arc consistency).

Backjumping for Quantified Boolean Logic satisfiability

The implementation of effective reasoning tools for deciding the satisfiability of Quantified Boolean Formulas (QBFs) is an important research issue in Artificial Intelligence. Many decision procedures have been proposed in the last few years, most of them based on the Davis, Logemann, Loveland procedure (DLL) for propositional satisfiability (SAT). In this paper we show how it is possible to extend the conflict-directed backjumping schema for SAT to the satisfiability of QBFs: When applicable, conflict-directed backjumping allows search to skip over existentially quantified literals while backtracking. We introduce solution-directed backjumping, which allows the same behavior for universally quantified literals. We show how it is possible to incorporate both conflict-directed and solution-directed backjumping in a DLL-based decision procedure for satisfiability of QBFs. We also implement and test the procedure: The experimental analysis shows that, because of backjumping, significant speed-ups can be obtained. Summing up: We present the first algorithm that applies conflict and solution directed backjumping to QBF, and demonstrate the performance of this algorithm via an empirical study.

Determining if (FC-) (conflict-directed) backjumping visits a given node is NP-hard

Conflict-directed backjumping is a modification of the backtracking algorithm that can outperform forward checking in non-pathological examples. We prove it is in general NP-hard to determine if backjumping or conflict-directed backjumping or their forward checking hybrids visit a given node of a search space. This shows that these algorithms are fundamentally more complex to analyze than backtracking and forward checking. We conclude by describing how similar results can be proved for versions of the Maintaining Arc Consistency algorithm.

Combining Preorder and Postorder Resolution in a Satisfiability Solver

Abstract Abstract Recently, the classical backtracking-search satisfiability algorithm of Davis, Putnam, Loveland and Logemann (DPLL) has been enhanced in two distinct directions: with more advanced reasoning methods, or with conflict-directed back-jumping (CBJ). Previous methods used one idea or the other, but not both (except that CBJ has been combined with the unit-clause rule). The difficulty is that more advanced reasoning derives new clauses, but does not identify which backtrackable assumptions were relevant for the derivation. However CBJ needs this information. The linear-time decision procedure for binary-clause formulas is a good example of this phenomenon. This paper describes an efficient method to integrate several popular reasoning methods with CBJ. It includes binary-clause reasoning, equivalent-literal identification, variable-elimination resolution, and others. The main idea is to exploit the fact that DPLL can be viewed as an algorithm to construct a resolution refutation, rather than as backtracking-search for a model. Conflict sets in CBJ correspond to clauses in the resolution refutation. Incorporating advanced reasoning into this dual view of DPLL shows the way to combine it soundly with CBJ. Experiments show that the search space is reduced, but that memory has to be managed extremely carefully. This work was supported in part by NSF grants CCR-8958590 and CCR-9503830, by equipment donations from Sun Microsystems, Inc., and software donations from Quintus Computer Systems, Inc.

Conflict-Directed Backjumping Revisited

In recent years, many improvements to backtracking algorithms for solving constraint satisfaction problems have been proposed. The techniques for improving backtracking algorithms can be conveniently classified as look-ahead schemes and look-back schemes. Unfortunately, look-ahead and look-back schemes are not entirely orthogonal as it has been observed empirically that the enhancement of look-ahead techniques is sometimes counterproductive to the effects of look-back techniques. In this paper, we focus on the relationship between the two most important look-ahead techniques---using a variable ordering heuristic and maintaining a level of local consistency during the backtracking search---and the look-back technique of conflict-directed backjumping (CBJ). We show that there exists a ``perfect'' dynamic variable ordering such that CBJ becomes redundant. We also show theoretically that as the level of local consistency that is maintained in the backtracking search is increased, the less that backjumping will be an improvement. Our theoretical results partially explain why a backtracking algorithm doing more in the look-ahead phase cannot benefit more from the backjumping look-back scheme. Finally, we show empirically that adding CBJ to a backtracking algorithm that maintains generalized arc consistency (GAC), an algorithm that we refer to as GAC-CBJ, can still provide orders of magnitude speedups. Our empirical results contrast with Bessiere and Regin's conclusion (1996) that CBJ is useless to an algorithm that maintains arc consistency.

Conflict-directed backjumping revisited

In recent years, many improvements to backtracking algorithms for solving constraint satisfaction problems have been proposed. The techniques for improving backtracking algorithms can be convenient...

Search algorithms in type theory

In this paper, we take an abstract view of search by describing search procedures via particular kinds of proofs in type theory. We rely on the proofs-as-programs interpretation to extract programs from our proofs. Using these techniques we explore, in depth, a large family of search problems by parameterizing the specification of the problem. A constructive proof is presented which has as its computational content a correct search procedure for these problems. We show how a classical extension to an otherwise constructive system can be used to describe a typical use of the nonlocal control operator call/cc. Using the classical typing of nonlocal control we extend our purely constructive proof to incorporate a sophisticated backtracking technique known as ‘conflict-directed backjumping’ (CBJ). A variant of this proof is formalized in Nuprl yielding a correct-by-construction implementation of CBJ. The extracted program has been translated into Scheme and serves as the basis for an implementation of a new solution to the Hamiltonian circuit problem. This paper demonstrates a nontrivial application of the proofs-as-programs paradigm by applying the technique to the derivation of a sophisticated search algorithm; also, it shows the generality of the resulting implementation by demonstrating its application in a new problem domain for CBJ.

A theoretical evaluation of selected backtracking algorithms

In recent years, many new backtracking algorithms for solving constraint satisfaction problems have been proposed. The algorithms are usually evaluated by empirical testing. This method, however, has its limitations. Our paper adopts a different, purely theoretical approach, which is based on characterizations of the sets of search tree nodes visited by the backtracking algorithms. A notion of inconsistency between instantiations and variables is introduced, and is shown to be a useful tool for characterizing such well-known concepts as backtrack, backjump, and domain annihilation. The characterizations enable us to: (a) prove the correctness of the algorithms, and (b) partially order the algorithms according to two standard performance measures: the number of nodes visited, and the number of consistency checks performed. Among other results, we prove the correctness of Backjumping and Conflict-Directed Backjumping, and show that Forward Checking never visits more nodes than Backjumping. Our approach leads us also to propose a modification to two hybrid backtracking algorithms, Backmarking with Backjumping (BMJ) and Backmarking with Conflict-Directed Backjumping (BM-CBJ), so that they always perform fewer consistency checks than the original algorithms.

APACS: A performance measurement architecture for constraint satisfaction

This paper presents a performance measurement architecture for objectively evaluating constraint atisfaction techniques. It examines and analyses the overheads involved in using the assumption-based dependency directed backtracking for solving constraint satisfaction problems. The problem of using a functional representation of contraints in the evaluation is described. To overcome this, an interactive performance measurement architecture has been developed to allow the benchmarking of new algorithms, for which assumption-based directed dependency backtracking, chronological backtracking, forward checking, conflict-directed backjumping and forward checking with conflict-directed backjumping are used for preliminary experimentation.

HYBRID ALGORITHMS FOR THE CONSTRAINT SATISFACTION PROBLEM

It might be said that there are five basic tree search algorithms for the constraint satisfaction problem (csp), namely, naive backtracking (BT), backjumping (BJ), conflict‐directed backjumping (CBJ), backmarking (BM), and forward checking (FC). In broad terms, BT, BJ, and CBJ describe different styles of backward move (backtracking), whereas BT, BM, and FC describe different styles of forward move (labeling of variables). This paper presents an approach that allows base algorithms to be combined, giving us new hybrids. The base algorithms are described explicitly, in terms of a forward move and a backward move. It is then shown that the forward move of one algorithm may be combined with the backward move of another, giving a new hybrid. In total, four hybrids are presented: backmarking with backjumping (BMJ), backmarking with conflict‐directed backjumping (BM‐CBJ), forward checking with backjumping (FC‐BJ), and forward checking with conflict‐directed backjumping (FC‐CBJ). The performances of the nine algorithms (BT, BJ, CBJ, BM, BMJ, BM‐CBJ, FC, FC‐BJ, FC‐CBJ) are compared empirically, using 450 instances of the ZEBRA problem, and it is shown that FC‐CBJ is by far the best of the algorithms examined.