Relevant bibliographies by topics / Logic Constraints / Journal articles
To see the other types of publications on this topic, follow the link: Logic Constraints.

Journal articles on the topic 'Logic Constraints'

Author: Grafiati
Published: 10 March 2023

Create a spot-on reference in APA, MLA, Chicago, Harvard, and other styles

Select a source type:

Consult the top 50 journal articles for your research on the topic 'Logic Constraints.'

Next to every source in the list of references, there is an 'Add to bibliography' button. Press on it, and we will generate automatically the bibliographic reference to the chosen work in the citation style you need: APA, MLA, Harvard, Chicago, Vancouver, etc.

You can also download the full text of the academic publication as pdf and read online its abstract whenever available in the metadata.

Browse journal articles on a wide variety of disciplines and organise your bibliography correctly.

1

FAGES, FRANÇOIS, and EMMANUEL COQUERY. "Typing constraint logic programs." Theory and Practice of Logic Programming 1, no. 6 (November 2001): 751–77. http://dx.doi.org/10.1017/s1471068401001120.

Full text
Abstract:
We present a prescriptive type system with parametric polymorphism and subtyping for constraint logic programs. The aim of this type system is to detect programming errors statically. It introduces a type discipline for constraint logic programs and modules, while maintaining the capabilities of performing the usual coercions between constraint domains, and of typing meta-programming predicates, thanks to the exibility of subtyping. The property of subject reduction expresses the consistency of a prescriptive type system w.r.t. the execution model: if a program is ‘well-typed’, then all derivations starting from a ‘well-typed’ goal are again ‘well-typed’. That property is proved w.r.t. the abstract execution model of constraint programming which proceeds by accumulation of constraints only, and w.r.t. an enriched execution model with type constraints for substitutions. We describe our implementation of the system for type checking and type inference. We report our experimental results on type checking ISO-Prolog, the (constraint) libraries of Sicstus Prolog and other Prolog programs.
APA, Harvard, Vancouver, ISO, and other styles
2

DUNDUA, BESIK, MÁRIO FLORIDO, TEMUR KUTSIA, and MIRCEA MARIN. "CLP(H):Constraint logic programming for hedges." Theory and Practice of Logic Programming 16, no. 2 (April 16, 2015): 141–62. http://dx.doi.org/10.1017/s1471068415000071.

Full text
Abstract:
AbstractCLP(H) is an instantiation of the general constraint logic programming scheme with the constraint domain of hedges. Hedges are finite sequences of unranked terms, built over variadic function symbols and three kinds of variables: for terms, for hedges, and for function symbols. Constraints involve equations between unranked terms and atoms for regular hedge language membership. We study algebraic semantics of CLP(H) programs, define a sound, terminating, and incomplete constraint solver, investigate two fragments of constraints for which the solver returns a complete set of solutions, and describe classes of programs that generate such constraints.
APA, Harvard, Vancouver, ISO, and other styles
3

APT, KRZYSZTOF R., and ERIC MONFROY. "Constraint programming viewed as rule-based programming." Theory and Practice of Logic Programming 1, no. 6 (November 2001): 713–50. http://dx.doi.org/10.1017/s1471068401000072.

Full text
Abstract:
We study here a natural situation when constraint programming can be entirely reduced to rule-based programming. To this end we explain first how one can compute on constraint satisfaction problems using rules represented by simple first-order formulas. Then we consider constraint satisfaction problems that are based on predefined, explicitly given constraints. To solve them we first derive rules from these explicitly given constraints and limit the computation process to a repeated application of these rules, combined with labeling. We consider two types of rule here. The first type, that we call equality rules, leads to a new notion of local consistency, called rule consistency that turns out to be weaker than arc consistency for constraints of arbitrary arity (called hyper-arc consistency in Marriott & Stuckey (1998)). For Boolean constraints rule consistency coincides with the closure under the well-known propagation rules for Boolean constraints. The second type of rules, that we call membership rules, yields a rule-based characterization of arc consistency. To show feasibility of this rule-based approach to constraint programming, we show how both types of rules can be automatically generated, as CHR rules of Frühwirth (1995). This yields an implementation of this approach to programming by means of constraint logic programming. We illustrate the usefulness of this approach to constraint programming by discussing various examples, including Boolean constraints, two typical examples of many valued logics, constraints dealing with Waltz's language for describing polyhedral scenes, and Allen's qualitative approach to temporal logic.
APA, Harvard, Vancouver, ISO, and other styles
4

ZHENG, LEI, CHUNNIAN LIU, DONG JIA, and NING ZHONG. "GENERATING NUMERICAL CONSTRAINTS IN CILP." International Journal of Pattern Recognition and Artificial Intelligence 19, no. 01 (February 2005): 91–108. http://dx.doi.org/10.1142/s0218001405003946.

Full text
Abstract:
A continuing problem with inductive logic programming (ILP) has been the poor handling of numbers. Constraint inductive logic programming (CILP) aims to solve this problem with ILP. We propose a new approach to generating numerical constraints in CILP, and describe an implementation of the CILP system (namely, BPU-CILP). In our approach, methods from pattern recognition and multivariate data analysis, such as Fisher's linear discriminant, dynamic clustering and principal component analysis, are introduced into CILP. The BPU-CILP can generate various forms of polynomial constraints of multiple dimensions, without additional background knowledge. As a result, the constraint logic program covering all positive examples and consistent with all negative examples can be derived automatically.
APA, Harvard, Vancouver, ISO, and other styles
5

MANCARELLA, PAOLO, GIACOMO TERRENI, FARIBA SADRI, FRANCESCA TONI, and ULLE ENDRISS. "The CIFF proof procedure for abductive logic programming with constraints: Theory, implementation and experiments." Theory and Practice of Logic Programming 9, no. 6 (August 14, 2009): 691–750. http://dx.doi.org/10.1017/s1471068409990093.

