<?xml version="1.0" standalone="yes"?>
<Paper uid="W00-0740">
  <Title>Incorporating Linguistics Constraints into Inductive Logic Programming</Title>
  <Section position="4" start_page="184" end_page="184" type="intro">
    <SectionTitle>
2 Generating naive rules
</SectionTitle>
    <Paragraph position="0"> The first step in our algorithm can be described as inductive chart parsing. The details of integrating induction into chart parsing have been described in (Cussens and Pulman, 2000), here we give just a brief account. This first step of the algorithm is the only one that has been retained from this previous work. The basic idea is that, after a failed parse, we use abduction to find needed edges: which, if they existed, would allow a complete parse of the sentence.</Paragraph>
    <Paragraph position="1"> These are produced in a top-down manner starting with the initial need for a sigma edge spanning the entire sentence. If a need matches the mother of a grammar rule and edges for all the daughters bar one are in the chart, then the missing daughter edge is generated as a new need.</Paragraph>
    <Paragraph position="2"> The process of generating naive rules is very simple, and we will explain it by way of an example. Suppose the vp_vp rood grammar rule, shown in Fig 1, has been artificially removed from a grammar. The absence of this rule means vp_vp_mod syn vp : \[gaps= \[A, B\] ,mor=C, aux=n\] ==&gt; \[ vp : \[gaps = \[A, D\] , mor=C, aux=n\] , mod: \[gaps= \[D, B\], of =or (s, vp), type=_\] \] .  readable representation) that, for example, the sentence All big companies wrote a report quickly can not be parsed, since we can not get the needed VP wrote a report quickly from the found VP wrote a report and the found MOD quickly. The corresponding needed and actual (complete) edges are given in  Fig 2. A naive rule is constructed by putting a Y.need (Sent, Cat, From, To).</Paragraph>
    <Paragraph position="3"> need(l, vp(\[ng,ng\], f(0,0,0,0,1,1,1,1,1),_), 3, 7).</Paragraph>
    <Paragraph position="4"> %edge (Sent, Id, Origin, From, To, Cat,.. ) ThCat, From, To).</Paragraph>
    <Paragraph position="5"> edge(l, 39, vp v rip, 3, 6, vp(\[_A,_A\] ,f(O,O,O,O ....... l,l),n) .... ). edge(l, 19, quickly, 6, 7, mod(\[_B,_B\] ,f (0,0,0, I) ,f(0,1, i,i)),...).  needed edge on its LHS and other edges on the RHS which in this case gives us the naive rule in Fig 3. In (Cussens and Pulman, 2000) only actual edges were allowed on the RHS of a naive rule, since this ensures that the naive rule suffices to allow a parse. Recently, we have added an option which allows needed edges to appear on the RHS, thus generating more naive rules. This amounts to conjecturing that the needed edges should actually be there, but are missing from the set of actual edges because some other grammar rule is missing: thus preventing the parser from producing them. Since all naive rules are subsequently constrained and evaluated on the data, and then not added to the grammar unless the user allows them, such bold conjectures can be retracted later on. From cmp_synrule (rO, vp( \[ng,ng\] ,f (0,0,0,0,1, I, I, 1, i) ,_), vp( \[_A,_A\] ,f (0,0,0,0 ....... 1,1) ,n), mod(E_B,_B\] ,f (0,0,O, i) ,f (0,I, i,i))).</Paragraph>
    <Paragraph position="6">  piled form an ILP perspective, the construction of naive rules involves repeated applications of inverse resolution (Muggleton and Buntine, 1988) until we produce a clause which meets extra-logical constraints on vertex connectivity. Abbreviating, we produce vp(3,7) :- vp(3,6) and then vp(3,7) :'- vp(3,6),mod(6,7). This is then followed by variabilising the vertices to give</Paragraph>
    <Paragraph position="8"> actly the same procedure can be implemented by building a 'bottom-clause' using the Progol algorithm. We previously used P-Progol (now called Aleph) to construct naive rules in this way, but have since found it more convenient to write our own code to do this.</Paragraph>
  </Section>
class="xml-element"></Paper>