File size: 51,511 Bytes
6fa4bc9 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 | {
"paper_id": "P95-1012",
"header": {
"generated_with": "S2ORC 1.0.0",
"date_generated": "2023-01-19T08:33:52.847195Z"
},
"title": "Compiling HPSG type constraints into definite clause programs",
"authors": [
{
"first": "Thilo",
"middle": [],
"last": "G~tz",
"suffix": "",
"affiliation": {
"laboratory": "",
"institution": "Universit\u00a3t Tfibingcn Kleine Wilhelmstrat~e",
"location": {
"addrLine": "113",
"postCode": "72074",
"settlement": "Tfibingen",
"country": "Germany"
}
},
"email": ""
},
{
"first": "Walt",
"middle": [
"Detmar"
],
"last": "Meurers",
"suffix": "",
"affiliation": {
"laboratory": "",
"institution": "Universit\u00a3t Tfibingcn Kleine Wilhelmstrat~e",
"location": {
"addrLine": "113",
"postCode": "72074",
"settlement": "Tfibingen",
"country": "Germany"
}
},
"email": ""
}
],
"year": "",
"venue": null,
"identifiers": {},
"abstract": "We present a new approach to HPSG processing: compiling HPSG grammars expressed as type constraints into definite clause programs. This provides a clear and computationally useful correspondence between linguistic theories and their implementation. The compiler performs offline constraint inheritance and code optimization. As a result, we are able to efficiently process with HPSG grammars without haviog to hand-translate them into definite clause or phrase structure based systems.",
"pdf_parse": {
"paper_id": "P95-1012",
"_pdf_hash": "",
"abstract": [
{
"text": "We present a new approach to HPSG processing: compiling HPSG grammars expressed as type constraints into definite clause programs. This provides a clear and computationally useful correspondence between linguistic theories and their implementation. The compiler performs offline constraint inheritance and code optimization. As a result, we are able to efficiently process with HPSG grammars without haviog to hand-translate them into definite clause or phrase structure based systems.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "Abstract",
"sec_num": null
}
],
"body_text": [
{
"text": "The HPSG architecture as defined in (Pollard and Sag, 1994 ) (henceforth HPSGII) is being used by an increasing number of linguists, since the formally well-defined framework allows for a rigid and explicit formalization of a linguistic theory. At the same time, the feature logics which provide the formal foundation of HPSGII have been used as basis for several NLP systems, such as ALE (Carpenter, 1993) , CUF (DSrre and Dorna, 1993) , Troll (Gerdemann and King, 1993) or TFS (Emele and Zajac, 1990) . These systems are -at least partly -intended as computational environments for the implementation of HPSG grammars.",
"cite_spans": [
{
"start": 36,
"end": 58,
"text": "(Pollard and Sag, 1994",
"ref_id": "BIBREF9"
},
{
"start": 389,
"end": 406,
"text": "(Carpenter, 1993)",
"ref_id": "BIBREF2"
},
{
"start": 409,
"end": 436,
"text": "CUF (DSrre and Dorna, 1993)",
"ref_id": null
},
{
"start": 460,
"end": 471,
"text": "King, 1993)",
"ref_id": "BIBREF4"
},
{
"start": 479,
"end": 502,
"text": "(Emele and Zajac, 1990)",
"ref_id": null
}
],
"ref_spans": [],
"eq_spans": [],
"section": "Introduction",
"sec_num": "1"
},
{
"text": "HPSG linguists use the description language of the logic to express their theories in the form of implicative constraints. On the other hand, most of the computational setups only allow feature descriptions as extra constraints with a phrase structure or definite clause based language. 1 From a computational point of view the latter setup has several advantages. It provides access to the pool of work done in the *The authors are listed alphabetically. 1One exception is the TFS system. However, the possibility to express recursive relations on the level of the description language leads to serious control problems in that system. area of natural language processing, e.g., to efficient control strategies for the definite clause level based on tabelling methods like Earley deduction, or different parsing strategies in the phrase structure setup.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "Introduction",
"sec_num": "1"
},
{
"text": "The result is a gap between the description language theories of HPSG linguists and the definite clause or phrase structure based NLP systems provided to implement these theories. Most grammars currently implemented therefore have no clear correspondence to the linguistic theories they originated from. To be able to use implemented grammars to provide feedback for a rigid and complete formalization of linguistic theories, a clear and computa-tionMly useful correspondence has to be established. This link is also needed to stimulate further development of the computational systems. Finally, an HPSGII style setup is also interesting to model from a software engineering point of view, since it permits a modular development and testing of the grammar.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "Introduction",
"sec_num": "1"
},
{
"text": "The purpose of this paper is to provide the desired link, i.e., to show how a HPSG theory formulated as implicative constraints can be modelled on the level of the relational extension of the constraint language. More specifically, we define a compilation procedure which translates the type constraints of the linguistic theory into definite clauses runnable in systems such as Troll, ALE, or CUF. Thus, we perform constraint inheritance and code optimization off-line. This results in a considerable efficiency gain over a direct on-line treatment of type constraints as, e.g., in TFS.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "Introduction",
"sec_num": "1"
},
{
"text": "The structure of the paper is as follows: A short discussion of the logical setup for HPSGII provides the necessary formal background and terminology. Then the two possibilities for expressing a theoryusing the description language as in HPSGII or the relational level as in the computational architectures -are introduced. The third section provides a simple picture of how HPSGII theories can be modelled on the relational level. This simple picture is then refined in the fourth section, where the compilation procedure and its implementation is discussed. A small example grammar is provided in the appendix.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "Introduction",
"sec_num": "1"
},
{
"text": "A HPSG grammar consists of two components: the declaration of the structure of the domain of linguistic objects in a signature (consisting of the type hierarchy and the appropriateness conditions) and the formulation of constraints on that domain. The signature introduces the structures the linguist wants to talk about. The theory the linguist proposes distinguishes between those objects in a domain which are part of the natural language described, and those which are not.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "The HPSGII architecture",
"sec_num": "2.1"
},
{
"text": "HPSGII gives a closed world interpretation to the type hierarchy: every object is of exactly one minimal (most specific) type. This implies that every object in the denotation of a non-minimal type is also described by at least one of its subtypes. Our compilation procedure will adhere to this interpretation.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "The HPSGII architecture",
"sec_num": "2.1"
},
{
"text": "A HPSGII theory consists of a set of descriptions which are interpreted as being true or false of an object in the domain. An object is admissible with respect to a certain theory iff it satisfies each of the descriptions in the theory and so does each of its substructures. The descriptions which make up the theory are also called constraints, since these descriptions constrain the set of objects which are admissible with respect to the theory. Figure 1 shows an example of a constraint, the head-feature principle of HPSGII. Throughout the paper we will be using HPSG style AVM notation for descriptions. The intended interpretation of this constraint is that every object which is being described by type phrase and by [DTI~S h~aded-str~c] also has to be described by the consequent, i.e. have its head value shared with that of its head-daughter.",
"cite_spans": [],
"ref_spans": [
{
"start": 449,
"end": 457,
"text": "Figure 1",
"ref_id": "FIGREF0"
}
],
"eq_spans": [],
"section": "The theories of HPSGII: Directly constraining the domain",
"sec_num": "2.2"
},
{
"text": "In the HPSG II architecture any description can be used as antecedent of an implicative constraint. As shown in (Meurers, 1994) , a complex description can be expressed as a type by modifying the signature and/or adding theory statements. In the following, we therefore only deal with implicative constraints with type antecedents, the type definitions.",
"cite_spans": [
{
"start": 112,
"end": 127,
"text": "(Meurers, 1994)",
"ref_id": "BIBREF8"
}
],
"ref_spans": [],
"eq_spans": [],
"section": "The theories of HPSGII: Directly constraining the domain",
"sec_num": "2.2"
},
{
"text": "As mentioned in the introduction, in most computational systems for the implementation of HPSG theories a grammar is expressed using a relational extension of the description language 2 such as definite clauses or phrase structure rules. The HPSG description language is only used to specify the arguments of the relations, in the example noted as D, E, and F. The organization of the descriptions, i.e. their use as constraints to narrow down the set of described objects, is taken over by the relational level. This way of organizing descriptions in definite clauses allows efficient processing techniques of logic programming to be used.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "Theories in constraint logic programming: expressing definite clause relations",
"sec_num": "2.3"
},
{
"text": "The question we are concerned with in the following is how a HPSG II theory can be modelled in such a setup.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "Theories in constraint logic programming: expressing definite clause relations",
"sec_num": "2.3"
},
{
"text": "Modelling HPSGII theories on a relational level: a simple picture There are three characteristics of HPSGII theories which we need to model on the relational level: one needs to be able to 1. express constraints on any kind of object, 2. use the hierarchical structure of the type hierarchy to organize the constraints, and 3. check any structure for consistency with the theory.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "3",
"sec_num": null
},
{
"text": "A straightforward encoding is achieved by expressing each of these three aspects in a set of relations. Let us illustrate this idea with a simple example. Assume the signature given in figure 3 First, we define a relation to express the constraints immediately specified for a type on the argument of the relation:",
"cite_spans": [],
"ref_spans": [
{
"start": 185,
"end": 193,
"text": "figure 3",
"ref_id": null
}
],
"eq_spans": [],
"section": "3",
"sec_num": null
},
{
"text": "\u2022 a o,, ) :-T,vp,G).",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "3",
"sec_num": null
},
{
"text": "\u2022 c\u00b0on,(c).",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "\u2022 b b :-",
"sec_num": null
},
{
"text": "For every type, the relation specifies its only argument to bear the type information and the consequents of the type definition for that type. Note that the simple type assignment [G a] leads to a call to the relation atvp~ imposing all constraints for type a, which is defined below. Second, a relation is needed to capture the hierarchical organization of constraints: Each hierarchy relation of a type references the constraint relation and makes sure that the constraints below one of the subtypes are obeyed.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "\u2022 b b :-",
"sec_num": null
},
{
"text": "Finally, a relation is defined to collect all constraints on a type:",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "\u2022 b b :-",
"sec_num": null
},
{
"text": "\u2022 atyp~(~) :-This,-( ri-1 a ). aA disjunction of the immediate subtypes of T.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "\u2022 b b :-",
"sec_num": null
},
{
"text": "Compared to the hierarchy relation of a type which collects all constraints on the type and its subtypes, the last kind of relation additionally references those constraints which are inherited from a supertype. Thus, this is the relation that needs to be queried to check for grammaticality.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "\u2022 b b :-",
"sec_num": null
},
{
"text": "Even though the simple picture with its tripartite definition for each type yields perspicuous code, it falls short in several respects. The last two kinds of relations (reltype and relhier) just perform inheritance of constraints. Doing this at run-time is slow, and additionally there are problems with multiple inheritance.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "\u2022 b b :-",
"sec_num": null
},
{
"text": "A further problem of the encoding is that the value of an appropriate feature which is not mentioned in any type definition may nonetheless be implicitly constrained, since the type of its value is constrained. Consider for example the standard HPSG encoding of list structures. This usually involves a type he_list with appropriate features HD and TL, where under HD we encode an element of the list, and under TL the tail of the list. Normally, there will be no extra constraints on ne_list. But in our setup we clearly need a definite clause .TL since the value of the feature HD may be of a type which is constrained by the grammar. Consequently, since he_list is a subtype of list, the value of TL needs to be constrained as well.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "\u2022 b b :-",
"sec_num": null
},
{
"text": "Compiling HPSG type constraints into definite clauses After this intuitive introduction to the problem, we will now show how to automatically generate definite clause programs from a set of type definitions, in a way that avoids the problems mentioned for the simple picture.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "4",
"sec_num": null
},
{
"text": "Before we can look at the actual compilation procedure, we need some terminology.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "The algorithm",
"sec_num": "4.1"
},
{
"text": "Two types interact if they have a common subtype.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "Definition (type interaction)",
"sec_num": null
},
{
"text": "Note that every type interacts with itself.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "Definition (type interaction)",
"sec_num": null
},
{
"text": "A defined type is a type that occurs as antecedent of an implicational constraint in the grammar.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "Definition (defined type)",
"sec_num": null
},
{
"text": "A constrained type is a type that interacts with a defined type.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "Definition (constrained type)",
"sec_num": null
},
{
"text": "Whenever we encounter a structure of a constrained type, we need to check that the structure conforms to the constraint on that type. As mentioned in section 2.1, due to the closed world interpretation of type hierarchies, we know that every object in the denotation of a non-minimal type t also has to obey the constraints on one of the minimal subtypes of t. Thus, if a type t has a subtype t' in common with a defined type d, then t ~ is a constrained type (by virtue of being a subtype of d) and t is a constrained type (because it subsumes t').",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "Definition (constrained type)",
"sec_num": null
},
{
"text": "The set of hiding types is the smallest set s.t. if t is not a constrained type and subsumes a type to that has a feature f appropriate s.t. approp(to,f) is a constrained type or a hiding type, then t is a hiding type.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "Definition (hiding type)",
"sec_num": null
},
{
"text": "The type ne_list that we saw above is a hiding type.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "Definition (hiding type)",
"sec_num": null
},
{
"text": "If t is a constrained or hiding type, then f is a hiding feature on t iff approp(t,f) is a constrained or hiding type.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "Definition (hiding feature)",
"sec_num": null
},
{
"text": "A simple type is a type that is neither a constrained nor a hiding type.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "Definition (simple type)",
"sec_num": null
},
{
"text": "When we see a structure of a simple type, we don't need to apply any constraints, neither on the top node nor on any substructure. Partitioning the types in this manner helps us to construct definite clause programs for type constraint grammars. For each type, we compute a unary relation that we just give the same name as the type. Since we assume a closed world interpretation of the type hierarchy, we really only need to compute proper definitions for minimal types. The body of a definition for a non-minimal type is just a disjunction of the relations defining the minimal subtypes of the non-minimal type.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "Definition (simple type)",
"sec_num": null
},
{
"text": "When we want to compute the defining clause for a minimal type, we first of all check what sort of type it is. For each simple type, we just introduce a unit clause whose argument is just the type. For a constrained type t, first of all we have to perform constraint inheritance from all types that subsume t. Then we transform that constraint to some internal representation, usually a feature structure (FS). We now have a schematic defining clause of the form t(FS) :-?.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "Definition (simple type)",
"sec_num": null
},
{
"text": "Next, we compute the missing right-hand side (RHS) with the following algorithm.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "Definition (simple type)",
"sec_num": null
},
{
"text": "1. Compute HF, the set of hiding features on the type of the current node, then insert these features with appropriate types in the structure (FS) if they're not already there. For each node under a feature in HF, apply step 2. 2. Let t be the type on the current node and X its tag (a variable). (a) If t is a constrained type, enter t(X) into RHS (if it's not already there). (b) Elseif t is a hiding type, then check if its hiding features and the hiding features of all its hiding subtypes are identical. If they are identical, then proceed as in step 1. If not, enter t(X) into RHS. (c) Else (t is a simple type) do nothing at all. For hiding types, we do exactly the same thing, except that we don't have any structure to begin with. But this is no problem, since the hiding features get introduced anyway.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "Definition (simple type)",
"sec_num": null
},
{
"text": "A formal proof of correctness of this compiler is given in (GStz, 1995) -here, we will try to show by example how it works. Our example is an encodin~ of a definite relation in a type constraint setup2 append_c appends an arbitrary list onto a list of constants.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "An example",
"sec_num": "4.2"
},
{
"text": "T constant Figure 5 : The signature for the append_c example",
"cite_spans": [],
"ref_spans": [
{
"start": 11,
"end": 19,
"text": "Figure 5",
"ref_id": null
}
],
"eq_spans": [],
"section": "An example",
"sec_num": "4.2"
},
{
"text": "We will stick to an AVM style notation for our examples, the actual program uses a standard feature term syntax. List are abbreviated in the standard HPSG manner, using angled brackets.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "An example",
"sec_num": "4.2"
},
{
"text": "ARG 2 ARG3",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "append_c -* [A O1",
"sec_num": null
},
{
"text": "GOALS e_listJ",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "append_c -* [A O1",
"sec_num": null
},
{
"text": "\"ARG 1 ARG2 ARG3 V GOALS 15q oo.,,..,i 5q \u00a2 [] IE]I[EI ARG 1 [~]",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "append_c -* [A O1",
"sec_num": null
},
{
"text": "ARG2 ARG3 Figure 6 : A constraint on append_c Note that the set of constrained types is {append_c, 4This sort of encoding was pioneered by (Ait-Kaci, 1984) , but see also (King, 1989) and (Carpenter, 1992) . T} and the set of hiding types is {list, ne_list}. Converting the first disjunct of append_c into a feature structure to start our compilation, we get something like 'append_c I ",
"cite_spans": [
{
"start": 139,
"end": 155,
"text": "(Ait-Kaci, 1984)",
"ref_id": "BIBREF0"
},
{
"start": 171,
"end": 183,
"text": "(King, 1989)",
"ref_id": "BIBREF7"
},
{
"start": 188,
"end": 205,
"text": "(Carpenter, 1992)",
"ref_id": "BIBREF1"
}
],
"ref_spans": [
{
"start": 10,
"end": 18,
"text": "Figure 6",
"ref_id": null
}
],
"eq_spans": [],
"section": "append_c -* [A O1",
"sec_num": null
},
{
"text": "ARG1 v--a[]e-list]",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "append_c -* [A O1",
"sec_num": null
},
{
"text": "append_c ARG1 e_list append_c( I ARG3ARG2 ~__lisq):-]Jst(~).",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "append_c -* [A O1",
"sec_num": null
},
{
"text": "LGOALS e_list j which is exactly what we want. It means that a structure of type append_c is well-formed if it unifies with the argument of the head of the above clause and whatever is under ARG2 (and AR.G3) is a wellformed list. Now for the recursive disjunct, we start out with append_el \"append_c rne_list Our implementation of the compiler does in fact perform this pruning as an integrated part of the compilation, not as an additional step.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "append_c -* [A O1",
"sec_num": null
},
{
"text": "It should be pointed out that this compilation result is quite a dramatic improvement on more naive on-line approaches to ttPSG processing. By reasoning with the different kinds of types, we can drastically reduce the number of goals that need to be checked on-line. Another way of viewing this would be to see the actual compilation step as being much simpler (just check every possible feature) and to subsequently apply program transformation techniques (some sophisticated form of partial evaluation). We believe that this view would not simplify the overall picture, however.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "append_c -* [A O1",
"sec_num": null
},
{
"text": "The compiler as described in the last section has been fully implemented under Quintus Prolog. Our interpreter at the moment is a simple left to right backtracking interpreter. The only extension is to keep a list of all the nodes that have already been visited to keep the same computation from being repeated. This is necessary since although we avoid redundancies as shown in the last example, there are still cases where the same node gets checked more than once.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "Implementation and Extensions",
"sec_num": "4.3"
},
{
"text": "This simple extension also allows us to process cyclic queries. The following query is allowed by our system. The computationally oriented reader will now wonder how we expect to deal with non-termination anyway. At the moment, we allow the user to specify minimal control information.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "Implementation and Extensions",
"sec_num": "4.3"
},
{
"text": "\u2022 The user can specify an ordering on type expansion. E.g., if the type hierarchy contains a type sign with subtypes word and phrase, the user may specify that word should always be tried before phrase.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "me_list ~]",
"sec_num": null
},
{
"text": "\u2022 The user can specify an ordering on feature expansion. E.g., HD should always be expanded before TL in a given structure. Since this information is local to any given structure, the interpreter does not need to know about it, and the control information is interpreted as compiler directives.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "me_list ~]",
"sec_num": null
},
{
"text": "We have presented a compiler that can encode HPSG type definitions as a definite clause program. This for the first time offers the possibility to express linguistic theories the way they are formulated by linguists in a number of already existing computational systems. The compiler finds out exactly which nodes of a structure have to be examined and which don't. In doing this off-line, we minimize the need for on-line inferences. The same is true for the control information, which is also dealt with off-line. This is not to say that the interpreter wouldn't profit by a more sophisticated selection function or tabulation techniques (see, e.g., (DSrre, 1993) ). We plan to apply Earley deduction to our scheme in the near future and experiment with program transformation techniques and bottom-up interpretation.",
"cite_spans": [
{
"start": 652,
"end": 665,
"text": "(DSrre, 1993)",
"ref_id": "BIBREF3"
}
],
"ref_spans": [],
"eq_spans": [],
"section": "Conclusion and Outlook",
"sec_num": "5"
},
{
"text": "Our work addresses a similar problem as Carpenter's work on resolved feature structures (Carpenter, 1992, ch. 15) . However, there are two major differences, both deriving form the fact that Carpenter uses an open world interpretation. Firstly, our approach can be extended to handle arbitrarily complex antecedents of implications (i.e., arbitrary negation), which is not possible using an open world approach. Secondly, solutions in our approach have the so-called subsumption monotonicity or persistence property. That means that any structure subsumed by a solution is also a solution (as in Prolog, for example). Quite the opposite is the case in Carpenter's approach, where solutions are not guaranteed to have more specific extensions. This is unsatisfactory at least from an HPSG point of view, since HPSG feature structures are supposed to be maximally specific.",
"cite_spans": [
{
"start": 88,
"end": 113,
"text": "(Carpenter, 1992, ch. 15)",
"ref_id": null
}
],
"ref_spans": [],
"eq_spans": [],
"section": "Conclusion and Outlook",
"sec_num": "5"
},
{
"text": "Jochen DSrre. 1993. Generalizing earley deduction for constraint-based grammars. In Jochen DSrre, editor, Computational aspects of constraint based linguistic descriptions I, pages 25-41. DYANA-2 Deliverable R1.2.A, Universit~t Stuttgart, August. Martin C. Emele and R~mi Zajac. 1990. Typed unification grammars. In Proceedings of the 13 'h",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "",
"sec_num": null
}
],
"back_matter": [
{
"text": "The research reported here was carried out in the context of SFB 340, project B4, funded by the Deutsche Forschungsgemeinschaft. We would like to thank Dale Gerdemann, Paul John King and two anonymous referees for helpful discussion and comments.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "Acknowledgments",
"sec_num": null
},
{
"text": "The following small example grammar, together with a definition of an append type, generates sentences like \"John thinks cats run\". It is a modified version of an example from (Carpenter, 1992) . Here's an example query. Note that the feature GOALS has been suppressed in the result.",
"cite_spans": [
{
"start": 176,
"end": 193,
"text": "(Carpenter, 1992)",
"ref_id": "BIBREF1"
}
],
"ref_spans": [],
"eq_spans": [],
"section": "Appendix A. A small grammar",
"sec_num": null
},
{
"text": "[PHON { john, runs )] ",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "Query>",
"sec_num": null
},
{
"text": "For the next query we get exactly the same result.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "AGR PHON",
"sec_num": null
}
],
"bib_entries": {
"BIBREF0": {
"ref_id": "b0",
"title": "A lattice theoretic approach to computation based on a calculus of partially ordered type structures",
"authors": [
{
"first": "Hassan",
"middle": [],
"last": "Ait-Kaci",
"suffix": ""
}
],
"year": 1984,
"venue": "",
"volume": "",
"issue": "",
"pages": "",
"other_ids": {},
"num": null,
"urls": [],
"raw_text": "Hassan Ait-Kaci. 1984. A lattice theoretic approach to computation based on a calculus of partially or- dered type structures. Ph.D. thesis, University of Pennsylvania.",
"links": null
},
"BIBREF1": {
"ref_id": "b1",
"title": "of Cambridge Tracts in Theoretical Computer Science",
"authors": [
{
"first": "Bob",
"middle": [],
"last": "Carpenter",
"suffix": ""
}
],
"year": 1992,
"venue": "",
"volume": "32",
"issue": "",
"pages": "",
"other_ids": {},
"num": null,
"urls": [],
"raw_text": "Bob Carpenter. 1992. The logic of typed feature s~ructures, volume 32 of Cambridge Tracts in The- oretical Computer Science. Cambridge University Press.",
"links": null
},
"BIBREF2": {
"ref_id": "b2",
"title": "ALE -the attribute logic engine, user's guide, May. Laboratory for Computational Linguistics, Philosophy Department",
"authors": [
{
"first": "Bob",
"middle": [],
"last": "Carpenter",
"suffix": ""
}
],
"year": 1993,
"venue": "",
"volume": "",
"issue": "",
"pages": "",
"other_ids": {},
"num": null,
"urls": [],
"raw_text": "Bob Carpenter. 1993. ALE -the attribute logic engine, user's guide, May. Laboratory for Computational Linguistics, Philosophy Depart- ment, Carnegie Mellon University, Pittsburgh, PA 15213.",
"links": null
},
"BIBREF3": {
"ref_id": "b3",
"title": "Computational aspects of constraint based linguistic descriptions I, pages 1-22. DYANA-2 Deliverable R1.2.A, Uni-versit~t Stuttgart",
"authors": [
{
"first": "Jochen",
"middle": [],
"last": "Dsrre",
"suffix": ""
},
{
"first": "Michael",
"middle": [],
"last": "Dorna",
"suffix": ""
}
],
"year": 1993,
"venue": "August. International Conference on Computational Linguistics",
"volume": "",
"issue": "",
"pages": "",
"other_ids": {},
"num": null,
"urls": [],
"raw_text": "Jochen DSrre and Michael Dorna. 1993. CUF - a formalism for linguistic knowledge representa- tion. In Jochen DSrre, editor, Computational as- pects of constraint based linguistic descriptions I, pages 1-22. DYANA-2 Deliverable R1.2.A, Uni- versit~t Stuttgart, August. International Conference on Computational Lin- guistics.",
"links": null
},
"BIBREF4": {
"ref_id": "b4",
"title": "Typed feature structures for expressing and computationally implementing feature cooccurrence restrictions",
"authors": [
{
"first": "Dale",
"middle": [],
"last": "Gerdemann",
"suffix": ""
},
{
"first": "Paul John",
"middle": [],
"last": "King",
"suffix": ""
}
],
"year": 1993,
"venue": "Proceedings of 4. Fachtagung der Sektion Computerlinguistik der Deutschen Gesellschafl fffr Sprachwissenschaft",
"volume": "",
"issue": "",
"pages": "33--39",
"other_ids": {},
"num": null,
"urls": [],
"raw_text": "Dale Gerdemann and Paul John King. 1993. Typed feature structures for expressing and com- putationally implementing feature cooccurrence restrictions. In Proceedings of 4. Fachtagung der Sektion Computerlinguistik der Deutschen Gesellschafl fffr Sprachwissenschaft, pages 33-39.",
"links": null
},
"BIBREF5": {
"ref_id": "b5",
"title": "Compiling HPSG constraint grammars into logic programs",
"authors": [
{
"first": "Thilo",
"middle": [],
"last": "Gstz",
"suffix": ""
}
],
"year": 1995,
"venue": "Proceedings of the joint ELSNET/COMPULOG-NET/EAGLES workshop on computational logic for natural language processing",
"volume": "",
"issue": "",
"pages": "",
"other_ids": {},
"num": null,
"urls": [],
"raw_text": "Thilo GStz. 1995. Compiling HPSG constraint grammars into logic programs. In Proceedings of the joint ELSNET/COMPULOG-NET/EAGLES workshop on computational logic for natural lan- guage processing.",
"links": null
},
"BIBREF6": {
"ref_id": "b6",
"title": "Definite relations over constraint languages",
"authors": [
{
"first": "M",
"middle": [],
"last": "Hshfeld",
"suffix": ""
},
{
"first": "Gert",
"middle": [],
"last": "Smolka",
"suffix": ""
}
],
"year": 1988,
"venue": "LILOG technical report",
"volume": "53",
"issue": "",
"pages": "",
"other_ids": {},
"num": null,
"urls": [],
"raw_text": "M. HShfeld and Gert Smolka. 1988. Definite rela- tions over constraint languages. LILOG technical report, number 53, IBM Deutschland GmbH.",
"links": null
},
"BIBREF7": {
"ref_id": "b7",
"title": "A logical formalism for head. driven phrase structure grammar",
"authors": [
{
"first": "Paul John",
"middle": [],
"last": "King",
"suffix": ""
}
],
"year": 1989,
"venue": "",
"volume": "",
"issue": "",
"pages": "",
"other_ids": {},
"num": null,
"urls": [],
"raw_text": "Paul John King. 1989. A logical formalism for head. driven phrase structure grammar. Ph.D. thesis, University of Manchester.",
"links": null
},
"BIBREF8": {
"ref_id": "b8",
"title": "On implementing an HPSG theory -Aspects of the logical architecture, the formalization, and the implementation of head-driven phrase structure grammars",
"authors": [
{
"first": "W",
"middle": [
"Detmar"
],
"last": "Meurers",
"suffix": ""
}
],
"year": 1994,
"venue": "Erhard W. Hinrichs, W. Detmar Meurers, and Tsuneko Nakazawa: Partial-VP and Split-NP Topicalization in German -An HPSG Analysis and its Implementation. Arbeitspapiere des SFB 340 Nr",
"volume": "58",
"issue": "",
"pages": "",
"other_ids": {},
"num": null,
"urls": [],
"raw_text": "W. Detmar Meurers. 1994. On implementing an HPSG theory -Aspects of the logical archi- tecture, the formalization, and the implementa- tion of head-driven phrase structure grammars. In: Erhard W. Hinrichs, W. Detmar Meurers, and Tsuneko Nakazawa: Partial-VP and Split-NP Topicalization in German -An HPSG Analysis and its Implementation. Arbeitspapiere des SFB 340 Nr. 58, Universit\u00a3t Tfibingen.",
"links": null
},
"BIBREF9": {
"ref_id": "b9",
"title": "Head-Driven Phrase Structure Grammar",
"authors": [
{
"first": "Carl",
"middle": [],
"last": "Pollard",
"suffix": ""
},
{
"first": "Ivan",
"middle": [
"A"
],
"last": "Sag",
"suffix": ""
}
],
"year": 1994,
"venue": "",
"volume": "",
"issue": "",
"pages": "",
"other_ids": {},
"num": null,
"urls": [],
"raw_text": "Carl Pollard and Ivan A. Sag. 1994. Head-Driven Phrase Structure Grammar. Chicago: University of Chicago Press and Stanford: CSLI Publica- tions.",
"links": null
}
},
"ref_entries": {
"FIGREF0": {
"type_str": "figure",
"text": "The Head-Feature Principle of HPSGII",
"num": null,
"uris": null
},
"FIGREF1": {
"type_str": "figure",
"text": "Figure 2 schematically shows the embedding of HPSG II descriptions in the definition of a relation. relo (D1 ..... D~) :-tell(E1,..., Ej), re/n(Fl .... , Fh).",
"num": null,
"uris": null
},
"FIGREF2": {
"type_str": "figure",
"text": "Defining relation relo",
"num": null,
"uris": null
},
"FIGREF3": {
"type_str": "figure",
"text": "and the HPSGII 2 For the logical foundations of relational extensions of arbitrary constraint languages see (HShfeld and Smolka, An example theory in a HPSGII setup",
"num": null,
"uris": null
},
"FIGREF4": {
"type_str": "figure",
"text": "; ....\u2022 ahi,~(~):-a,o,,,([~]), ( bh,,~(~); chi,r([~) ). \u2022 bhi,r(]~]):-bco,,,(~).",
"num": null,
"uris": null
},
"FIGREF5": {
"type_str": "figure",
"text": "\u2022 bt,p~(E~ ]) :-Thief( [-i~b ). * ctvpe([~]) :-Thier( r-~c ).",
"num": null,
"uris": null
},
"FIGREF7": {
"type_str": "figure",
"text": "A permitted cyclic queryAn interpreter without the above-mentioned extension would not terminate on this query.",
"num": null,
"uris": null
}
}
}
} |