Full text
Abstract:
AbstractWe present the CIFF proof procedure for abductive logic programming with constraints, and we prove its correctness. CIFF is an extension of the IFF proof procedure for abductive logic programming, relaxing the original restrictions over variable quantification (allowedness conditions) and incorporating a constraint solver to deal with numerical constraints as in constraint logic programming. Finally, we describe the CIFF system, comparing it with state-of-the-art abductive systems and answer set solvers and showing how to use it to program some applications.
APA, Harvard, Vancouver, ISO, and other styles
6

Fox, A., C. T. Spracklen, and C. P. Jolly. "Logic synthesis with constraints." Microprocessing and Microprogramming 24, no. 1-5 (August 1988): 339–46. http://dx.doi.org/10.1016/0165-6074(88)90076-2.

Full text
APA, Harvard, Vancouver, ISO, and other styles
7

Monfroglio, Angelo. "Logic decisions under constraints." Decision Support Systems 11, no. 3 (March 1994): 259–81. http://dx.doi.org/10.1016/0167-9236(94)90076-0.

Full text
APA, Harvard, Vancouver, ISO, and other styles
8

Bergenti, Federico, Stefania Monica, and Gianfranco Rossi. "Constraint Logic Programming with Polynomial Constraints over Finite Domains." Fundamenta Informaticae 161, no. 1-2 (July 2, 2018): 9–27. http://dx.doi.org/10.3233/fi-2018-1693.

Full text
APA, Harvard, Vancouver, ISO, and other styles
9

Sitek, Pawel, and Jaroslaw Wikarek. "A Hybrid Method for the Modelling and Optimisation of Constrained Search Problems." Foundations of Management 5, no. 3 (August 21, 2014): 7–22. http://dx.doi.org/10.2478/fman-2014-0016.

Full text
Abstract:
AbstractThe paper presents a concept and the outline of the implementation of a hybrid approach to modelling and solving constrained problems. Two environments of mathematical programming (in particular, integer programming) and declarative programming (in particular, constraint logic programming) were integrated. The strengths of integer programming and constraint logic programming, in which constraints are treated in a different way and different methods are implemented, were combined to use the strengths of both. The hybrid method is not worse than either of its components used independently. The proposed approach is particularly important for the decision models with an objective function and many discrete decision variables added up in multiple constraints. To validate the proposed approach, two illustrative examples are presented and solved. The first example is the authors’ original model of cost optimisation in the supply chain with multimodal transportation. The second one is the two-echelon variant of the well-known capacitated vehicle routing problem.
APA, Harvard, Vancouver, ISO, and other styles
10

Kozen, Dexter. "Set Constraints and Logic Programming." Information and Computation 142, no. 1 (April 1998): 2–25. http://dx.doi.org/10.1006/inco.1997.2694.

Full text
APA, Harvard, Vancouver, ISO, and other styles
11

Asirelli, Patrizia, Michelle De Santis, and Maurizio Martelli. "Integrity constraints in logic databases." Journal of Logic Programming 2, no. 3 (October 1985): 221–32. http://dx.doi.org/10.1016/0743-1066(85)90020-2.

Full text
APA, Harvard, Vancouver, ISO, and other styles
12

PIMENTEL, ELAINE, CARLOS OLARTE, and VIVEK NIGAM. "A Proof Theoretic Study of Soft Concurrent Constraint Programming." Theory and Practice of Logic Programming 14, no. 4-5 (July 2014): 649–63. http://dx.doi.org/10.1017/s147106841400026x.

Full text
Abstract:
AbstractConcurrent Constraint Programming (CCP) is a simple and powerful model for concurrency where agents interact by telling and asking constraints. Since their inception, CCP-languages have been designed for having a strong connection to logic. In fact, the underlying constraint system can be built from a suitable fragment of intuitionistic (linear) logic -ILL- and processes can be interpreted as formulas in ILL. Constraints as ILL formulas fail to represent accurately situations where “preferences” (called soft constraints) such as probabilities, uncertainty or fuzziness are present. In order to circumvent this problem, c-semirings have been proposed as algebraic structures for defining constraint systems where agents are allowed to tell and ask soft constraints. Nevertheless, in this case, the tight connection to logic and proof theory is lost. In this work, we give a proof theoretical meaning to soft constraints: they can be defined as formulas in a suitable fragment of ILL with subexponentials (SELL) where subexponentials, ordered in a c-semiring structure, are interpreted as preferences. We hence achieve two goals: (1) obtain a CCP language where agents can tell and ask soft constraints and (2) prove that the language in (1) has a strong connection with logic. Hence we keep a declarative reading of processes as formulas while providing a logical framework for soft-CCP based systems. An interesting side effect of (1) is that one is also able to handle probabilities (and other modalities) in SELL, by restricting the use of the promotion rule for non-idempotent c-semirings.This finer way of controlling subexponentials allows for considering more interesting spaces and restrictions, and it opens the possibility of specifying more challenging computational systems.
APA, Harvard, Vancouver, ISO, and other styles
13

FERNÁNDEZ, ANTONIO J., TERESA HORTALÁ-GONZÁLEZ, FERNANDO SÁENZ-PÉREZ, and RAFAEL DEL VADO-VÍRSEDA. "Constraint functional logic programming over finite domains." Theory and Practice of Logic Programming 7, no. 5 (September 2007): 537–82. http://dx.doi.org/10.1017/s1471068406002924.

Full text
Abstract:
AbstractIn this paper, we present our proposal to Constraint Functional Logic Programming over Finite Domains (CFLP($\fd$)) with a lazy functional logic programming language which seamlessly embodies finite domain ($\fd$) constraints. This proposal increases the expressiveness and power of constraint logic programming over finite domains (CLP($\fd$)) by combining functional and relational notation, curried expressions, higher-order functions, patterns, partial applications, non-determinism, lazy evaluation, logical variables, types, domain variables, constraint composition, and finite domain constraints. We describe the syntax of the language, its type discipline, and its declarative and operational semantics. We also describe\toy(fd)$, an implementation forCFLP($\fd$), and a comparison of our approach with respect toCLP($\fd$) from a programming point of view, showing the new features we introduce. And, finally, we show a performance analysis which demonstrates that our implementation is competitive with respect to existingCLP($\fd$) systems and that clearly outperforms the closer approach toCFLP($\fd$).
APA, Harvard, Vancouver, ISO, and other styles
14

