<?xml version="1.0" standalone="yes"?>
<Paper uid="P96-1058">
  <Title>Maximizing Top-down Constraints for Unification-based Systems</Title>
  <Section position="4" start_page="0" end_page="382" type="metho">
    <SectionTitle>
3 Top-down Propagation
</SectionTitle>
    <Paragraph position="0"> Top-down propagation can be precomputed to form a teachability table. Each entry in the table is a compiled dag which represents the relation between a non-terminal category and a rule used to rewrite the constituents in the teachability relation (i.e., reflexive, transitive closure of the left-corner path).</Paragraph>
    <Paragraph position="1"> For example, consider the following fragment of a grammar used in the syntax/semantics integrated system called LINK (Lytinen, 1992):</Paragraph>
    <Paragraph position="3"/>
    <Paragraph position="5"> (YPo head sem owner) - (NP1 head sem) (This rule is used to parse phrases such as &amp;quot;Kris's desk&amp;quot; .) The dag D(1) in Figure 11 represents the initial application of rl to the category NP. Note that the subdag under the lc arc is the rule used to rewrite the constituent on the left-corner path, and the paths from the top node represent which top-down constraints are propagated to the lower level. Top-down propagation works as follows: given a dad D that represents a teachability relation and a rule dad R whose left-hand side category (i.e., root) is the same as D's left-corner category (i.e., under its (lc 1) path), the resulting dag is D1 = p(D') U (R \ lc), where D' is a copy of D in which all the numbered arcs and lc arc are deleted and the subdag which used to be under the (lc 1) path is promoted to lie under the lc arc. Dags after the next two recursive applications of rl (D(2) and D(3) respectively 2) are shown in Figure 1.</Paragraph>
    <Paragraph position="6"> Notice the filtering function p is applied only to D'. In the case when p(D') = nil, the top node in D1 will have no connections to the rule dag under the lc arc. This means no top-down constraints are propagated to the lower level, therefore the parsing becomes pure bottom-up.</Paragraph>
    <Paragraph position="7"> In many unification-based systems, subsumption is used to avoid redundancy: a dag is recorded in the table if it is not subsumed by any other one.</Paragraph>
    <Paragraph position="8"> Therefore, if a newly created dag is incompatible or more general than existing dags, rule application continues. In the above example, D(2) is incompatible with D(1) and therefore gets entered into the table. The owner arc keeps extending in the subsequent recursive applications (as in D(3)), thus the propagation goes into an infinite loop.</Paragraph>
    <Section position="1" start_page="381" end_page="382" type="sub_section">
      <SectionTitle>
3.1 Proposed Method
</SectionTitle>
      <Paragraph position="0"> Let A be a dag created by the first application of the rule R and B be a dad created by the second application during the top-down propagation. 3 In the proposed method, A and B are first checked for subsumption. If B is subsumed by A, the propagation for this path terminates. Otherwise a possible loop is detected. The detection function (described in the next subsection) is called on A and B and selected features are added to the .restrictor. set. 4 Then, using the updated *restrictor*, propagation is re-done from A.</Paragraph>
      <Paragraph position="1"> When R is applied again yielding B', while B' is not subsumed by A, the following process is repeated: if B' is incompatible with A, the detection function is called on A and B' and propagation is re-done from A. If B' is more general than A, then A is replaced by B' (thereby keeping the most general dag for the path) and propagation is re-done from B'. Otherwise the process stops for this propagation path. Thus, the propagation will terminate when enough features are detected, or when *restrictor* includes all the (finite number of) features in the grammar. 5 In the example, when the detection function is called on D(1) and D(2) after the first recursive application, the feature owner is selected and added to *restrictor*. After the propagation is re-done from D(1), the resulting dad D(4) becomes more general than O(1). 6 Then D(1) is replaced by 0(4), and the propagation is re-done once again. This time it results the same D(4), therefore the propagation  terminates.</Paragraph>
    </Section>
    <Section position="2" start_page="382" end_page="382" type="sub_section">
      <SectionTitle>
3.2 Detection Function
</SectionTitle>
      <Paragraph position="0"> The detection function compares two dags X and Y by checking every constraint (unification equation) x in X with any inconsistent or more general constraint y in Y. If such a constraint is found, the function selects a path in x or y and detects its last arc/feature as being involved in the possible loop. 7 If x is the path constraint pl - p2 where pl and p2 are paths of length &gt; I, features may be detected in the following cases: 8 * (case 1) If both pl and p2 exist in Y, and there exists a more general constraint y in Y in the form pl * p3 - p2 - p3 (length of p3 is also &gt; 1), the path p3 is selected; * (case 2) If both pl and p2 exist in Y, but the subdag under pl and the subdag under p2 do not unify, or if neither pl nor p2 exists in Y, whichever of pl or p2 does not contain the lc arc, or either if they both contain the lc arc, is selected; and * (case 3) If either pl or p2 does not exist in Y, the one which does not exist in Y is selected.</Paragraph>
      <Paragraph position="1"> If x is the constant constraint pl - c (where c is some constant), features may be detected in the following cases: * (case 4) If there exists an incompatible constraint y of the form pl - d where d 7~ c in Y, or if there is no path pl in Y, pl is selected; and * (case 5) If there exists an incompatible constraint y of the form pl * p2 - c, then p2 is selected.</Paragraph>
    </Section>
  </Section>
class="xml-element"></Paper>