WebSVN – wimsdev – /trunk/wims/public_html/scripts/help/symtext/symtext.phtml

!set p2=!item 2 of $special_parm
!if $p2!=$empty
!if $p2=list
!read help/symtext/list.phtml
!if $stylecnt > 0
!exit
!endif
!endif
!set test=!defof style_exists in symtext/$module_language/$p2/def
!if $test=yes
!changeto symtext/$module_language/$p2/help.phtml
!endif
!endif
<h2>Symtext documentation</h2>
!href cmd=help&special_parm=symtext,list List of symtext styles
.
Symtext is a natural language parsing syntax. It is designed to make it
easier to identify different ways to say the same thing in natural language,
and its main purpose is for the recognition of freely typed or composed
short text answers to exercises.
Recognition of free text answers is difficult due to the following facts.
<ul>
<li>Different context requires different tolerance and precision. A language
exercise cannot tolerate spelling or grammar error, which may not be the
case for a mathematical exercise.
</li>
<li>Natural language often allows many different ways to say the same thing,
between "A or B" and "B or A", "Paul is older than Bill" and "Bill is
younger than Paul", "x and y are similar" and "x is similar to y", or even
"this costs too much" and "it is too expensive".
</li>
<li>Typing errors are common in freely typed text. In many cases, typing
errors should be tolerated. But before an unknown word, it is difficult for
the software to tell whether it is a typing error or a bad answer.
</li>
</ul>
In view of the above, the design of symtext has incorporated the following
features.
<ul>
<li>A nestable syntax allowing the identification of various language
alternatives (different ways to say the same thing).
</li>
<li>Macro dictionaries can be defined to help improve the human readability
of the matching rules.
</li>
<li>User-definable multiple dictionaries that can be used for various text
analysis purposes.
</li>
<li>Designated portions of the text can be output for further processing.
</li>
<li>
It is based on user-definable styles, with different styles defining
different dictionaries and macros. So they can be used to deal with
different context.
</li>
<li>Language scope can be delimited by declaring the list of allowed words.
Text containing words not in the list can be considered to be out-scope and
be sent back for rephrasing, instead of being rejected as bad answer. A
correct use of this feature can solve most of the problems related to typing
errors and unexpected answers.
</li>
</ul>
<hr><h3>
How it works</h3>
Symtext deals with the problem of comparing two sentences. The first is the
sample which is typically the answer given to an exercise. It is
compared to the second sentence, the tester, which is typically the
good answer as declared by the author of the exercise.
The sample must be plain text in natural language, while the tester may
contain symtext rules allowing it to match various samples
that are considered to have the same meaning. Such various ways to say the
same thing are alternatives in the natural language. The scope of the
acceptable alternatives depends on the context of the exercise, therefore
must be precisely defined by the author. Symtext is designed to allow
authors to make such definitions.
Symtext rules are word based, that is, it only compares words. A word is a
chain of alphabetic characters or digits delimited by spaces or special
symbols (parentheses, quotes, punctuations etc.). Any special symbol is
considered as a word by itself. And symtext does not count the number of
space characters between two words: any chain of consecutive space
characters will be reduced to one space.
A set of basic builtin rules are defined in the symtext syntax. For
example, the rule [Iperm:x,and,y] matches both samples "x and y"
and "y and x". Rules can be nested:
<pre>neither [Aperm:[Alt:I,me,we,us],nor,our teacher]</pre>
matches the following 8 cases.
"neither I nor our teacher", "neither our teacher nor I", "neither me nor
our teacher", "neither our teacher nor me", "neither we nor our teacher",
"neither our teacher nor we", "neither us nor our teacher", "neither our
teacher nor us".
In general applications, a context style can be declared before
making the comparison. A style is a set of dictionaries and options. These
include pre-transformation dictionaries that can be used for example to
identify singular and plural words before comparison, a macro dictionary
that can simplify the writing of tester rules and make it more readable, and
user-definable dictionaries for various other purposes.
!href cmd=help&special_parm=symtext,list List of styles
.
For example, a positional macro _divides can be defined in
the macro dictionary, so that the tester x _divides [y + z] will
match the following samples.
"x divides y + z", "x is a factor of y + z", "y + z is divisible by x", "y +
z is a multiple of x".
Note here that such a macro is positional, so that the string "y + z" must
be enclosed in a pair of brackets to make them look as one word for the
macro. Otherwise it will rather match things like "y is a multiple of x +
z", which clearly is wrong.
This example shows that the final power of the syntax depends primarily on the
construction of the macro dictionary (which will vary from style to style).
The tester is a text string containing ordinary words, matching rules and
positional macros. An ordinary word is simply compared with the word at the
corresponding position in the sample, while matching rules and macros can
match multiple possibilities in the sample.
Before comparison takes place, words in both the sample and the tester may
first be transformed in order to identify small differences that one wants
to ignore, such as upper and lower cases, singular and plural nouns etc.
Unlike regular expression, symtext match occurs only if the tester matches
the whole sample. Match does not occur if the tester only matches a part of
the sample. However, wildcard rules can be included in the tester if part of
the sample needs to be ignored.
<hr><h3>Details of the syntax</h3>
Definitions. <ul>
<li>A tstring is a succession of atoms.
</li><li>An atom is either a word, a bracket block or
a positional macro name.
</li><li>A word is either a list of consecutive alphanumerical
characters or a single special character. In the first case, the word is
delimited by either spaces or non-alphanumerical characters.
</li><li>A bracket block is a substring enclosed by a pair of brackets.
It can be either a tstring, or a matching rule.
</li><li>A positional macro is a word (macro name) preceded by the
underline character. The macro name must be defined in the macro dictionary,
otherwise the whole atom will be treated as an ordinary word.
</li></ul>
A matching rule may be either builtin or defined in the style macro
dictionary. It must be enclosed by a pair of brackets, and the first
character must be alphabetic. If the first character is upper-case, it is
builtin. otherwise it is a macro.
Syntax of the matching rule: [rule_name:parameters].
rule_name must start with the first character of the block, it must
be a valid rule name, and the colon must immediately follow the name (no
spaces inserted). Otherwise the block will be treated as a normal tstring
rather than a rule.
Parameters is a comma-separated list of strings. Each parameter can
be a tstring itself (hence can contain nested subrules), except in some
special cases of builtin rules where some of the parameter has a special
meaning, e.g. the first parameter of the rule Pick must be a
positive integer.
There are also two special bracket blocks that are in fact simplifications
of builtin matching rules:
<ul><li>
[A|B|C] is equivalent to [Alt:A,B,C]. For this
reason, the character | is reserved. To have it matched, write
[|] (or [Alt:|]).
</li><li>
[**] is equivalent to [Wild:**], [* *] is
equivalent to [Wild:* *], etc. A block falls into this category if
the first character is a '*'.
</ul>
<hr><h3>Builtin rules</h3>
A builtin rule is a matching rule where the first character of the name is
upper-case.
Any parameter may include the comma character, as long as it is enclosed by
a pair of parentheses or brackets.
!read tabletheme
!set wims_backslash_insmath=yes
$table_header
$table_hdtr
<th>name</th>
<th>Number of parameters</th>
<th>Effect</th>
<th>Detail</th>
</tr>
$table_tr
<td>Alt</td>
<td align=middle>\(>= 1)</td>
<td>Matches any one of the parameters.</td>
<td>[Alt:a,b,c d] matches "a", "b" or "c d".</td>
</tr>
$table_tr
<td>Aperm</td>
<td align=middle>\(>= 3)</td>
<td>"And" styled permutation.</td>
<td>[Aperm:[,],and,A,B,C] matches "A, B and C", "B, A and C", etc.
The order of parameters 3 and up is arbitrary, and the first two parameters
are used to insert between them: parameter 1 is inserted except for the
last insertion where parameter 2 is inserted.
</td></tr>
$table_tr
<td>Apick</td>
<td align=middle>\(>= 4)</td>
<td>"And" styled arbitrary selection.</td>
<td>[Apick:3,[,],and,A,B,C,D,E] matches "B, E and A", "C, A and E",
etc. Parameter 1 must be an integer and gives the number of items to pick.
</td></tr>
$table_tr
<td>Dic</td>
<td align=middle>\(1)</td>
<td>Dictionary check</td>
<td>[Dic:wordtype transitive verb] matches any word or group of
words that is defined in the dictionary "wordtype", with a definition that
contains an item "transitive verb".
Note. No word transformation is performed on the parameter of this rule.
</td></tr>
$table_tr
<td>Dperm</td>
<td align=middle>\(4)</td>
<td>Dependent permutation: parameters to match depend on the sample.</td>
<td>[Dperm:a,b,c,d] matches either "a b c" or "c d a", but nothing
else. For example,
[Dperm:x,beats,y,is beaten by] matches either "x beats y" or "y is
beaten by x". Or in French,
il [Dperm:,y,est allé,à Paris] matches either "il y est allé" or
"il est allé à Paris".
</td></tr>
$table_tr
<td>Ins</td>
<td align=middle>\(>= 3)</td>
<td>Arbitrary insertion of parameter 1.</td>
<td>[Ins:A,B,C,D,E] matches "B A C D E", "B C A D E", "B C D A E".
Parameter 2 and up must be matched in the given order, while parameter 1 may
find its place anywhere between them.
To match "A B C D", "B A C D", "B C A D" and "B C D A", put two empty
parameters: [Ins:A,,B,C,D,].
</td></tr>
$table_tr
<td>Iperm</td>
<td align=middle>\(3)</td>
<td>Inter-permutation.</td>
<td>[Iperm:Bill,and,Alice] matches "Bill and Alice" and "Alice and
Bill". But not the three words in any other order.
</td></tr>
$table_tr
<td>M</td>
<td align=middle>\(1)</td>
<td>Shared macro.</td>
<td>The content (any tstring) of the macro can be shared with other calls (with
the same content). This is mainly designed for the macros file, with the aim of
reducing the size of compiled ruleset. Moreover, Shared macros can be self-nested
(while non-shared ones cannot).
</td></tr>
$table_tr
<td>Neg</td>
<td align=middle>\(1)</td>
<td>Logical match negation.</td>
<td>This rule returns match if the sample does not match its parameter, and
vice versa.
In the first case, the rule matches the empty string in the sample.
</td></tr>
$table_tr
<td>Nomatch</td>
<td align=middle>\(0)</td>
<td>This is a synonym of None.</td>
<td>
</td></tr>
$table_tr
<td>None</td>
<td align=middle>\(0)</td>
<td>Matches nothing.</td>
<td>[None:] always returns no match.</td>
</tr>
$table_tr
<td>Not</td>
<td align=middle>\(1)</td>
<td>This is a synonym of Neg.</td>
<td>
</td></tr>
$table_tr
<td>Opick</td>
<td align=middle>\(>= 2)</td>
<td>Matches an ordered subset of given number of parameters.</td>
<td>This rule is as Pick, except that it only matches subsets that
are in the same order as that given in the parameters.
</td></tr>
$table_tr
<td>Out</td>
<td align=middle>\(2)</td>
<td>Match plus output</td>
<td>The first parameter is a variable name, and the second parameter can be
any combination of words, subrules and macros. If match occurs for the
second parameter, the matching text will be put as a value of the variable
and output.
Example. [Out:myvar,[*]] matches any single word, and if the
matched word is "myword" (in the sample), the match output contains a string
"myvar=myword" that can be parsed to know what word the user has entered in
this location.
</td></tr>
$table_tr
<td>Perm</td>
<td align=middle>\(>= 2)</td>
<td>Matches all the parameters in arbitrary order.</td>
<td>[Perm:x,y,z] matches "x y z", "y x z", "z x y" etc.
</td></tr>
$table_tr
<td>Pick</td>
<td align=middle>\(>= 2)</td>
<td>Matches a subset of given number of parameters in any order.</td>
<td>The first parameter must be a positive integer n. The rule matches any
subset of n parameters within the rest, in any order.
Example: [Pick:2,a,b,c,d] matches "a b", "d b", "c a" etc.
[Pick:3,x,y,z] is equivalent to [Perm:x,y,z].
[Pick:1,a,b,c,d] is equivalent to [Alt:a,b,c,d].
Extensions: [Pick:+2,...] matches any subset of at least 2
parameters.
[Pick:-3,...] matches any subset of at most 3 parameters (including
the empty subset).
Known bug: repetition of the same parameter is not recognized.
[Pick:2,a,b,c,d] does not match "a c c".
</td></tr>
$table_tr
<td>Rep</td>
<td align=middle>\(>= 1)</td>
<td>Matches an arbitrary number (at least one) of parameters in any order and
with any repetition.</td>
<td>[Rep:0,1] matches "0 1", "1", "0 1 0 0 1 1 0", etc.
</td></tr>
$table_tr
<td>W</td>
<td align=middle>\(0 or 1)</td>
<td>Matches words in a list.</td>
<td>This rule matches the next word if it appears somewhere in the tester or
if it is a word given in the parameter.
If this rule is put in the last tester line, words in all the tester lines
will count.
$table_tr
<td>Wild</td>
<td align=middle>\(1)</td>
<td>Wildcard word match.</td>
<td>The unique parameter must be composed of words "*", "**", and/or "**n"
where n is a positive number. The first matches any single word, the second
matches 0 or any number of words, and the third matches from 0 to n
arbitrary words. For example,
[Wild:* * **3] matches between 2 to 5 words (inclusive).
</td></tr>
$table_end
<hr><h3>Construction of styles</h3>
A style corresponds to a directory and its contents. Under WIMS, the style
can either be shared among all modules in the public_html/scripts/symtext
directory, or be special to one module, in the module's directory.
The style must contain an index file, named def. It defines the
basic configuration choices of the style. Every line of the file is a
definition under the format name=value.
The def file must contain a definition style_exists=yes,
otherwise the existence of the style will not be recognized. All the rest is
optional.
It may contain a definition of option, that lists option words that
will always be activated for the style.
It can also define general dictionaries using the name
dictionaries. The value must be a list of words, each corresponding
to a dictionary file in the style. The number of general dictionaries is
limited.
For each general dictionary, a variable NAME_unknown can be defined (where
NAME should be replaced by the dictionary name), which tells how a word
should be treated if it is not found in the dictionary (unknown). The value
may be delete (default) which means the unknown word should be
replaced by an empty string; leave which will return the unknown
word unchanged; or anything else. In the last case, the value will be used
to replace the unknown word.
There may also be three dictionary files with reserved names:
suffix, trans and macros. All dictionaries are
line dictionaries, with each line in the format name:definition. Names
must be sorted (using the special program dicsort in the WIMS
package). All of the dictionaries are optional.
Both name and definition may contain space characters. However, except macro
definitions there is no transformation after the dictionary is read, so only
single space characters should be used. The name field should start and end
with non-space characters. Multiple definitions with a same name will give
unpredictable result.
The suffix dictionary is a very special one, that is used to
transform word suffixes before any other transformation. It is easy to
understand except that in the name field, the suffixes are defined in
reverse order.
The trans dictionary is used for word replacements after suffix
transformation. Both dictionaries will be consulted before any string
comparison takes place. For example, if we want to identify nouns under
singular and plural forms, we can first use the suffix dictionary
to transform plural nouns into singular suffix if they obey a general suffix
rule; then for nouns with special plural forms, the trans
dictionary can be used to transform them.
Both the suffix and trans dictionaries must be constructed
to be order 1 stable, that is, if an already transformed string is
resubmitted to the dictionary, no further transformation will take place.
The macros dictionary contains both definitions for positional
macros and macro rules. The former have names starting with the underline
character, while the latter starts with lower case letters.
The definition of a macro is a tstring that will be used to replace the
macro. Macros can be nested, that is, the definition of a macro may contain
calls to other macros, in any order. However, infinite nesting loops will
result in an error.
In order to preserve consistency for positional macros, the definition of
any macro must be composed of exactly one atom.
Macro definitions may contain parameters. For this purpose, the character
@ has a special meaning in a macro definition. When invoked, it
must be followe by an integer. And the character together with the following
integer will be replaced by a macro parameter during macro expansion.
For a rule macro, @1 means the first parameter, @2 means
the second parameter, etc. It is an error if the macro is invoked in a
tstring without giving enough parameters.
For a positional macro, @1 designates the first atom following the
macro, while @-1 designates the first atom preceding the macro, etc.
It is also an error if a positional macro is inserted in a tstring without
enough atoms before or after it as required by its definition.
Care must be taken to the point that a macro parameter may result in several
atoms after expansion. This is not a problem unless the macro definition
contains a positional macro. In case where it is necessary to ensure the
position of parameters, one can enclose the parameter by a pair of brackets,
such as [@1].
A general dictionary has the same syntax as the reserved ones. In this case,
the definition field can be a comma-separated list of items. These
dictionaries are used via the Dic builtin rule, which gives a match
if one of the items in the definition is equal to the value given in the
parameter of the rule.
<hr><h3>The command line program</h3>
The command line program symtext is specially built for WIMS, so that
all the input data are sent through environment variables. It can also be
used as a standalone program, but in this case it is better that a wrapper
script be used to put the input-output into a more *nix flavor.
$table_header
<caption>List of environment parameters</caption>
$table_hdtr<th>Name</th>
<th>Value</th>
<th>Comments</th>
</tr>
$table_tr
<td>wims_exec_parm</td>
<td>The main data input</td>
<td>A multi-line string.
<ul>
<li>Line 1: command followed by options. Valid commands:
<ul>
<li>match check matching.
</li>
<li>debug check matching with debug information.
</li>
</ul>
</li>
<li>Line 2: The sample.</li>
<li>Line 3 and up: Each line is a tester.</li>
</ul>
Lines can also be delimited by the semi-colon. For this reason, semi-colons
must be protected by parentheses in both the sample and the tester.
Options have the same syntax as in the style option definition. With one
more possible definition here: style=[the_name_of_style].
</td></tr>
$table_tr
<td>module_dir</td>
<td>Directory to current module</td>
<td>Automatically defined if called by WIMS. If this variable is undefined,
then w_symtext must give the complete path of the style.
</td></tr>
$table_tr
<td>w_module_language</td>
<td>Language</td>
<td>Only used when called by WIMS. Can be overrun by the "language=" option.
</td></tr>
$table_end
Options have two origins: either from the environment variable
w_symtext_option or from the def file of the style. The two
have the same syntax.
!set option_data=!trim \
alnumly,word,Transform everything non-alphabetic and non-digit into space.\
alphaonly,word,Transform everything non-alphabetic into space.\
deaccent,word,Remove accents from letters before comparison.\
debug,word,Output debug information to stderr.\
language,value,A two-letter language code.\
matchall,word,Match every line of the tester, instead of stopping after the first match.\
nocase,word,Fold both texts to lower case before comparison.\
nocs,word,Replace computer-oriented characters by spaces (_&$#\\@~)\
nomath,word,Replace mathematical operators by spaces (<tt>+-*/=|%<>()_</tt>)\
noparentheses,word,Replace parentheses by spaces (()[]{})\
nopunct,word,Replace puncuation characters by spaces (.,;:?!") except the dot as a decimal point.\
noquote,word,Replace quoting characters by spaces (`'")\
reaccent,word,Allow composition of accented letters using special characters.\
style,value,The style&#44, only valid in the environment parameter.\
$table_header
<caption>List of options</caption>
$table_hdtr
<th>Name</th>
<th>Nature</th>
<th>Meaning</th>
</tr>
!set n=!linecnt $option_data
!for i=1 to $n
!set l=!line $i of $option_data
!distribute item $l into name,nature,meaning
$table_tr
<td>$name</td>
<td>$nature</td>
<td>$meaning
!next i
$table_end
Program output. The output is empty if no match is found.
!set error_data=!nonempty lines \
bad_command,Invalid command in the input.\
bad_dictionary,Non-existing dictionary specified.\
bad_macro,Bad macro name.\
bad_macro_position,Positional macro placed in the tester where pre- or post-parameters cannot be found.\
bad_pickcnt,Invalid first parameter for Pick.\
block_overflow,Too many rules and parameters defined in the tester (before or after macro expansion).\
duplication_in_dictionary,A name is defined twice in the indicated dictionary (in the style).\
file_too_long,File size exceeded limit.\
level_overflow,Too much nesting; probably an internal bug.\
list_overflow,A rule contains too many parameters.\
macro_level_overflow,Too many recursive macro definitions. Usually it is an infinite loop in the macro dictionary.\
name_too_long,Macro or variable name exceeded length limit.\
string_too_long,String length limit exceeded.\
style_not_found,Inexisting style specified.\
syntax_error,Syntax error in a macro or rule.\
tag_overflow,Tester expansion is too complicated.\
too_many_dictionaries,The number of dictionaries declared in the style has exceeded limit.\
unknown_cmd,Unknown matching rule name.\
unmatched_parentheses,Unmatched parentheses or brackets.\
unsorted_dictionary,The indicated dictionary (in the style) is in bad order.\
wrong_parmcnt,A matching rule has a number of parameters that does not meet its definition.\
$table_header
<caption>Error messages</caption>
$table_hdtr
<th>Message</th>
<th>Meaning</th>
</tr>
!set n=!linecnt $error_data
!for i=1 to $n
!set l=!line $i of $error_data
!distribute items $l into msg,mean
$table_tr
<td class="tt">$msg</td>
<td>$mean</td>
</tr>
!next i
$table_end

Subversion Repositories wimsdev

(root)/trunk/wims/public_html/scripts/help/symtext/symtext.phtml – Rev 17348