Chen, X., H. Hsieh, F. Balarin, and Y. Watanabe. "Logic of Constraints: A Quantitative Performance and Functional Constraint Formalism." IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems 23, no. 8 (August 2004): 1243–55. http://dx.doi.org/10.1109/tcad.2004.831575.

Full text
APA, Harvard, Vancouver, ISO, and other styles
15

FIERBINTEANU, CRISTINA. "CONSTRAINT LOGIC PROGRAMMING APPROACH OF NETWORK FLOW PROBLEMS WITHIN A DECISION SUPPORT SYSTEMS GENERATOR FOR TRANSPORTATION PLANNIG." International Journal on Artificial Intelligence Tools 07, no. 04 (December 1998): 453–62. http://dx.doi.org/10.1142/s0218213098000214.

Full text
Abstract:
In this paper we propose a model of a decision support systems (DSS) generator for unstructured problems. The model is developed within the constraint logic programming (CLP) paradigm. At the center of the generator there is an ontology defining the concepts and relationships necessary and sufficient to describe the domain to be reasoned about, in a manner suitable for a particular class of tasks. The constraint solver of the constraint logic programming host language has to be extended with constraints which are relevant to the domain studied, but can not be found among the general constraints provided by the constraint solver. The domain of transportation planning was chosen to illustrate the proposed concept of DSS generator for ustructured problems. In this case we need to extend the constraint solver with constraint manipulation techniques specific to network flow problems. This paper presents in detail our constraint logic programming approach of network flow problems.
APA, Harvard, Vancouver, ISO, and other styles
16

VOLIOTIS, C., N. M. SGOUROS, and G. PAPAKONSTANTINOU. "ATTRIBUTE GRAMMAR BASED MODELING OF CONCURRENT CONSTRAINT LOGIC PROGRAMMING." International Journal on Artificial Intelligence Tools 04, no. 03 (September 1995): 383–411. http://dx.doi.org/10.1142/s021821309500019x.

Full text
Abstract:
The development of more powerful Concurrent Constraint Logic Programming (CCLP) languages depends largely on the development of environments that facilitate the specification and integration of constraints in the semantics of a logic program and automatically extract the inherent parallelism of Logic Programming. This paper presents a novel method for automating the parallel AND/OR execution of CCLP applications. This method consists of two stages. The first stage translates a logic program into an equivalent Attribute Grammar providing a common language in which the specifications of constraints and the semantics of a logic program can be expressed. The second stage evaluates this Attribute Grammar using MPAGE, a Multipass Parallel Attribute Grammar Evaluation algorithm. Support for the processing of constraints in the logic program is provided with the creation of a dependency graph between the variables of a logic rule during the first stage. Using this dependency graph MPAGE delays, if necessary, the evaluation of variables in a constraint until they become bound at some later point in processing. As a result our method supports rule representations in CLP languages with no restrictions on the ordering of subgoals. Furthermore, during execution MPAGE allows single rules in a CLP program to deal with multiple assignments of bindings, thus generating a minimal number of processes. Finally, this method is independent from the underlying hardware and its memory organization, therefore it can be implemented on both shared and distributed memory systems.
APA, Harvard, Vancouver, ISO, and other styles
17

ABDENNADHER, SLIM, and CHRISTOPHE RIGOTTI. "AUTOMATIC GENERATION OF RULE-BASED SOLVERS FOR INTENTIONALLY DEFINED CONSTRAINTS." International Journal on Artificial Intelligence Tools 11, no. 02 (June 2002): 283–302. http://dx.doi.org/10.1142/s0218213002000903.

Full text
Abstract:
A general approach to implement propagation and simplification of constraints consists of applying rules over these constraints. However, a difficulty that arises frequently when writing a constraint solver is to determine the constraint propagation algorithm. In previous work, different methods for automatic generation of rule-based solvers for constraints defined over finite domains have been proposed1,2,3,4. In this paper, we present a method for generating rule-based solvers for constraint predicates defined by means of a constraint logic program, even when the constraint domain is infinite.
APA, Harvard, Vancouver, ISO, and other styles
18

ZHANG, YUANLIN, and ROLAND H. C. YAP. "Solving functional constraints by variable substitution." Theory and Practice of Logic Programming 11, no. 2-3 (February 4, 2011): 297–322. http://dx.doi.org/10.1017/s1471068410000591.

Full text
Abstract:
AbstractFunctional constraints and bi-functional constraints are an important constraint class in Constraint Programming (CP) systems, in particular for Constraint Logic Programming (CLP) systems. CP systems with finite domain constraints usually employ Constraint Satisfaction Problem(s)-based solvers which use local consistency, for example, arc consistency. We introduce a new approach which is based instead on variable substitution. We obtain efficient algorithms for reducing systems involving functional and bi-functional constraints together with other nonfunctional constraints. It also solves globally any CSP where there exists a variable such that any other variable is reachable from it through a sequence of functional constraints. Our experiments on random problems show that variable elimination can significantly improve the efficiency of solving problems with functional constraints.
APA, Harvard, Vancouver, ISO, and other styles
19

MAHER, MICHAEL J. "Contractibility for open global constraints." Theory and Practice of Logic Programming 17, no. 4 (June 27, 2017): 365–407. http://dx.doi.org/10.1017/s1471068417000126.

