Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
LINK-PARSER(1)		     General Commands Manual		  LINK-PARSER(1)

NAME
     link-parser - parse natural language sentences using Link Grammar

SYNOPSIS
     link-parser --help
     link-parser --version
     link-parser [language|dict_location] [--quiet] [-<special_"!"_command>...]

DESCRIPTION
     link-parser  is  the  command-line wrapper to the link-grammar natural lan-
     guage parsing library.  This library will parse sentences written	in  Eng-
     lish,  Russian  and other languages, generating linkage trees showing rela-
     tionships between the subject, the verb, and various  adjectives,	adverbs,
     etc. in the sentence.

EXAMPLE
     link-parser

     Starts the parser interactive shell.  Enter any sentence to parse:

     linkparser> Reading a man page is informative.

     Found 18 linkages (18 had no P.P. violations)
	     Linkage 1, cost vector = (UNUSED=0 DIS= 0.00 LEN=16)

	 +------------------------Xp------------------------+
	 +--------------->WV-------------->+		    |
	 |	   +----------Ss*g---------+		    |
	 |	   +--------Os-------+	   |		    |
	 |	   |	 +---Ds**x---+	   |		    |
	 +--->Wd---+	 +-PHc+---A--+	   +---Pa---+	    |
	 |	   |	 |    |      |	   |	    |	    |
     LEFT-WALL reading.g a man.ij page.n is.v informative.a .

BACKGROUND
     The  link-parser  command-line  tool  is useful for general exploration and
     use, although it is presumed that, for the parsing of large  quantities  of
     text,  developers	will  create  a  custom  application,  making use of the
     link-grammar library.  Several such applications are described on the  Link
     Grammar web page (see SEE ALSO below).

     The  theory  of  Link Grammar is explained in many academic papers.  In the
     first of these, Daniel Sleator and Davy Temperley, "Parsing English with  a
     Link  Grammar"  (1991), the authors defined a new formal grammatical system
     called a "link grammar". A sequence of words is in the language of  a  link
     grammar  if there is a way to draw "links" between words in such a way that
     the local requirements of each word are satisfied, the links do not  cross,
     and  the  words form a consistent connected graph. The authors encoded Eng-
     lish grammar into such a system, and wrote link-parser to parse English us-
     ing this grammar.

     The engine that performs the parsing is separate from the dictionaries  de-
     scribing a language.  Currently, the most fully developed, complete dictio-
     naries  are  for  the English and Russian languages, although experimental,
     incomplete dictionaries exist for German and eight other languages.

OVERVIEW
     link-parser, when invoked manually, starts  an  interactive  shell,  taking
     control  of the terminal.	Any lines beginning with an exclamation mark are
     assumed to be a "special command"; these are described below.  The  command
     !help  will provide more info; the command !variables will print all of the
     special commands.	These are also called "variables", as  almost  all  com-
     mands  have  a  value associated with them: the command typically enable or
     disable some function, or they alter some multi-valued setting.

     All other input is treated as a single, English-language  sentence;  it  is
     parsed, and the result of the parse is printed.  The variables control what
     is  printed:   By	default,  an ASCII-graphics linkage is printed, although
     post-script output is also possible.  The printing of the constituent  tree
     can  also	be  enabled.  Other output controls include the printing of dis-
     juncts and complete link data.

     In order to analyze sentences, link-parser depends on a  link-grammar  dic-
     tionary.	This contains lists of words and associated metadata about their
     grammatical properties.  An English language dictionary is provided by  de-
     fault.   If other language dictionaries are installed in the default search
     locations, these may be explicitly specified by means  of	a  2-letter  ISO
     language code: so, for example:

	 link-parser de

     will start the parser shell with the German dictionary.

     Alternately,  the	dictionary location can be specified explicitly with ei-
     ther an absolute or a relative file path; so, for example:

	 link-parser /usr/share/link-grammar/en

     will run link-parser using the English dictionary located	in  the  typical
     install directory.

     link-parser  can  also be used in a non-interactive mode ("batch mode") via
     the -batch option (a special command, see below): So, for example:

	 cat thesis.txt | link-parser -batch

     will read lines from the file thesis.txt, processing each one as a complete
     sentence. For sentences that don't have a full parse, it will print
     +++++ error N
     (N is a number) to the standard output.

     Alternately, an input file may be specified with the !file filename special
     command, described below.

     Note that using "batch mode"  disables  the  usual  ASCII-graphics  linkage
     printing.	The  input  sentences  also  don't  appear by default on stdout.
     These features may be re-enabled via special commands; special commands may
     be interspersed with the input.

     Instead of specifying -batch in the command-line, !batch can  be  specified
     in the said input file.

     For more details, use !help batch in link-parser's interactive shell.

