1. Introduction

• Word order and meaning - syntactic analysis aims to extract the dependence of words with other words in the document. If we change the order of words, then it will be difficult to understand the sentence;
• Retention of stop words - if we remove stop words, then the meaning of a sentence can be changed altogether;
• Word morphology - stemming, lemmatization will bring words to their basic form, thereby changing the grammar of the sentence;
• Parts of speech of words in a sentence - identifying the correct speech part of a word is important.

2. Materials

• the identification of the special grammatical relation to the subject position of any sentence analyzed by this clause vis-à-vis the NP appearing in it;
• the identification of all grammatical relations of the sentence with those of the VP.

3. Methodology

• The required packages and modules are imported using the require function. The wink-nlp package is imported as winkNLP, and the English language model is imported accordingly:
  // Load required packages and modules:
  const winkNLP = require(’wink-nlp’);
  const model = require(’wink-eng-lite-web-model’);
  const pl = require("tau-prolog");.
• The tau-prolog package is imported as pl, and a session is created with pl.create(1000):
  // Create a new session:
  const session = pl.create(1000);
• The winkNLP function is invoked with the imported model to instantiate the nlp object:
  // Instantiate winkNLP:
  const nlp = winkNLP(model);
• The its and show variables are assigned to nlp.its and a function that logs the formatted answer from the tau-prolog session, respectively:
  // Define helper functions:
  const its = nlp.its;
  const showAnswer = x => console.log(session.format_answer(x));
• The item variable is assigned the value of the third argument passed to the Node.js script using process.argv[2]:
  // Get command line argument:
  const inputItem = process.argv[2]; //’the boy eats the apples.the woman runs the alley’;
  // in the back. a woman runs freely on the alley’;
• The program variable is assigned a Prolog program represented as a string. It defines rules for sentence structure, including noun phrases, verb phrases, and intransitive verbs. The program also includes rules for intransitive verbs, e.g. "runs" and "laughs":[11]
  // Define the program and goal:
  let program = `
  s(A,B) :- np(A,C), vp(C,D), punct(D,B).
  np(A,B) :- proper_noun(A,B).
  np(A,B) :- det(A,C), noun(C,B).
  vp(A,B) :- verb(A,C), np(C,B).
  vp(A, B) :- intransitive_verb(A, B).
  proper_noun([Eesha|A],A).
  proper_noun([Eeshan|A],A).
  intransitive_verb([runs|A],A).
  intransitive_verb([laughs|A],A).
  punct(A,A).
  `;
• The nlp.readDoc function is used to create a document object from the inputItem. The code then iterates over each sentence and token in the document, extracting the type of entity and its part of speech:
  const doc = nlp.readDoc(inputItem);
  let entityMap = new Map();
  // Extract entities from the text:
  doc.sentences().each((sentence) => {
  sentence.tokens().each((token) => {
  entityMap.set(token.out(its.value), token.out(its.pos));
  });});
• The extracted entities and their parts of speech are stored in a Map object as Prolog rules:
  // Add entity rules to the program:
  const mapEntriesToString = (entries) => {
  return Array.from(entries, ([k, v]) => `
  n ${v.toLowerCase()}(S0,S) :- S0=[${k.toLowerCase()}|S].`).join("") + "
  n";
  }
  //console.log(mapEntriesToString([...entityMap.entries()]));
• The generated Prolog rules are appended to the program string:
  program += mapEntriesToString([...entityMap.entries()]);
• The session.consult function is used to load the Prolog program into the tau-prolog session. Then, the session.query function is used to query the loaded program with the specified goals. The session.answers function is used to display the answers obtained from the query:
  doc.sentences().each((sentence) => {
  let goals = `s([${sentence.tokens().out()}],[]).`;
  session.consult(program,{
  success: function() {
  session.query(goals, {
  success: function() {
  session.answers(showAnswer);
  }})}})});

4. Results

5. Discussion

Abbreviations

References

1. de Kok, D., Brouwer, H. Natural Language Processing for the Working Programmer, Available online: https://www.researchgate.net/publication/259572969_Draft_Natural_Language_Processing_for_the_Working_Programmer (accessed on 16 Aug. 2023).
2. NLP: Building a Grammatical Error Correction Model. Available online: https://towardsdatascience.com/nlp-building-a-grammatical-error-correction-model-deep-learning-analytics-c914c3a8331b (accessed on 16 Aug. 2023).
3. Syntactic Analysis - Guide to Master Natural Language Processing(Part 11). Available online: https://www.analyticsvidhya.com/blog/2021/06/part-11-step-by-step-guide-to-master-nlp-syntactic-analysis (accessed on 16 Aug. 2023).
4. Relation Extraction and Entity Extraction in Text using NLP. Available online: https://nikhilsrihari-nik.medium.com/identifying-entities-and-their-relations-in-text-76efa8c18194 (accessed on 16 Aug. 2023).
5. Bercaru, G.; Truică, C.-O.; Chiru, C.-G.; Rebedea, T. Improving Intent Classification Using Unlabeled Data from Large Corpora. Mathematics 2023, 11, 769. [CrossRef]
6. Jose F. Morales, Rémy Haemmerlé, Manuel Carro, and Manuel V. Hermenegildo. Lightweight compilation of (C)LP to JavaScript. Theory and Practice of Logic Programming 2012, 12(4-5), 755–773. [CrossRef]
7. Krill, P. (2023). C++ still shining in language popularity index, InfoWorld, Available online: https://www.infoworld.com/article/3687174/c-still-shining-in-language-popularity-index.html (accessed on 16 Aug. 2023).
8. An open source Prolog interpreter in JavaScript. Available online: https://socket.dev/npm/package/tau-prolog (accessed on 16 Aug. 2023).
9. Frey W.; Reyle U. A Prolog Implementation of Lexical Functional Grammar as a Base for a Natural Language Processing System. Conference of the European Chapter of the Association for Computational Linguistics (1983); URL: https://api.semanticscholar.org/CorpusID:17161699. [CrossRef]
10. Logic programming in JavaScript using LogicJS. Available online: https://abdelrahman.sh/2022/05/logic-programming-in-javascript (accessed on 16 Aug. 2023).
11. Kamath, R, Jamsandekar, S., Kamat, R. Exploiting Prolog and Natural Language Processing for Simple English Grammar. In Proceedings of National Seminar NSRTIT-2015, CSIBER, Kolhapur, Date of Conference (March 2015); URL: URL: https://www.researchgate.net/publication/280136353_Exploiting_Prolog_and_Natural_Language_Processing_for_Simple_English_Grammar.
12. Khanfor, A.,Yang, Y. (2017). An Overview of Practical Impacts of Functional Programming, 24th Asia-Pacific Software Engineering Conference Workshops, DOI: 10.1109/APSECW.2017.27, URL: https://www.researchgate.net/publication/323714122. [CrossRef]