Full text
Abstract:
AbstractOpen forms of global constraints allow the addition of new variables to an argument during the execution of a constraint program. Such forms are needed for difficult constraint programming problems, where problem construction and problem solving are interleaved, and fit naturally within constraint logic programming. However, in general, filtering that is sound for a global constraint can be unsound when the constraint is open. This paper provides a simple characterization, called contractibility, of the constraints, where filtering remains sound when the constraint is open. With this characterization, we can easily determine whether a constraint has this property or not. In the latter case, we can use it to derive a contractible approximation to the constraint. We demonstrate this work on both hard and soft constraints. In the process, we formulate two general classes of soft constraints.
APA, Harvard, Vancouver, ISO, and other styles
20

Geibinger, Tobias, Florian Mischek, and Nysret Musliu. "Constraint Logic Programming for Real-World Test Laboratory Scheduling." Proceedings of the AAAI Conference on Artificial Intelligence 35, no. 7 (May 18, 2021): 6358–66. http://dx.doi.org/10.1609/aaai.v35i7.16789.

Full text
Abstract:
The Test Laboratory Scheduling Problem (TLSP) and its subproblem TLSP-S are real-world industrial scheduling problems that are extensions of the Resource-Constrained Project Scheduling Problem (RCPSP). Besides several additional constraints, TLSP includes a grouping phase where the jobs to be scheduled have to be assembled from smaller tasks and derive their properties from this grouping. For TLSP-S such a grouping is already part of the input. In this work, we show how TLSP-S can be solved by Answer-set Programming extended with ideas from other constraint solving paradigms. We propose a novel and efficient encoding and apply an answer-set solver for constraint logic programs called clingcon. Additionally, we utilize our encoding in a Very Large Neighborhood Search framework and compare our methods with the state of the art approaches. Our approach provides new upper bounds and optimality proofs for several existing benchmark instances in the literature.
APA, Harvard, Vancouver, ISO, and other styles
21

Coroianu, Lucian, Robert Fullér, Marek Gagolewski, and Simon James. "Constrained ordered weighted averaging aggregation with multiple comonotone constraints." Fuzzy Sets and Systems 395 (September 2020): 21–39. http://dx.doi.org/10.1016/j.fss.2019.09.006.

Full text
APA, Harvard, Vancouver, ISO, and other styles
22

Brunel, Julien, David Chemouil, Alcino Cunha, and Nuno Macedo. "Simulation under Arbitrary Temporal Logic Constraints." Electronic Proceedings in Theoretical Computer Science 310 (December 23, 2019): 63–69. http://dx.doi.org/10.4204/eptcs.310.7.

Full text
APA, Harvard, Vancouver, ISO, and other styles
23

Christiansen, Henning, and Davide Martinenghi. "Symbolic constraints for meta-logic programming." Applied Artificial Intelligence 14, no. 4 (April 2000): 345–67. http://dx.doi.org/10.1080/088395100117034.

Full text
APA, Harvard, Vancouver, ISO, and other styles
24

Delugach, Harry S. "Representing metadata constraints in Common Logic." International Journal of Metadata, Semantics and Ontologies 4, no. 4 (2009): 277. http://dx.doi.org/10.1504/ijmso.2009.029231.

Full text
APA, Harvard, Vancouver, ISO, and other styles
25

Lukasiewicz, Thomas. "Probabilistic logic programming with conditional constraints." ACM Transactions on Computational Logic 2, no. 3 (July 2001): 289–339. http://dx.doi.org/10.1145/377978.377983.

Full text
APA, Harvard, Vancouver, ISO, and other styles
26

Lakmazaheri, Sivand, and William J. Rasdorf. "Constraint logic programming for the analysis and partial synthesis of truss structures." Artificial Intelligence for Engineering Design, Analysis and Manufacturing 3, no. 3 (August 1989): 157–73. http://dx.doi.org/10.1017/s0890060400001207.

Full text
Abstract:
A general constraint-based formulation for the analysis and partial synthesis of two-dimensional truss structures is presented. This formulation is general in that it handles statically determinate and statically indeterminate trusses with pin and roller supports, and concentrated joint loads. The formulation is constraint-based in that the physical behavior of truss components is declaratively represented using constraints.The analysis and partial synthesis of a truss structure manifest themselves in proving the satisfiability of the constraints associated with the structural components. An artificial intelligence approach called constraint logic programming is used for representing and satisfying constraints. A constraint logic programming language, called CLP(R), is used for implementing the formulation. The implemented program consists of sixteen rules. These rules are used for both the analysis and partial synthesis of truss structures. Several truss analysis and synthesis examples using the formulation are presented.
APA, Harvard, Vancouver, ISO, and other styles
27

Ligęza, Antoni. "Models and Tools for Improving Efficiency in Constraint Logic Programming." Decision Making in Manufacturing and Services 5, no. 1 (October 3, 2011): 69–78. http://dx.doi.org/10.7494/dmms.2011.5.1.69.

Full text
Abstract:
Constraint Satisfaction Problems typically exhibit strong combinatorial explosion. In this paper we present some models and techniques aimed at improving efficiency in Constraint Logic Programming. A hypergraph model of constraints is presented and an outline of strategy planning approach focused on entropy minimization is put forward. An example cryptoaritmetic problem is explored in order to explain the proposed approach.
APA, Harvard, Vancouver, ISO, and other styles
28

CHRISTIANSEN, HENNING, CHRISTIAN THEIL HAVE, OLE TORP LASSEN, and MATTHIEU PETIT. "Inference with constrained hidden Markov models in PRISM." Theory and Practice of Logic Programming 10, no. 4-6 (July 2010): 449–64. http://dx.doi.org/10.1017/s1471068410000219.

Full text
Abstract:
AbstractA Hidden Markov Model (HMM) is a common statistical model which is widely used for analysis of biological sequence data and other sequential phenomena. In the present paper we show how HMMs can be extended with side-constraints and present constraint solving techniques for efficient inference. Defining HMMs with side-constraints in Constraint Logic Programming has advantages in terms of more compact expression and pruning opportunities during inference. We present a PRISM-based framework for extending HMMs with side-constraints and show how well-known constraints such as cardinality and all_different are integrated. We experimentally validate our approach on the biologically motivated problem of global pairwise alignment.
APA, Harvard, Vancouver, ISO, and other styles
29