OPTIONS
     --help
	    Print usage and exit.

     --version
	    Print program version and configuration details, and exit.

     --quiet
	    Suppress the version messages on startup.

   Special ! commands
     The  special  "!"	commands can be specified as command-line options in the
     command-line, or within the interactive shell itself by prefixing them with
     "!" on line start.  The full option name does not need  to  be  used;  only
     enough letters to make the option unique must be specified.

     When specifying as a command-line option, a special command is proceeded by
     "-" instead of "!".

     Boolean  variables  may be toggled simply by giving the !varname, for exam-
     ple, !batch.   Setting  other  variables  require	using  an  equals  sign:
     !varname=value, for example, !width=100.

     The  !help  command  prints  general help. When issued from the interactive
     shell, it can get an argument, usually a special command.	 The  !variables
     command  prints  all  of  the current variable settings.  The !file command
     reads input from its argument file.  The !file command is not  a  variable;
     it cannot be set.	It can be used repeatedly.

     The !exit command instructs link-parser to exit.

     The  exclamation  mark "!" is also a special command by itself, used to in-
     spect the dictionary entry for any given word (optionally terminated  by  a
     subscript).   Thus two exclamation marks are needed before such a word when
     doing so from the interactive shell. The  wildcard  character  "*"  can  be
     specified	as  the  last  character  of  the word in order to find multiple
     matches.

     Default values of the special commands below are shown in parenthesis. Most
     of them are the default ones of the link-grammar library.
     Boolean default values are shown as on (1) or off (0).

     !bad (off)
	    Enable display of bad linkages.

     !batch (off)
	    Enable batch mode.

     !constituents (0)
	    Generate constituent output. Its value may be:

	    0	   Disabled

	    1	   Treebank-style constituent tree

	    2	   Flat, bracketed tree [A like [B this B] A]

	    3	   Flat, treebank-style tree (A like (B this))

     !cost-max (2.7)
	    Largest cost to be considered.

     !dialect (no value)
	    Use the specified (comma-separated) names.
	    They modify the disjunct cost of dictionary words whose  expressions
	    contain symbolic cost specifications.

     !disjuncts (off)
	    Display of disjuncts used.

     !echo (off)
	    Echo input sentence.

     !graphics (on)
	    Enable graphical display of linkage.  For each linkage, the sentence
	    is	printed  along	with  a  graphical representation of its linkage
	    above it.

	    The following notations are used for words in the sentence:

	    [word] A word with no linkage.

	    word[?].x
		   An unknown word whose POS category x has been  found  by  the
		   parser.

	    word[!]An  unknown word whose link-grammar dictionary entry has been
		   assigned by a RegEx.  (Use !morphology=1 to see the said dic-
		   tionary entry.)

	    word[~]There was an unknown word in this position, and  it	has  got
		   replaced,  using  a spell guess with this word, that is found
		   in the link-grammar dictionary.

	    word[&]This word is a part of an unknown word which has  been  found
		   to  consist of two or more words that are in the link-grammar
		   dictionary.

	    word.POS
		   This word found in the dictionary as word.POS.

	    word.#CORRECTION
		   This word is probably a typo - got linked as  an  alternative
		   word CORRECTION.

	    For  dictionaries  that  support  morphology  (enable with !morphol-
	    ogy=1):

	    word=  A prefix morpheme

	    =word  A suffix morpheme

	    word.= A stem

     !islands-ok (on)
	    Use null-linked islands.

     !limit (1000)
	    Limit the maximum linkages processed.

     !links (off)
	    Enable display of complete link data.

     !null (on)
	    Allow null links.

     !morphology (off)
	    Display word morphology.  When a word  matches  a  RegEx,  show  the
	    matching dictionary entry.

     !panic (on)
	    Use "panic mode" if a parse cannot be quickly found.
	    The  command  !panic_variables prints the special variables that are
	    used only in "panic mode".

     !postscript (off)
	    Generate postscript output.

     !short (16)
	    Maximum length of short links.

     !spell (7)
	    If zero, no spell and run-on corrections of unknown words  are  per-
	    formed.
	    Else,  use	up  to this many spell-guesses per unknown word. In that
	    case, the number of run-on corrections (word split) of unknown words
	    is not limited.

     !timeout (30)
	    Abort parsing after this many seconds.

     !use-sat (off)
	    Use Boolean SAT-based parser.

     !verbosity (1)
	    Level of detail in output. Some useful values:

	    0	   No prompt, minimal library messages

	    1	   Normal verbosity

	    2	   Show times of the parsing steps

	    3	   Display some more information messages

	    4	   Display data file search and locale setup

	    5-9    Tokenizer and parser debugging

	    10-19  Dictionary debugging

	    101    Print all the dictionary connectors, along with their  length
		   limit

     !walls (off)
	    Display wall words.

     !width (16381)(*)
	    The width of the display.
	    * When writing to a terminal, this value is set from its width.

     !wordgraph (0)
	    Display the wordgraph (word-split graph).

	    0	   Disabled

	    1	   Default display

	    2	   Display parent tokens as subgraphs

	    3	   Use esoteric display flags as set by !test=wg:FLAGS

