Default grammar - Revision history

imported>Martins at 22:14, 7 November 2012

2012-11-07T22:14:17Z

← Older revision		Revision as of 22:14, 7 November 2012
Line 81:		Line 81:

	== UNL>NL Default Grammar (NLization) ==		== UNL>NL Default Grammar (NLization) ==
	The NL>UNL Default Grammar is divided into 7 sections		The NL>UNL Default Grammar is divided into 6 sections
	#Pre-processing (prepares the input for the processing)		#Pre-processing (prepares the input for the processing)
	~~#Normalization (standardizes the feature structure)~~
	#Arborization (converts the syntactic network into a syntactic tree)		#Arborization (converts the syntactic network into a syntactic tree)
	#Transformation (converts the deep syntactic structure into the surface syntactic structure)		#Transformation (converts the deep syntactic structure into the surface syntactic structure)
Line 91:		Line 90:

	=== Pre-processing ===		=== Pre-processing ===

	~~=== Normalization ===~~
	~~The normalization module of the UNL>NL Default Grammar is the same as the NL>UNL Default Grammar. It is used to standardize the feature structure and to propagate values from parents to children.~~

	=== Arborization ===		=== Arborization ===

imported>Martins at 22:13, 7 November 2012

2012-11-07T22:13:33Z

← Older revision		Revision as of 22:13, 7 November 2012
Line 6:		Line 6:

	== NL>UNL Default Grammar (UNLization) ==		== NL>UNL Default Grammar (UNLization) ==
	The NL>UNL Default Grammar is divided into 7 sections		The NL>UNL Default Grammar is divided into 6 sections
	#Pre-processing (prepares the input for the processing)		#Pre-processing (prepares the input for the processing)
	~~#Normalization (standardizes the feature structure)~~
	#Parsing (converts the input list structure into a tree structure)		#Parsing (converts the input list structure into a tree structure)
	#Transformation (converts the surface tree struture into the deep tree structure)		#Transformation (converts the surface tree struture into the deep tree structure)
Line 26:		Line 25:
	deletes all blank spaces		deletes all blank spaces
	:("a")(" ")("b") > ("a")("b")		:("a")(" ")("b") > ("a")("b")

	~~=== Normalization ===~~
	~~The normalization section is divided into three modules:~~
	*'''Standardization''', where isolated features are rewritten in the attribute-value format.
	This is used when the feature list of entries are not represented in the dictionary in the attribute-value format, or as a cross-check for the feature assignment operations performed by the grammar itself. An example of standardization rules is:
	~~(CAU,^ASP):=(-CAU,+ASP=CAU);~~
	~~if a node has the feature "CAU" (= causative) but does not have the attribute "ASP" (aspect), then rewrite CAU as ASP=CAU~~
	*'''Propagation''', where the features of top categories are copied to their children.
	This is used to avoid proliferating rules. For instance, every word having the feature SNGT (singulare tantum) is also SNG (singular). This information is not stated in the dictionary, and must be made explicit in the grammar, in order not to simply duplicate all rules dealing with SNG. This generalization movement is performed by rules such as:
	~~(SNGT,^SNG):=(-NUM,-SGNT,+NUM=SNG,+NUM=SNGT);~~
	~~if a node has the feature SNGT (singulare tantum) and does not have the feature SNG (singular), then copy the feature SNG to it~~
	*'''Other normalization rules''', to deal with special cases such as temporary UW's, pronouns and numbers, such as:
	~~(TEMP,^LEX):=(+LEX=N,+POS=PPN); treats all temporary words as proper nouns~~
	temporary UW's, which are absent from the dictionary, do not have any information other than the feature TEMP. In order to manipulate them inside the grammar, we assign them the feature PPN (proper name) (i.e., all temporary words are interpreted as proper names)

	=== Parsing ===		=== Parsing ===

imported>Martins at 22:05, 29 October 2012

2012-10-29T22:05:11Z