Gnecco, Giorgio, Marco Gori, Stefano Melacci, and Marcello Sanguineti. "Foundations of Support Constraint Machines." Neural Computation 27, no. 2 (February 2015): 388–480. http://dx.doi.org/10.1162/neco_a_00686.

Full text
Abstract:
The mathematical foundations of a new theory for the design of intelligent agents are presented. The proposed learning paradigm is centered around the concept of constraint, representing the interactions with the environment, and the parsimony principle. The classical regularization framework of kernel machines is naturally extended to the case in which the agents interact with a richer environment, where abstract granules of knowledge, compactly described by different linguistic formalisms, can be translated into the unified notion of constraint for defining the hypothesis set. Constrained variational calculus is exploited to derive general representation theorems that provide a description of the optimal body of the agent (i.e., the functional structure of the optimal solution to the learning problem), which is the basis for devising new learning algorithms. We show that regardless of the kind of constraints, the optimal body of the agent is a support constraint machine (SCM) based on representer theorems that extend classical results for kernel machines and provide new representations. In a sense, the expressiveness of constraints yields a semantic-based regularization theory, which strongly restricts the hypothesis set of classical regularization. Some guidelines to unify continuous and discrete computational mechanisms are given so as to accommodate in the same framework various kinds of stimuli, for example, supervised examples and logic predicates. The proposed view of learning from constraints incorporates classical learning from examples and extends naturally to the case in which the examples are subsets of the input space, which is related to learning propositional logic clauses.
APA, Harvard, Vancouver, ISO, and other styles
30

Courtault, J. R., H. van Ditmarsch, and D. Galmiche. "A public announcement separation logic." Mathematical Structures in Computer Science 29, no. 06 (April 15, 2019): 828–71. http://dx.doi.org/10.1017/s0960129518000348.

Full text
Abstract:
AbstractWe define a Public Announcement Separation Logic (PASL) that allows us to consider epistemic possible worlds as resources that can be shared or separated, in the spirit of separation logics. After studying its semantics and illustrating its interest for modelling systems, we provide a sound and complete tableau calculus that deals with resource, agent and announcement constraints and give also a countermodel extraction method.
APA, Harvard, Vancouver, ISO, and other styles
31

LIU, GUOHUA, and JIA-HUAI YOU. "Relating weight constraint and aggregate programs: Semantics and representation." Theory and Practice of Logic Programming 13, no. 1 (June 30, 2011): 1–31. http://dx.doi.org/10.1017/s147106841100038x.

Full text
Abstract:
AbstractWeight constraint and aggregate programs are among the most widely used logic programs with constraints. In this paper, we relate the semantics of these two classes of programs, namely, the stable model semantics for weight constraint programs and the answer set semantics based on conditional satisfaction for aggregate programs. Both classes of programs are instances of logic programs with constraints, and in particular, the answer set semantics for aggregate programs can be applied to weight constraint programs. We show that the two semantics are closely related. First, we show that for a broad class of weight constraint programs, called strongly satisfiable programs, the two semantics coincide. When they disagree, a stable model admitted by the stable model semantics may be circularly justified. We show that the gap between the two semantics can be closed by transforming a weight constraint program to a strongly satisfiable one so that no circular models may be generated under the current implementation of the stable model semantics. We further demonstrate the close relationship between the two semantics by formulating a transformation from weight constraint programs to logic programs with nested expressions, which preserves the answer set semantics. Our study on the semantics leads to an investigation of a methodological issue, namely, the possibility of compact representation of aggregate programs by weight constraint programs. We show that almost all standard aggregates can be encoded by weight constraints compactly. This makes it possible to compute the answer sets of aggregate programs using the answer set programming solvers for weight constraint programs. This approach is compared experimentally with the ones where aggregates are handled more explicitly, which show that the weight constraint encoding of aggregates enables a competitive approach to answer set computation for aggregate programs.
APA, Harvard, Vancouver, ISO, and other styles
32

Yue, Michael, and Sara Tehranipoor. "A Novel Probability-Based Logic-Locking Technique: ProbLock." Sensors 21, no. 23 (December 4, 2021): 8126. http://dx.doi.org/10.3390/s21238126.

Full text
Abstract:
Integrated circuit (IC) piracy and overproduction are serious issues that threaten the security and integrity of a system. Logic locking is a type of hardware obfuscation technique where additional key gates are inserted into the circuit. Only the correct key can unlock the functionality of that circuit; otherwise, the system produces the wrong output. In an effort to hinder these threats on ICs, we have developed a probability-based logic-locking technique to protect the design of a circuit. Our proposed technique, called “ProbLock”, can be applied to both combinational and sequential circuits through a critical selection process. We used a filtering process to select the best location of key gates based on various constraints. Each step in the filtering process generates a subset of nodes for each constraint. We also analyzed the correlation between each constraint and adjusted the strength of the constraints before inserting key gates. We tested our algorithm on 40 benchmarks from the ISCAS ’85 and ISCAS ’89 suites. We evaluated ProbLock against a SAT attack and measured how long the attack took to successfully generate a key value. The SAT attack took longer for most benchmarks using ProbLock which proves viable security in hardware obfuscation.
APA, Harvard, Vancouver, ISO, and other styles
33

Sagi, Gil. "Logic in Natural Language: Commitments and Constraints." Disputatio 12, no. 58 (December 1, 2020): 277–308. http://dx.doi.org/10.2478/disp-2020-0014.

