Global grammar constraints
Download
1 / 28

grammar - PowerPoint PPT Presentation


  • 426 Views
  • Updated On :

Toby Walsh National ICT Australia and University of New South Wales www.cse.unsw.edu.au/~tw Joint work with Claude-Guy Quimper To be presented at CP06. Global Grammar Constraints . Global grammar constraints. Often easy to specify a global constraint ALLDIFFERENT([X1,..Xn]) iff

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'grammar' - Patman


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
Global grammar constraints l.jpg

Toby Walsh

National ICT Australia and

University of New South Wales

www.cse.unsw.edu.au/~tw

Joint work with Claude-Guy Quimper

To be presented at CP06

Global Grammar Constraints


Global grammar constraints2 l.jpg
Global grammar constraints

  • Often easy to specify a global constraint

    • ALLDIFFERENT([X1,..Xn]) iff

      Xi=/=Xj for i<j

  • Difficult to build an efficient and effective propagator

    • Especially if we want global reasoning


Global grammar constraints3 l.jpg
Global grammar constraints

  • Promising direction initiated by Beldiceanu, Carlsson, Pesant and Petit is to specify constraints via automata/grammar

    • Sequence of variables =

      string in some formal language

    • Satisfying assignment =

      string accepted by the grammar/automata


Regular constraint l.jpg
REGULAR constraint

  • REGULAR(A,[X1,..Xn]) holds iff

    • X1 .. Xn is a string accepted by the deterministic finite automaton A

    • Proposed by Pesant at CP 2004

    • GAC algorithm using dynamic programming

    • However, DP is not needed since simple ternary encoding is just as efficient and effective

    • Encoding similar to that used by Beldiceanu et al for their automata with counters


Regular constraint5 l.jpg
REGULAR constraint

  • Deterministic finite automaton (DFA)

    • <Q,Sigma,T,q0,F>

    • Q is finite set of states

    • Sigma is alphabet (from which strings formed)

    • T is transition function: Q x Sigma -> Q

    • q0 is starting state

    • F subseteq Q are accepting states

  • DFAs accept precisely regular languages


Regular constraint6 l.jpg
REGULAR constraint

  • Many global constraints are instances of REGULAR

    • AMONG

    • CONTIGUITY

    • LEX

    • PRECEDENCE

    • STRETCH

    • ..

  • Domain consistency can be enforced in O(ndQ) time using dynamic programming


Regular constraint7 l.jpg
REGULAR constraint

  • REGULAR constraint can be encoded into ternary constraints

  • Introduce Qi+1

    • state of the DFA after the ith transition

  • Then post sequence of constraints

    • C(Xi,Qi,Qi+1) iff

      DFA goes from state Qi to Qi+1 on symbol Xi


Regular constraint8 l.jpg
REGULAR constraint

  • REGULAR constraint can be encoded into ternary constraints

  • Constraint graph is Berge-acyclic

    • Constraints only overlap on one variable

    • Enforcing GAC on ternary constraints achieves GAC on REGULAR in O(ndQ) time


Regular constraint9 l.jpg
REGULAR constraint

  • REGULAR constraint can be encoded into ternary constraints

  • Constraint graph is Berge-acyclic

    • Constraints only overlap on one variable

    • Enforcing GAC on ternary constraints achieves GAC on REGULAR in O(ndQ) time

  • Encoding provides access to states of automata

    • Can be useful for expressing problems

    • E.g. minimizing number of times we are in a particular state


Regular constraint10 l.jpg
REGULAR constraint

  • STRETCH([X1,..Xn]) holds iff

    • Any stretch of consecutive values is between shortest(v) and longest(v) length

    • Any change (v1,v2) is in some permitted set, P

    • For example, you can only have 3 consecutive night shifts and a night shift must be followed by a day off


Regular constraint11 l.jpg
REGULAR constraint

  • STRETCH([X1,..Xn]) holds iff

    • Any stretch of consecutive values is between shortest(v) and longest(v) length

    • Any change (v1,v2) is in some permitted set, P

  • DFA

    • Qi is <last value, length of current stretch>

    • Q0= <dummy,0>

    • T(<a,q>,a)=<a,q+1> if q+1<=longest(a)

    • T(<a,q>,b)=<b,1> if (a,b) in P and q>=shortest(a)

    • All states are accepting


Nfa constraint l.jpg
NFA constraint

  • Automaton does not need to be deterministic

  • Non-deterministic finite automaton (NFA) still only accept regular languages

    • But may require exponentially fewer states

    • Important as O(ndQ) running time for propagator

    • E.g. 0* (1|2)^k 2 (1|2)* 2 (1|2)^k 0*

    • Where 0=closed, 1=production, 2=maintenance

  • Can use the same ternary encoding


Soft regular constraint l.jpg
Soft REGULAR constraint

  • May wish to be “near” to a regular string

  • Near could be

    • Hamming distance

    • Edit distance

  • SoftREGULAR(A,[X1,..Xn],N) holds iff

    • X1..Xn is at distance N from a string accepted by the finite automaton A

    • Can encode this into a sequence of 5-ary constraints