← Older revision		Revision as of 22:05, 29 October 2012
Line 96:		Line 96:

	== UNL>NL Default Grammar (NLization) ==		== UNL>NL Default Grammar (NLization) ==
	The NL>UNL Default Grammar is divided into 6 sections		The NL>UNL Default Grammar is divided into 7 sections
	*Pre-processing (prepares the input for the processing)		#Pre-processing (prepares the input for the processing)
	*Normalization (standardizes the feature structure)		#Normalization (standardizes the feature structure)
	*Arborization (converts the syntactic network into a syntactic tree)		#Arborization (converts the syntactic network into a syntactic tree)
	*Transformation (converts the deep syntactic structure into the surface syntactic structure)		#Transformation (converts the deep syntactic structure into the surface syntactic structure)
	*Linearization (converts the syntactic structure into a list structure)		#Linearization (converts the syntactic structure into a list structure)
	*Morphological generation (inflects the words that need to be inflected)		#Morphological generation (inflects the words that need to be inflected)
	*Post-processing (adjusts the final output)		#Post-processing (adjusts the final output)

	=== Pre-processing ===		=== Pre-processing ===

imported>Martins at 22:06, 26 October 2012

2012-10-26T22:06:57Z

← Older revision		Revision as of 22:06, 26 October 2012
Line 141:		Line 141:
	:if the word belongs to the paradigm M2, then copy to this word the rule FLX(SNG:=0>""; PLR:=0>"s";), i.e., in order to make the singular, add nothing, and in order to make the plural, add "s" to the end of the word.		:if the word belongs to the paradigm M2, then copy to this word the rule FLX(SNG:=0>""; PLR:=0>"s";), i.e., in order to make the singular, add nothing, and in order to make the plural, add "s" to the end of the word.
	=== Post-processing ===		=== Post-processing ===
	The post-processing module is used to adjust the list to the standards of natural language output. It		The post-processing module is used to adjust the list to the standards of natural language output. It contains rules to eliminate remaining scopes, to add blank spaces, to capitalize the first word in a sentence, etc.
			((%x)(%y)(%z)):=(%x)(%y)(%z);
			((%x)(%y)):=(%x)(%y);
			:removes remaining scopes
			(%x,>BLK)(%y,^BLK,^STAIL):=(%x,->BLK)(" ",+BLK)(%y);
			:inserts blank spaces after the words requiring a blank space (the feature >BLK was inserted during the linearization step)
			(%x,>COMMA):=(%x,->COMMA)(",",PUT=COMMA);
			:inserts comma after the words requiring comma (the feature >COMMA was inserted in previous steps)

imported>Martins at 21:57, 26 October 2012

2012-10-26T21:57:51Z

← Older revision		Revision as of 21:57, 26 October 2012
Line 102:		Line 102:
	*Transformation (converts the deep syntactic structure into the surface syntactic structure)		*Transformation (converts the deep syntactic structure into the surface syntactic structure)
	*Linearization (converts the syntactic structure into a list structure)		*Linearization (converts the syntactic structure into a list structure)
			*Morphological generation (inflects the words that need to be inflected)
	*Post-processing (adjusts the final output)		*Post-processing (adjusts the final output)