Full text
Abstract:
Abstract In his new book, Logical Form, Andrea Iacona distinguishes between two different roles that have been ascribed to the notion of logical form: the logical role and the semantic role. These two roles entail a bifurcation of the notion of logical form. Both notions of logical form, according to Iacona, are descriptive, having to do with different features of natural language sentences. I agree that the notion of logical form bifurcates, but not that the logical role is merely descriptive. In this paper, I focus on formalization, a process by which logical form, on its logical role, is attributed to natural language sentences. According to some, formalization is a form of explication, and it involves normative, pragmatic, as well as creative aspects. I present a view by which formalization involves explicit commitments on behalf of a reasoner or an interpreter, which serve the normative grounds for the evaluation of a given text. In previous work, I proposed the framework of semantic constraints for the explication of logical consequence. Here, I extend the framework to include formalization constraints. The various constraints then serve the role of commitments. I discuss specific issues raised by Iacona concerning univocality, co-reference and equivocation, and I show how our views on these matters diverge as a result of our different starting assumptions.
APA, Harvard, Vancouver, ISO, and other styles
34

Clarke, Dave, and José Proença. "Coordination via Interaction Constraints I: Local Logic." Electronic Proceedings in Theoretical Computer Science 12 (December 3, 2009): 17–39. http://dx.doi.org/10.4204/eptcs.12.2.

Full text
APA, Harvard, Vancouver, ISO, and other styles
35

Wirsing, Martin, Grit Denker, Carolyn Talcott, Andy Poggio, and Linda Briesemeister. "A Rewriting Logic Framework for Soft Constraints." Electronic Notes in Theoretical Computer Science 176, no. 4 (July 2007): 181–97. http://dx.doi.org/10.1016/j.entcs.2007.06.015.

Full text
APA, Harvard, Vancouver, ISO, and other styles
36

Combi, Carlo, Andrea Masini, Barbara Oliboni, and Margherita Zorzi. "A hybrid logic for XML reference constraints." Data & Knowledge Engineering 115 (May 2018): 94–115. http://dx.doi.org/10.1016/j.datak.2018.02.005.

Full text
APA, Harvard, Vancouver, ISO, and other styles
37

ARECES, CARLOS, DIEGO FIGUEIRA, SANTIAGO FIGUEIRA, and SERGIO MERA. "THE EXPRESSIVE POWER OF MEMORY LOGICS." Review of Symbolic Logic 4, no. 2 (June 2011): 290–318. http://dx.doi.org/10.1017/s1755020310000389.

Full text
Abstract:
We investigate the expressive power of memory logics. These are modal logics extended with the possibility to store (or remove) the current node of evaluation in (or from) a memory, and to perform membership tests on the current memory. From this perspective, the hybrid logic ℋℒ (↓), for example, can be thought of as a particular case of a memory logic where the memory is an indexed list of elements of the domain.This work focuses in the case where the memory is a set, and we can test whether the current node belongs to the set or not. We prove that, in terms of expressive power, the memory logics we discuss here lie between the basic modal logic ${\cal K}$ and ℋℒ (↓). We show that the satisfiability problem of most of the logics we cover is undecidable. The only logic with a decidable satisfiability problem is obtained by imposing strong constraints on which elements can be memorized.
APA, Harvard, Vancouver, ISO, and other styles
38

Xiong, Liping, and Sumei Guo. "Representation and Reasoning about Strategic Abilities with ω-Regular Properties." Mathematics 9, no. 23 (November 27, 2021): 3052. http://dx.doi.org/10.3390/math9233052.

Full text
Abstract:
Specification and verification of coalitional strategic abilities have been an active research area in multi-agent systems, artificial intelligence, and game theory. Recently, many strategic logics, e.g., Strategy Logic (SL) and alternating-time temporal logic (ATL*), have been proposed based on classical temporal logics, e.g., linear-time temporal logic (LTL) and computational tree logic (CTL*), respectively. However, these logics cannot express general ω-regular properties, the need for which are considered compelling from practical applications, especially in industry. To remedy this problem, in this paper, based on linear dynamic logic (LDL), proposed by Moshe Y. Vardi, we propose LDL-based Strategy Logic (LDL-SL). Interpreted on concurrent game structures, LDL-SL extends SL, which contains existential/universal quantification operators about regular expressions. Here we adopt a branching-time version. This logic can express general ω-regular properties and describe more programmed constraints about individual/group strategies. Then we study three types of fragments (i.e., one-goal, ATL-like, star-free) of LDL-SL. Furthermore, we show that prevalent strategic logics based on LTL/CTL*, such as SL/ATL*, are exactly equivalent with those corresponding star-free strategic logics, where only star-free regular expressions are considered. Moreover, results show that reasoning complexity about the model-checking problems for these new logics, including one-goal and ATL-like fragments, is not harder than those of corresponding SL or ATL*.
APA, Harvard, Vancouver, ISO, and other styles
39

SEOW, KIAM TIAN, and MICHEL PASQUIER. "Vehicle route-sequence planning using temporal logic." Artificial Intelligence for Engineering Design, Analysis and Manufacturing 16, no. 1 (January 2002): 31–38. http://dx.doi.org/10.1017/s0890060401020042.

Full text
Abstract:
This paper proposes a new logical framework for vehicle route-sequence planning of passenger travel requests. Each request is a fetch-and-send service task associated with two request-locations, namely, a source and a destination. The proposed framework is developed using propositional linear time temporal logic of Manna and Pnueli. The novelty lies in the use of the formal language for both the specification and theorem-proving analysis of precedence constraints among the location visits that are inherent in route sequences. In the framework, legal route sequences—each of which visits every request location once and only once in the precedence order of fetch-and-send associated with every such request—is formalized and justified, forming a basis upon which the link between a basic precedence constraint and the corresponding canonical forbidden-state formula is formally established. Over a given base route plan, a simple procedure to generate a feasible subplan based on a specification of the forbidden-state canonical form is also given. An example demonstrates how temporal logic analysis and the proposed procedure can be applied to select a final (feasible) subplan based on additional precedence constraints.
APA, Harvard, Vancouver, ISO, and other styles
40

LEACH, JAVIER, SUSANA NIEVA, and MARIO RODRÍGUEZ-ARTALEJO. "Constraint Logic Programming with Hereditary Harrop formulas." Theory and Practice of Logic Programming 1, no. 4 (June 25, 2001): 409–45. http://dx.doi.org/10.1017/s1471068401001041.