Soft regular constraint14 l.jpg
Soft REGULAR constraint

  • SoftREGULAR(A,[X1,..Xn],N)

    • Consider Hamming distance (edit distance similar though a little more complex)

    • Qi+1 is state of automaton after the ith transition

    • Di+1 is Hamming distance up to the ith variable

    • Post sequence of constraints

      • C(Xi,Qi,Qi+1,Di,Di+1) where

      • Di+1=Di if T(Xi,Qi)=Qi+1 else Di+1=1+Di


Soft regular constraint15 l.jpg
Soft REGULAR constraint

  • SoftREGULAR(A,[X1,..Xn],N)

    • To propagate

    • Dynamic programming

      • Pass support along sequence

    • Just post the 5-ary constraints

      • Accept less than GAC

    • Tuple up the variables


Cyclic forms of regular l.jpg
Cyclic forms of REGULAR

  • REGULAR+(A,[X1,..,Xn])

    • X1 .. XnX1 is accepted by A

    • Can convert into REGULAR by increasing states by factor of d where d is number of initial symbols

    • qi => (qi,initial value)

    • T(qi,a)=qj => T((qi,b),a)=(qj,b)

    • Thereby pass along value taken by X1 so it can be checked on last transition


Cyclic forms of regular17 l.jpg
Cyclic forms of REGULAR

  • REGULARo(A,[X1,..,Xn])

    • Xi .. X1+(i+n-1)mod n is accepted by A for each 1<=i<=n

    • Can decompose into n instances of the REGULAR constraint

    • However, this hinders propagation

      • Suppose A accepts just alternating sequences of 0 and 1

      • Xi in {0,1} and REGULARo(A,[X1,X2.X3])

    • Unfortunately enforcing GAC on REGULARo is NP-hard


Cyclic forms of regular18 l.jpg
Cyclic forms of REGULAR

  • REGULARo(A,[X1,..,Xn])

    • Reduction from Hamiltonian cycle

    • Consider polynomial sized automaton A1 that accepts any sequence in which the 1st character is never repeated

    • Consider polynomial sized automaton A2 that accepts any walk in a graph

      • T(a,b)=b iff (a,b) in edges of graph

    • Consider polynomial sized automaton A1 intersect A2

    • This accepts only those strings corresponding to Hamiltonian cycles


Other generalizations of regular l.jpg
Other generalizations of REGULAR

  • REGULAR FIX(A,[X1,..Xn],[B1,..Bm]) iff

    • REGULAR(A,[X1,..Xn]) and Bi=1 iff exists j. Xj=I

    • Certain values must occur within the sequence

    • For example, there must be a maintenance shift

    • Unfortunately NP-hard to enforce GAC on this


Other generalizations of regular20 l.jpg
Other generalizations of REGULAR

  • REGULAR FIX(A,[X1,..Xn],[B1,..Bm])

    • Simple reduction from Hamiltonian path

    • Automaton A accepts any walk on a graph

    • n=m and Bi=1 for all i


Chomsky hierarchy l.jpg
Chomsky hierarchy

  • Regular languages

  • Context-free languages

  • Context-sensitive languages

  • ..


Chomsky hierarchy22 l.jpg
Chomsky hierarchy

  • Regular languages

    • GAC propagator in O(ndQ) time

  • Conext-free languages

    • GAC propagator in O(n^3) time and O(n^2) space

    • Asymptotically optimal as same as parsing!

  • Conext-sensitive languages

    • Checking if a string is in the language PSPACE-complete

    • Undecidable to know if empty string in grammar and thus to detect domain wipeout and enforce GAC!


Context free grammars l.jpg
Context-free grammars

  • Possible applications

    • Hierarchy configuration

    • Bioinformatics

    • Natual language parsing

  • CFG(G,[X1,…Xn]) holds iff

    • X1 .. Xn is a string accepted by the context free grammar G


Context free grammars24 l.jpg
Context-free grammars

  • CFG(G,[X1,…Xn])

    • Consider a block stacking example

    • S -> NP | P | PN | NPN

    • N -> n | nN

    • P -> aa | bb | aPa | bPb

    • These rules give n* w rev(w) n* where w is (a|b)*

    • Not expressible using a regular language

  • Chomsky normal form

    • Non-terminal -> Terminal

    • Non-terminal -> Non-terminal Non-terminal


Cfg propagator l.jpg
CFG propagator

  • Adapt CYK parser

  • Works on Chomsky normal form

    • Non-terminal -> Terminal

    • Non-terminal -> Non-terminal Non-terminal

  • Using dynamic programming to compute supports

  • Bottom up

    • Enforces GAC in Theta(n^3) time

      Simultaneously and independently proposed by Sellmannn [CP06]


Cfg propagator26 l.jpg
CFG propagator

  • Adapt Earley chart parser

    • Carry support information

  • Works on grammar in any form

  • More top down

    • Better on tightly restricted grammars

  • Enforces GAC in O(n^3) time

    • Best case is better as not Theta(n^3)


Conclusions l.jpg
Conclusions

  • Global grammar constraints

    • Specify wide range of global constraints

    • Provide efficient and effective propagators automatically

    • Nice marriage of formal language theory and constraint programming!



ad