Line 122:		Line 123:

	=== Transformation ===		=== Transformation ===
			[[File:Transformation2.png\|thumb\|left\|200px]]
			In the UNL>NL Default Grammar, the transformation module transforms the deep syntactic structure derived from the arborization into a surface structure. If in the UNLization process, the specifier of IP was moved to the position of specifier of VP, now it goes back to its original position, in order to be generated in the right position (if not, the verb would be generated after the auxiliary, in case of English, for instance).
			<br style="clear: both" />

	=== Linearization ===		=== Linearization ===
			[[File:Linearization.png\|thumb\|left\|200px]]
			The linearization module converts a tree structure into a list structure. It is formed by rules of the following type:
			VP(%x;%y):=(%y,+>BLK)(%x);
			:if the there is a VP between %x and %y, remove this relation and writes %y in front of %x.
			<br style="clear: both" />

			=== Morphological generation ===
			The morphological generation module comprises one single rule:
			(%x,^inflected,FLX):=(%x,!FLX,+inflected);
			This rule triggers the rules extracted from the inflectional paradigms (grammar) or from the [[Dictionary_Specs#Inflection_rules_inside_dictionary_entries.2A\|inflectional rules (dictionary)]. This is done through the operand "!" which, in this case, applies all the rules comprised inside the field FLX. For instance, the English grammar brings the following rule, which is copied to the entry during the NLization process:
			(%x,M2):=(%x,-M2,+FLX(SNG:=0>""; PLR:=0>"s";));
			:if the word belongs to the paradigm M2, then copy to this word the rule FLX(SNG:=0>""; PLR:=0>"s";), i.e., in order to make the singular, add nothing, and in order to make the plural, add "s" to the end of the word.
	=== Post-processing ===		=== Post-processing ===
			The post-processing module is used to adjust the list to the standards of natural language output. It

imported>Martins at 21:38, 26 October 2012

2012-10-26T21:38:33Z

← Older revision		Revision as of 21:38, 26 October 2012
Line 110:		Line 110:

	=== Arborization ===		=== Arborization ===
			[[File:Arborization.png\|thumb\|left\|200px]]
			The arborization module converts a syntactic network into a syntactic tree. It is the same as the dearborization module, but in the opposite direction. It converts the network into a tree because trees are much more suitable to linearization than networks. Arborization rules are of the following type:
			VB(%x;%y)VS(%x;%z):=VP(VB(%x;%y);%z);
			VB(%x;%y)VA(%x;%z):=VB(VB(%x;%y);%z);
			VB(%x;%y)VC(%x;%z):=VB(VB(%x;%y);%z);
			VC(%x;%y):=VB(%x;%y);
			VA(%x;%y):=VB(%x;%y);
			VS(%x;%y):=VP(%x;%y);
			:if there is a VB and a VS sharing the same head, create a VP between the VB and the second argument of VS.
			<br style="clear: both" />

	=== Transformation ===		=== Transformation ===

imported>Martins at 21:24, 26 October 2012

2012-10-26T21:24:25Z

← Older revision		Revision as of 21:24, 26 October 2012
Line 107:		Line 107:

	=== Normalization ===		=== Normalization ===
			The normalization module of the UNL>NL Default Grammar is the same as the NL>UNL Default Grammar. It is used to standardize the feature structure and to propagate values from parents to children.

	=== Arborization ===		=== Arborization ===

imported>Martins at 21:23, 26 October 2012

2012-10-26T21:23:09Z

← Older revision		Revision as of 21:23, 26 October 2012
Line 91:		Line 91:

	=== Post-processing ===		=== Post-processing ===
			The post-processing module simply adjusts the resulting graph to the UNL standards, in order to eliminate contradictions and redundancies. For instance, the rule
			(@pl,{@multal\|@paucal\|@all\|@both}):=(-@pl); eliminates the redundancy of @pl
			is used to eliminate the redundancy of @pl and @multal. As @multal conveys already the idea of plural, @multal.@pl is redundant and should be fixed.

	== UNL>NL Default Grammar (NLization) ==		== UNL>NL Default Grammar (NLization) ==

imported>Martins at 21:21, 26 October 2012

2012-10-26T21:21:30Z

← Older revision		Revision as of 21:21, 26 October 2012
Line 87:		Line 87:
	The interpretation module simply maps the syntactic network into a semantic network by analyzing the arguments of each relation. It is formed by rules of the type:		The interpretation module simply maps the syntactic network into a semantic network by analyzing the arguments of each relation. It is formed by rules of the type:
	/[ACDIJNPV][ACS]/(%x;%y,tim):=tim(%x;%y);		/[ACDIJNPV][ACS]/(%x;%y,tim):=tim(%x;%y);
	:if there is any relation (AA,AC,AS,CA,CC,CS,...) between two nodes %x and %y, and %y has the feature "tim", then rewrites this (syntactic) relation as a semantic relation of the type "tim" between these two nodes.		:if there is any syntactic relation (AA,AC,AS,CA,CC,CS,...) between two nodes %x and %y, and %y has the feature "tim", then rewrites this (syntactic) relation as a semantic relation of the type "tim" between these two nodes.
	<br style="clear: both" />		<br style="clear: both" />

imported>Martins at 21:20, 26 October 2012

2012-10-26T21:20:55Z

← Older revision		Revision as of 21:20, 26 October 2012
Line 85:		Line 85:
	=== Interpretation ===		=== Interpretation ===
	[[File:Interpretation.png\|thumb\|left\|200px]]		[[File:Interpretation.png\|thumb\|left\|200px]]
			The interpretation module simply maps the syntactic network into a semantic network by analyzing the arguments of each relation. It is formed by rules of the type:
			/[ACDIJNPV][ACS]/(%x;%y,tim):=tim(%x;%y);
			:if there is any relation (AA,AC,AS,CA,CC,CS,...) between two nodes %x and %y, and %y has the feature "tim", then rewrites this (syntactic) relation as a semantic relation of the type "tim" between these two nodes.
	<br style="clear: both" />		<br style="clear: both" />

	=== Post-processing ===		=== Post-processing ===