Full text
Abstract:
Constraint Logic Programming (CLP) and Hereditary Harrop formulas (HH) are two well known ways to enhance the expressivity of Horn clauses. In this paper, we present a novel combination of these two approaches. We show how to enrich the syntax and proof theory of HH with the help of a given constraint system, in such a way that the key property of HH as a logic programming language (namely, the existence of uniform proofs) is preserved. We also present a procedure for goal solving, showing its soundness and completeness for computing answer constraints. As a consequence of this result, we obtain a new strong completeness theorem for CLP that avoids the need to build disjunctions of computed answers, as well as a more abstract formulation of a known completeness theorem for HH.
APA, Harvard, Vancouver, ISO, and other styles
41

Christiansen, Henning, and Veronica Dahl. "Logic Grammars for Diagnosis and Repair." International Journal on Artificial Intelligence Tools 12, no. 03 (September 2003): 227–48. http://dx.doi.org/10.1142/s0218213003001216.

Full text
Abstract:
We propose an abductive model based on Constraint Handling Rule Grammars (CHRGs) for detecting and correcting errors in problem domains that can be described in terms of strings of words accepted by a logic grammar. We provide a proof of concept for the specific problem of detecting and repairing natural language errors, in particular, those concerning feature agreement. Our methodology relies on grammar and string transformation in accordance with a user-defined dictionary of possible repairs. This transformation also serves as top-down guidance for our essentially bottom-up parser. With respect to previous approaches to error detection and repair, including those that also use constraints and/or abduction, our methodology is surprisingly simple while far-reaching and efficient.
APA, Harvard, Vancouver, ISO, and other styles
42

Morel, Rolf. "Constraint-Driven Learning of Logic Programs." Proceedings of the AAAI Conference on Artificial Intelligence 35, no. 18 (May 18, 2021): 15726–27. http://dx.doi.org/10.1609/aaai.v35i18.17860.

Full text
Abstract:
Two fundamental challenges in program synthesis, i.e. learning programs from specifications, are (1) program correctness and (2) search efficiency. We claim logical constraints can address both: (1) by expressing strong requirements on solutions and (2) due to being effective at eliminating non-solutions. When learning from examples, a hypothesis failing on an example means that (a class of) related programs fail as well. We encode these classes into constraints, thereby pruning away many a failing hypothesis. We are expanding this method with failure explanation: identify failing sub-programs the related programs of which can be eliminated as well. In addition to reasoning about examples, programming involves ensuring general properties are not violated. Inspired by the synthesis of functional programs, we intend to encode correctness properties as well as runtime complexity bounds into constraints.
APA, Harvard, Vancouver, ISO, and other styles
43

SAGI, GIL. "INVARIANCE CRITERIA AS META-CONSTRAINTS." Bulletin of Symbolic Logic 28, no. 1 (December 2, 2021): 104–32. http://dx.doi.org/10.1017/bsl.2021.67.

Full text
Abstract:
AbstractInvariance criteria are widely accepted as a means to demarcate the logical vocabulary of a language. In previous work, I proposed a framework of “semantic constraints” for model-theoretic consequence which does not rely on a strict distinction between logical and nonlogical terms, but rather on a range of constraints on models restricting the interpretations of terms in the language in different ways. In this paper I show how invariance criteria can be generalized so as to apply to semantic constraints on models. Some obviously unpalatable semantic constraints turn out to be invariant under isomorphisms. I shall connect the discussion to known counter-examples to invariance criteria for logical terms, and so the generalization will also shed light on the current existing debate on logicality. I analyse the failure of invariance to fulfil its role as a criterion for logicality, and argue that invariance conditions should best be thought of as merely methodological meta-constraints restricting the ways the model-theoretic apparatus should be used.
APA, Harvard, Vancouver, ISO, and other styles
44

Cropper, Andrew, and Rolf Morel. "Learning programs by learning from failures." Machine Learning 110, no. 4 (February 19, 2021): 801–56. http://dx.doi.org/10.1007/s10994-020-05934-z.

Full text
Abstract:
AbstractWe describe an inductive logic programming (ILP) approach called learning from failures. In this approach, an ILP system (the learner) decomposes the learning problem into three separate stages: generate, test, and constrain. In the generate stage, the learner generates a hypothesis (a logic program) that satisfies a set of hypothesis constraints (constraints on the syntactic form of hypotheses). In the test stage, the learner tests the hypothesis against training examples. A hypothesis fails when it does not entail all the positive examples or entails a negative example. If a hypothesis fails, then, in the constrain stage, the learner learns constraints from the failed hypothesis to prune the hypothesis space, i.e. to constrain subsequent hypothesis generation. For instance, if a hypothesis is too general (entails a negative example), the constraints prune generalisations of the hypothesis. If a hypothesis is too specific (does not entail all the positive examples), the constraints prune specialisations of the hypothesis. This loop repeats until either (i) the learner finds a hypothesis that entails all the positive and none of the negative examples, or (ii) there are no more hypotheses to test. We introduce Popper, an ILP system that implements this approach by combining answer set programming and Prolog. Popper supports infinite problem domains, reasoning about lists and numbers, learning textually minimal programs, and learning recursive programs. Our experimental results on three domains (toy game problems, robot strategies, and list transformations) show that (i) constraints drastically improve learning performance, and (ii) Popper can outperform existing ILP systems, both in terms of predictive accuracies and learning times.
APA, Harvard, Vancouver, ISO, and other styles
45

DRESCHER, CHRISTIAN, and TOBY WALSH. "A translational approach to constraint answer set solving." Theory and Practice of Logic Programming 10, no. 4-6 (July 2010): 465–80. http://dx.doi.org/10.1017/s1471068410000220.

Full text
Abstract:
AbstractWe present a new approach to enhancing Answer Set Programming (ASP) with Constraint Processing techniques which allows for solving interesting Constraint Satisfaction Problems in ASP. We show how constraints on finite domains can be decomposed into logic programs such that unit-propagation achieves arc, bound or range consistency. Experiments with our encodings demonstrate their computational impact.
APA, Harvard, Vancouver, ISO, and other styles
46