FILES
     The  following files are per-language, when LL is the 2-letter ISO language
     code.

     LL/4.0.dict
	    The Link Grammar dictionary.

     LL/4.0.affix
	    Values of entities used in tokenization.

     LL/4.0.regex
	    Regular expressions (see regex(7)) that are used to match tokens not
	    found in the dictionary.

     LL/4.0.dialect
	    Dialect component definitions.

     LL/4.0.knowledge
	    Post-processing definitions.

     LL/4.0.constituent-knowledge
	    Definitions for producing a constituent tree.

     command-help-LL.txt or command-help-LL-CC.txt
	    Help text for the !help topic special "!" command.	If several  such
	    files are provided, the desired one can be selected by e.g. the LAN-
	    GUAGE  environment	variable if it is set to LL or LL-CC (default is
	    en). Currently only command-help-en.txt is provided.

     The directory search order for these files is:
	    * ./
	    * data/
	    * ../
	    * ../data/
	    *	A  custom   data   directory,	as   set   by	the   API   call
	    dictionary_set_data_dir().
	    *  Installation-depended system data directory (*)

	    *  This  location  is displayed as DICTIONARY_DIR when the --version
	    argument is provided to link-parser on the command line.  On windows
	    it may be relative to the location of the link-grammar library  DLL;
	    in that case the actual location is displayed as "System data direc-
	    tory" when link-parser is invoked with -verbosity=4.

SEE ALSO
     The  link-generator command can be used to generate random sentences from a
     given dictionary.

     Information on the link-grammar shared-library API and the link types  used
     in the parse is available at the Link Grammar website.

     Peer-reviewed  papers  explaining Link Grammar can be found at original CMU
     site.

     The source code of link-parser and the link-grammar library is  located  at
     GitHub.

     The  mailing  list  for  Link  Grammar discussion is at link-grammar Google
     group.

AUTHOR
     link-parser and the link-grammar library were  written  by  Daniel  Sleator
     <sleator@cs.cmu.edu>,  Davy Temperley <dtemp@theory.esm.rochester.edu>, and
     John Lafferty <lafferty@cs.cmu.edu>

     This manual page was written by Ken Bloom <kbloom@gmail.com> for the Debian
     project and updated by Linas Vepstas <linasvepstas@gmail.com>.

Version 5.9.0			   2021-03-30			  LINK-PARSER(1)

Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=link-parser&sektion=1&manpath=FreeBSD+Ports+15.1.quarterly>

home | help