File size: 31,963 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 | {
"paper_id": "P82-1012",
"header": {
"generated_with": "S2ORC 1.0.0",
"date_generated": "2023-01-19T09:16:21.778421Z"
},
"title": "ISSUES IN NATURAL LANGUAGE ACCESS TO DATABASES FROM A LOGIC PROGRAMMING PERSPECTIVE",
"authors": [
{
"first": "David",
"middle": [
"H D"
],
"last": "Warren",
"suffix": "",
"affiliation": {},
"email": ""
}
],
"year": "",
"venue": null,
"identifiers": {},
"abstract": "",
"pdf_parse": {
"paper_id": "P82-1012",
"_pdf_hash": "",
"abstract": [],
"body_text": [
{
"text": "Chat processes a NL question in three main stages: translation planning execution English .... > logic .... > Prolog .... > answer corresponding roughly to: \"What does the question mean?\", \"How shall I answer it?\", \"What is the answer?\".",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "",
"sec_num": null
},
{
"text": "The meaning of a NL question, and the database of information about the application domain, are both represented as statements in an extension of a subset of flrst-order logic, which we call \"definite closed world\" (DCW) logic. This logic is a subset of flrst-order logic, in that it admits only \"definite\" statements; uncertain information (\"Either this or that\") is not allowed.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "",
"sec_num": null
},
{
"text": "DCW logic extends flrst-order logic, in that it provides constructions to support the \"closed world\" assumption, that everything not known to be true is false.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "",
"sec_num": null
},
{
"text": "language? The main reason is that it can be implemented very efficiently. In fact, DCW logic forms the basis of a general purpose programming language, Prolog [9] [I], due to Colmerauer, which has had a wide variety of applications.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "Why does Chat use this curious logic as a meaning representation",
"sec_num": null
},
{
"text": "Prolog can be viewed either as an extension of pure Lisp, or as an extension of a relational database query language.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "Why does Chat use this curious logic as a meaning representation",
"sec_num": null
},
{
"text": "Moreover, the efficiency of the DEC-10 Prolog implementation is comparable both with compiled Lisp [9] and with current relational database systems [6] (for databases within virtual memory).",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "Why does Chat use this curious logic as a meaning representation",
"sec_num": null
},
{
"text": "Chat's second main stage, \"planning\", is responsible for transforming the logical form of the NL query into efficient Prolog [6] . This step is analogous to \"query optlmlsatlon\" in a relational database system. The resulting Prolog form is directly executed to yield the answer to the original question.",
"cite_spans": [
{
"start": 118,
"end": 128,
"text": "Prolog [6]",
"ref_id": null
}
],
"ref_spans": [],
"eq_spans": [],
"section": "Why does Chat use this curious logic as a meaning representation",
"sec_num": null
},
{
"text": "On that's domain of world geography, most questions within the English subset are answered in well under one second, including queries which involve taking Joins between relations having of the order of a thousand tuples.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "Why does Chat use this curious logic as a meaning representation",
"sec_num": null
},
{
"text": "A disadvantage of much current work on NL access to databases is that the work is restricted to providing access to databases, whereas users would appreciate NL interfaces to computer systems in general.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "Why does Chat use this curious logic as a meaning representation",
"sec_num": null
},
{
"text": "Moreover, the attempt to provide a NL \"front-end\" to databases is surely putting the cart before the horse. What one should really do is to investigate what \"back-end\" is needed to support NL interfaces to computers, without being constrained by the limitations of current database management systems. I would argue that the \"logic programming\" approach taken in Chat is the right way to avoid these drawbacks of current work in NL access to databases.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "Why does Chat use this curious logic as a meaning representation",
"sec_num": null
},
{
"text": "Most work which attempts to deal precisely with the meaning of NL sentences uses some system of logic as an intermediate meaning representation",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "Why does Chat use this curious logic as a meaning representation",
"sec_num": null
},
{
"text": "language. Logic programm/ng is concerned with turning such systems of logic into practical computational formalisms. The outcome of this \"top-down\" approach, as reallsed in the language Prolog, has a great deal in common with the relational approach to databases, which can be seen as the result of a \"bottom-up\" effort to make database languages more like natural language. However Prolog is much more general than relational database formalisms, in that it permits data to be defined by general rules having the power of a fully general programming language. The logic programming approach therefore allows one to interface NL to general programs as well as to databases.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "Why does Chat use this curious logic as a meaning representation",
"sec_num": null
},
{
"text": "Current Prolog systems, because they were designed with programming not databases in mind, are not capable of accommodating really large databases.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "Why does Chat use this curious logic as a meaning representation",
"sec_num": null
},
{
"text": "However there seems to be no technical obstacle to building a Prolog system that is fully comparable with current relational database management systems, while retaining Prolog's generality and efficiency as a programming language.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "Why does Chat use this curious logic as a meaning representation",
"sec_num": null
},
{
"text": "Indeed, I expect such a system to be developed in the near future, especially now that Prolog has been chosen as the kernel language for Japan's \"Fifth Generation\" computer project [4] .",
"cite_spans": [
{
"start": 181,
"end": 184,
"text": "[4]",
"ref_id": null
}
],
"ref_spans": [],
"eq_spans": [],
"section": "Why does Chat use this curious logic as a meaning representation",
"sec_num": null
},
{
"text": "A. Aggregate Functions and Quantity Questions To cater for aggregate and quantity determiners, such as plural \"the\", \"two\", \"how many\", etc., DCW logic extends flrst-order logic by allowlng predications of the form: setof(X,P,S) to be read as \"the set of Xs such that P is provable is S\" [7] .",
"cite_spans": [
{
"start": 288,
"end": 291,
"text": "[7]",
"ref_id": null
}
],
"ref_spans": [],
"eq_spans": [],
"section": "II SPECIFIC ISSUES",
"sec_num": null
},
{
"text": "An efficient implementation of *aetof\" is provided in DEC-10 Prolog and used in Chat. Sets are actually represented as ordered llsts without dupllcate elements. Something along the lines of \"setof\" seems very necessary, as a first step at least.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "II SPECIFIC ISSUES",
"sec_num": null
},
{
"text": "The question of how to treat explicitly stored aggregate information, such as \"number of employees\" in a department, is a speclal case of the general issue of storing and accessing nonprimitive information, to be discussed below in section D.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "II SPECIFIC ISSUES",
"sec_num": null
},
{
"text": "The problem of providing a common framework for time instants and time intervals is not one that I have looked into very far, but it would seem to be primarily a database rather than a linguistic issue, and to highlight the limitations of traditional databases, where all facts have to be stored explicitly.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "B. Time and Tense",
"sec_num": null
},
{
"text": "Queries concerning time instants and intervals will generally need to be answered by calculatlon rather than by simple retrieval.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "B. Time and Tense",
"sec_num": null
},
{
"text": "A common framework for both calculation and retrieval is precisely what the logic programming approach provides. For example, the predication:",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "B. Time and Tense",
"sec_num": null
},
{
"text": "sailed(kennedy,July82,D)",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "B. Time and Tense",
"sec_num": null
},
{
"text": "occurring in a query might invoke a Prolog procedure \"sailed\" to calculate the distance D travelled, rather than cause a simple data lookup.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "B. Time and Tense",
"sec_num": null
},
{
"text": "Quantifying into Questions",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "C.",
"sec_num": null
},
{
"text": "Quantifying into questions is an issue which was an important concern in Chat, and one for which I feel we produced a reasonably adequate solution.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "C.",
"sec_num": null
},
{
"text": "The question \"Who manages every department?\" would be translated into the following logical form:",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "C.",
"sec_num": null
},
{
"text": "where \"\\+\" is to be read as \"it is not known that\", i.e. the logical form reads \"M is an answer if there is no known department that M does not manage\".",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "C.",
"sec_num": null
},
{
"text": "The question \"Who manages each department?\", on the other hand, would translate into:",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "C.",
"sec_num": null
},
{
"text": "answer(D-M) <-department(D) & manages(M,D)",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "C.",
"sec_num": null
},
{
"text": "generating answers which would be pairs of the form:",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "C.",
"sec_num": null
},
{
"text": "accounts -andrews ; sales -smith ; etc.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "C.",
"sec_num": null
},
{
"text": "The two different loglcal forms result from the different treatments accorded to \"each\" and \"every\" by Chat's determiner scoplng algorithm ",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "C.",
"sec_num": null
},
{
"text": "My general feeling here is that one should not struggle too hard to bend one's NL interface to fit an existing database. Rather the database should be designed to meet the needs of NL access. If the database does not easily support the kind of NL queries the user wants to ask, it is probably not a well-deslgned database. In general it seems best to design a database so that only primitive facts are stored explicitly, others being derived by general rules, and also to avoid storing redundant information.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "D. Querying Semantically Complex Fields",
"sec_num": null
},
{
"text": "However this general philosophy may not be practicable in all cases.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "D. Querying Semantically Complex Fields",
"sec_num": null
},
{
"text": "Suppose, indeed, that \"childofalumnus\" is stored as primitive information. Now the logical form for \"Is John Jones a child of an alumnus?\" would be:",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "D. Querying Semantically Complex Fields",
"sec_num": null
},
{
"text": "answer(yes) <- childof(X,JohnJones) & alumnus(X)",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "D. Querying Semantically Complex Fields",
"sec_num": null
},
{
"text": "What we seem to need to do is to recognlse that in this particular case a simplification is possible using the following definition:",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "D. Querying Semantically Complex Fields",
"sec_num": null
},
{
"text": "chlldofalumnus(X) <-> exlsts(Y, childof(Y,X) & alumnus(Y))",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "D. Querying Semantically Complex Fields",
"sec_num": null
},
{
"text": "giving the derived query:",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "D. Querying Semantically Complex Fields",
"sec_num": null
},
{
"text": "answer(yes) <= childofalumnus(JohnJones)",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "D. Querying Semantically Complex Fields",
"sec_num": null
},
{
"text": "However the loglcal form:",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "D. Querying Semantically Complex Fields",
"sec_num": null
},
{
"text": "answer(X) <= childof(X,JohnJones) & alumnus(X)",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "D. Querying Semantically Complex Fields",
"sec_num": null
},
{
"text": "corresponding to \"Of which ~!umnus is John Jones a child?\" would not be susceptible to simplification, and the answer to the query would have to be \"Don't know\".",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "D. Querying Semantically Complex Fields",
"sec_num": null
},
{
"text": "At the root of the difficulties raised here is the question of what to do when the concepts used in the NL query do not directly correspond to what is stored in the database.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "D. Querying Semantically Complex Fields",
"sec_num": null
},
{
"text": "With the logic programming approach taken in Chat, there is a slmple solution.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "D. Querying Semantically Complex Fields",
"sec_num": null
},
{
"text": "The database is augmented with general rules which define the NL concepts in terms of the explicitly stored data. For example, the rule:",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "D. Querying Semantically Complex Fields",
"sec_num": null
},
{
"text": "lengthofCS,L) <= classof(S,C) & classlengthof(C,L).",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "D. Querying Semantically Complex Fields",
"sec_num": null
},
{
"text": "says that the length of a ship is the length of that ship's class. These rules get invoked while a query is being executed, and may be considered to extend the database with \"virtual files\". Often a better approach would be to apply these rules to preprocess the query in advance of actual execution.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "D. Querying Semantically Complex Fields",
"sec_num": null
},
{
"text": "In any event, there seems to be no need to treat Joins as implicit, as systems such as Ladder have done. Joins, which are equivalent to conjunctions in a logical form, should always be expressed explicitly, either in the original query, or in other domaln-dependent rules which help to support the NL interface.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "D. Querying Semantically Complex Fields",
"sec_num": null
},
{
"text": "A FURTHER ISSUE -SEMANTICS OF PLURAL \"THE\"",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "III",
"sec_num": null
},
{
"text": "A difficulty we experienced in developing Chat, which I would propose as one of the most pressing problems in NL access to databases, is to define an adequate theoretical and computational semantics for plural noun phrases, especially those with the definite article \"the\".",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "III",
"sec_num": null
},
{
"text": "It is a pressing problem because clearly even the most minimal subset of NL suitable for querying a database must include plural \"the\". The problem has two aspects: (I) to define a precise semantics that is strictly correct in all cases;",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "III",
"sec_num": null
},
{
"text": "(2) to implement this semantics in an efficient way, giving results comparable to what could be achieved if a formal database query language were used in place of NL.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "III",
"sec_num": null
},
{
"text": "As a first approximation, Chat treats plural definite noun phrases as introducing sets, formallsed using the \"setof\" construct mentioned earlier.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "III",
"sec_num": null
},
{
"text": "Thus the translation of \"the European countries\" would be S where: setof(C,european(C) & country(C),S).",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "III",
"sec_num": null
},
{
"text": "The main drawback of this approach is that it leaves open the question of how predicates applied to sets relate to those same predicates applied to individuals.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "~:\"",
"sec_num": null
},
{
"text": "Thus the question \"Do the European countries border the Atlantic?\" gets as part of its translation: Chat only makes this default assumption in the course of query execution, which may well be very inefficient.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "~:\"",
"sec_num": null
},
{
"text": "If the \"setof\" can effectively be dispensed with, producing a simpler logical form, one would like to do this at an earlier stage and take advantage of optlmisatlons applicable to the simpler logical form.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "~:\"",
"sec_num": null
},
{
"text": "A further complication is illustrated by a question such as \"Who are the children of the employees?\".",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "~:\"",
"sec_num": null
},
{
"text": "A reasonable answer to this question would be a table of employees with their children, which is what Chat in fact produces.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "~:\"",
"sec_num": null
},
{
"text": "If one were to use the more slmple-mlnded approximations discussed so far, the answer would be simply a set of children, which would be empty (1) if the \"childof\" predicate were treated as distributive.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "~:\"",
"sec_num": null
},
{
"text": "In general, therefore, Chat treats nested definite noun phrases as introducing '*indexed sets\", although the treatment is arguably somewhat ad hoc.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "~:\"",
"sec_num": null
},
{
"text": "A phrase llke \"the children of the employees\" translates into S where:",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "~:\"",
"sec_num": null
},
{
"text": "setof(E-CC,employee(E) & setof(C,childof(E,C),CC),S).",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "~:\"",
"sec_num": null
},
{
"text": "If the indexed set occurs, not in the context of a question, but as an argument to another predicate, there is the further complication of defining the semantics of predicates over indexed sets. Consider, for example, \"Are the major cities of the Scandinavian countries linked by rail?\". In cases involving aggregate operators such as \"total\" and \"average\", an indexed set is clearly needed, and Chat handles these cases correctly. Consider, for example, \"What is the average of the salaries of the part-time employees?\".",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "~:\"",
"sec_num": null
},
{
"text": "One cannot slmply average over a set of salaries, since several employees may have the same salary; an indexed set ensures that each employee's salary is counted separately.",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "~:\"",
"sec_num": null
},
{
"text": "To summarise the overall problem, then, can one find a coherent semantics for plural \"the\" that is intuitively correct, and that is compatible with efficient database access?",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "~:\"",
"sec_num": null
},
{
"text": "answer(M) <-\\+ exlsts(D, department(D) & \\+manages(M,D))",
"cite_spans": [],
"ref_spans": [],
"eq_spans": [],
"section": "",
"sec_num": null
}
],
"back_matter": [],
"bib_entries": {
"BIBREF0": {
"ref_id": "b0",
"title": "Pro~ramm/ng i_.nn Prolo~",
"authors": [
{
"first": "\u2022",
"middle": [
"I"
],
"last": "Clocksln",
"suffix": ""
},
{
"first": "W F",
"middle": [],
"last": "Mellish",
"suffix": ""
},
{
"first": "C S",
"middle": [],
"last": "",
"suffix": ""
}
],
"year": 1981,
"venue": "",
"volume": "",
"issue": "",
"pages": "",
"other_ids": {},
"num": null,
"urls": [],
"raw_text": "\u2022 I. Clocksln W F and Mellish C S. Pro~ramm/ng i_.nn Prolo~. Springer-Verlag, 1981.",
"links": null
},
"BIBREF1": {
"ref_id": "b1",
"title": "Un sous-ensemble interessant du francais",
"authors": [
{
"first": "A",
"middle": [],
"last": "Colmerauer",
"suffix": ""
}
],
"year": 1977,
"venue": "Presented as -~-An interesting natural language subset\" at the Workshop on Logic and Databases",
"volume": "13",
"issue": "",
"pages": "309--336",
"other_ids": {},
"num": null,
"urls": [],
"raw_text": "Colmerauer A. Un sous-ensemble interessant du francais. RAIRO 13, 4 (1979), pp. 309-336. [Presented as -~-An interesting natural language subset\" at the Workshop on Logic and Databases, Toulouse, 1977].",
"links": null
}
},
"ref_entries": {}
}
} |