WU, PENG, and HUIMIN LIN. "MODEL-BASED TESTING OF CONCURRENT PROGRAMS WITH PREDICATE SEQUENCING CONSTRAINTS." International Journal of Software Engineering and Knowledge Engineering 16, no. 05 (October 2006): 727–46. http://dx.doi.org/10.1142/s0218194006002999.

Full text
Abstract:
A predicate sequencing constraint logic (PSCL) is proposed to represent test purpose for concurrent program testing. The logic is capable of expressing not only sequencing relationships among input and output events, but also data dependencies between event parameters. A PSCL-based symbolic test generation method is developed to automatically derive symbolic test cases that incorporate given data dependency constraints as verdict conditions. The method works in a syntactic way without referring to concrete program states and the derived test cases allow dynamic test data selection according to the response from the software under test. The advantage of the approach is demonstrated with a case study.
APA, Harvard, Vancouver, ISO, and other styles
47

Alfano, Gianvincenzo, Sergio Greco, Francesco Parisi, and Irina Trubitsyna. "Argumentation Frameworks with Strong and Weak Constraints: Semantics and Complexity." Proceedings of the AAAI Conference on Artificial Intelligence 35, no. 7 (May 18, 2021): 6175–84. http://dx.doi.org/10.1609/aaai.v35i7.16768.

Full text
Abstract:
Dung's abstract Argumentation Framework (AF) has emerged as a central formalism in formal argumentation. Key aspects of the success and popularity of Dung's framework include its simplicity and expressiveness. Integrity constraints help to express domain knowledge in a compact and natural way, thus keeping easy the modeling task even for problems that otherwise would be hard to encode within an AF. In this paper, after providing an intuitive semantics based on Lukasiewicz's logic for AFs with (strong) constraints, called Constrained AFs (CAFs), we propose Weak constrained AFs (WAFs) that enhance CAFs with weak constraints. Intuitively, these constraints can be used to find ``optimal'' solutions to problems defined through CAFs. We provide a detailed complexity analysis of CAFs and WAFs, showing that strong constraints do not increase the expressive power of AFs in most cases, while weak constraints systematically increase the expressive power of CAFs under several well-known argumentation semantics.
APA, Harvard, Vancouver, ISO, and other styles
48

Law, Jess H.-K. "The Mereological Structure of Distributivity: A Case Study of Binominal Each." Journal of Semantics 39, no. 1 (January 31, 2022): 159–211. http://dx.doi.org/10.1093/jos/ffab022.

Full text
Abstract:
Abstract Binominal each is known to exhibit selectional requirements on the noun phrase that immediately precedes it. The goal of this paper is to reduce these selectional requirements to a single requirement of monotonic growth of measurement in relation to the ‘size’ of distributivity. More concretely, it is argued that binominal each imposes a constraint on the functional dependencies arising from distributive quantification, requiring that the measurement of its host grows monotonically with the number of values being distributively quantified. To make constraints on dependencies formally explicit, I devise a version of dynamic plural logic with features from van den Berg (1996) and Brasoveanu (2008, 2013) to semantically represent dependencies arising from evaluating distributive quantification. The use of a dynamic logic, coupled with a delayed evaluation mechanism in terms of higher order meaning (Cresti, 1995; Swart, 2000; Charlow, 2021, allows the constraint to act as an output context constraint on distributive quantification, which mirrors the use of output constraints pioneered by Farkas (1997, 2002b) and and further developed in Brasoveanu (2013), Henderson (2014) and Kuhn (2017).
APA, Harvard, Vancouver, ISO, and other styles
49

EITER, THOMAS, and RAFAEL KIESEL. "ASP (): Answer Set Programming with Algebraic Constraints." Theory and Practice of Logic Programming 20, no. 6 (September 22, 2020): 895–910. http://dx.doi.org/10.1017/s1471068420000393.

Full text
Abstract:
AbstractWeighted Logic is a powerful tool for the specification of calculations over semirings that depend on qualitative information. Using a novel combination of Weighted Logic and Here-and-There (HT) Logic, in which this dependence is based on intuitionistic grounds, we introduce Answer Set Programming with Algebraic Constraints (ASP($\mathcal A \mathcal C$)), where rules may contain constraints that compare semiring values to weighted formula evaluations. Such constraints provide streamlined access to a manifold of constructs available in ASP, like aggregates, choice constraints, and arithmetic operators. They extend some of them and provide a generic framework for defining programs with algebraic computation, which can be fruitfully used e.g. for provenance semantics of datalog programs. While undecidable in general, expressive fragments of ASP($\mathcal A \mathcal C$) can be exploited for effective problem solving in a rich framework.
APA, Harvard, Vancouver, ISO, and other styles
50

Zhou, Wen Bo, and Shu Zhen Yao. "Model Checking of Constraint-Based Workflow Based on Linear Temporal Logic." Advanced Materials Research 601 (December 2012): 401–5. http://dx.doi.org/10.4028/www.scientific.net/amr.601.401.

Full text
Abstract:
The degree of flexibility of workflow management systems heavily influences the way business processes are executed. Constraint-based models are considered to be more flexible than traditional models because of their semantics: everything that does not violate constraints is allowed. More and more people use declarative languages to define workflow, such as linear temporal logic. But how to guarantee the correctness of the model based on the linear temporal logic is still a problem. This article proposes a way to verify the model based on Büchi automaton and gives the corresponding algorithms. Thus the verification of declarative workflow based on the linear temporal logic is solved.
APA, Harvard, Vancouver, ISO, and other styles
You might also be interested in the bibliographies on the topic 'Logic Constraints' for other source types:
Dissertations / Theses Books
We offer discounts on all premium plans for authors whose works are included in thematic literature selections. Contact us to get a unique promo code!

To the bibliography