;;; Hey, emacs(1), this is -*- Mode: TDL; Coding: utf-8; -*- got it? ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; ;;; quantifiers ;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; all_q := quantifier_mtr & [ INPUT.RELS < [ PRED "all_q_rel" ] >, OUTPUT.RELS < [ PRED _all_q_rel ] > ]. annen_q := quantifier_adjective_mtr & [ INPUT.RELS < [ PRED "annen_q_rel" ] >, OUTPUT.RELS < [ PRED udef_q_rel ], [ PRED "_other_a_1_rel" ] > ]. free_relative_1_q := quantifier_mtr & [ INPUT.RELS < [ PRED "arbitrær-hvilken_q_rel" ] >, OUTPUT.RELS < [ PRED free_relative_q_rel ] > ]. free_relative_2_q := quantifier_mtr & [ INPUT.RELS < [ PRED "free_relative_q_rel" ] >, OUTPUT.RELS < [ PRED free_relative_q_rel ] > ]. bare_div_q := quantifier_mtr & [ INPUT.RELS < [ PRED "bare_div_q_rel" ] >, OUTPUT.RELS < [ PRED udef_q_rel ] > ]. ;;; ;;; for Norwegian bare singulars, we used to always output both an indefinite ;;; and a covert quantifier (`_a_q' and `udef_q'), which creates a fair amount ;;; of downstream ambiguity and, ultimately, sets of outputs that are doomed ;;; to failure in generation. now that we have access to the TL countability ;;; distinction (from the ERG SEM-I), defer resolution of bare singulars until ;;; the final transfer phase. still change the predicate to a type here, such ;;; that subsequent rules can recognize quantifiers from the type hierarchy. ;;; bare_sg_q := quantifier_mtr & [ INPUT.RELS < [ PRED "bare_sg_q_rel" ] >, OUTPUT.RELS < [ PRED bare_sg_q_rel ] > ]. #| bare_sg_indefinite_q := quantifier_omtr & [ INPUT.RELS < [ PRED "bare_sg_q_rel" ] >, OUTPUT.RELS < [ PRED _a_q_rel ] > ]. bare_sg_null_q := quantifier_mtr & [ INPUT.RELS < [ PRED "bare_sg_q_rel" ] >, OUTPUT.RELS < [ PRED udef_q_rel ] > ]. |# begge_q := quantifier_mtr & [ INPUT.RELS < [ PRED "begge_q_rel" ] >, OUTPUT.RELS < [ PRED _both_q_rel ] > ]. ;;; ;;; _fix_me_ ;;; right now, we have created a fine mess here, using different schemes on the ;;; two sides: NorGram `def_q' used to be the incorporated definite determiner, ;;; and `def_rel' used to be a construction-specific quantifier (in partitives ;;; and possessives, and what not). then, jtl asked helge to rename `def_rel' ;;; to `def_q_rel', and dan eliminated the explicit vs. implicit distinction on ;;; definites. thus, it seems, right now, we risk overgeneration where `def_q' ;;; transfers into the ERG `def_q', which subsumes various over definites (the, ;;; that, those, both, et al.) and construction-specific definites. the plan ;;; is to try and make deictic, proximal, and such properties explicit maybe, ;;; e.g. as additional index properties, and reduce the number of quantifiers ;;; in the hierarchy. (2-sep-05; oe) ;;; --- for right now, we potentially overgenerate, as we can not tell whether ;;; a `def_q' was an incorporated determiner (which should become `_the_q') or ;;; not. `def_q' subsumes `def_explicit_q' in the ERG, hence no point creating ;;; both outputs. ;;; def_q := quantifier_mtr & [ INPUT.RELS < [ PRED "def_q_rel" ] >, OUTPUT.RELS < [ PRED def_q_rel ] > ]. def_explicit_q := quantifier_mtr & [ INPUT.RELS < [ PRED "def_explicit_q_rel" ] >, OUTPUT.RELS < [ PRED def_q_rel ] > ]. ;;; ;;; this one is for `de fleste' -> `most'. (2-jun-06; jtl) ;;; def+superl_q := quantifier_mtr & [ CONTEXT.RELS < [ LBL #h1, PRED "_mange_a_rel", ARG0 #e2, ARG1 #x3 ], [ LBL #h1, PRED "superl_pos_rel", ARG1 #e4] >, INPUT.RELS < [ PRED "def_q_rel", ARG0 #x3 ] >, OUTPUT.RELS < [ PRED udef_q_rel ] > ]. den_dem_that_q := quantifier_mtr & [ INPUT.RELS < [ PRED "den_dem_rel", ARG0 [ NUM sg ] ] >, OUTPUT.RELS < [ PRED _that_q_dem_rel ] > ]. den_dem_those_q := quantifier_mtr & [ INPUT.RELS < [ PRED "den_dem_rel", ARG0 [ NUM pl ] ] >, OUTPUT.RELS < [ PRED _those_q_dem_rel ] > ]. denne_dem_this_q := quantifier_mtr & [ INPUT.RELS < [ PRED "denne_dem_rel", ARG0 [ NUM sg ] ] >, OUTPUT.RELS < [ PRED _this_q_dem_rel ] > ]. denne_dem_these_q := quantifier_mtr & [ INPUT.RELS < [ PRED "denne_dem_rel", ARG0 [ NUM pl ] ] >, OUTPUT.RELS < [ PRED _these_q_dem_rel ] > ]. ;;; ;;; This has to come before 'en_q'; Should it be optional? ;;; With the current rules that would allow "a that deep valley" ;;; (11-may-06; jtl) en-såpass_such-a_q := quantifier_quantifier+deg_spec_mtr & [ INPUT.RELS < [ PRED "en_q_rel" ] , [ PRED "_såpass_x_deg_rel" ]>, OUTPUT.RELS < [ PRED _such+a_q_rel ] > ]. en_q := quantifier_mtr & [ INPUT.RELS < [ PRED "en_q_rel" ] >, OUTPUT.RELS < [ PRED _a_q_rel ] > ]. en-del_a_little_q := quantifier_mtr & [ INPUT.RELS < [ PRED "en-del_q_rel", ARG0 [ NUM sg, DIV + ] ] >, OUTPUT.RELS < [ PRED _a+little_q_rel ] > ]. en-del_a+few_a := quantifier_adjective_mtr & [ INPUT.RELS < [ PRED "en-del_q_rel" ] >, OUTPUT.RELS < [ PRED udef_q_rel ], [ PRED "_a+few_a_1_rel" ] > ]. ;;; ;;; _fix_me_ ;;; i added the following two hastily, for completeness, right before the Knut ;;; integration deadline. neither am i sure the translations are good, nor do ;;; i know that i buy the NorGram analysis. (24-sep-05; oe) ;;; en-mengde_q := quantifier_adjective_mtr & [ INPUT.RELS < [ PRED "en-mengde_q_rel" ] >, OUTPUT.RELS < [ PRED udef_q_rel ], [ PRED much-many_a_rel ] > ]. en-rekke_q := quantifier_adjective_mtr & [ INPUT.RELS < [ PRED "en-rekke_q_rel" ] >, OUTPUT.RELS < [ PRED udef_q_rel ], [ PRED much-many_a_rel ] > ]. en+og+annen_q := quantifier_adjective_mtr & [ INPUT.RELS < [ PRED "en+og+annen_q_rel" ] >, OUTPUT.RELS < [ PRED _a_q_rel ], [ PRED "_occasional_a_1_rel" ] > ]. ;;; ;;; _fix_me_ ;;; related to the discussion of `hver' (see below), maybe include more. ;;; (12-nov-04; oe & jtl) enhver_every_q := quantifier_omtr & [ INPUT.RELS < [ PRED "enhver_q_rel" ] >, OUTPUT.RELS < [ PRED _every_q_rel ] > ]. enhver_each_q := quantifier_mtr & [ INPUT.RELS < [ PRED "enhver_q_rel" ] >, OUTPUT.RELS < [ PRED _each_q_rel ] > ]. ;;; ;;; _fix_me_ ;;; check the following with a native speaker. (19-nov-04; oe) ;;; enkelt_q := quantifier_mtr & [ INPUT.RELS < [ PRED "enkelt_q_rel" ] >, OUTPUT.RELS < [ PRED _some_q_rel ] > ]. etpar_q := quantifier_adjective_mtr & [ INPUT.RELS < [ PRED "etpar_q_rel" ] >, OUTPUT.RELS < [ PRED udef_q_rel ], [ PRED "_a+couple_a_1_rel" ] > ]. halve_q := quantifier_mtr & [ INPUT.RELS < [ PRED "halve_q_rel" ] >, OUTPUT.RELS < [ PRED _half_q_rel ] > ]. hele_q := quantifier_mtr & [ INPUT.RELS < [ PRED "hele_q_rel" ] >, OUTPUT.RELS < [ PRED _all_q_rel ] > ]. ;;; cf. comments on 'tusenvis' (10-oct-06; jtl) hundrevis_q := monotonic_mtr & [ CONTEXT.HCONS < qeq & [ HARG #h2, LARG #h6 ] >, INPUT.RELS < [ LBL #h1, PRED "hundrevis-av_q_rel", ARG0 #x1, RSTR #h2, BODY #h3 ] >, OUTPUT.RELS < [ LBL #h1, PRED udef_q_rel, ARG0 #x1, RSTR #h2, BODY #h3 ], [ LBL #h4, PRED card_rel, ARG1 #x1, CARG "several" ], [ LBL #h5, PRED card_rel, ARG1 #x1, CARG "100" ], [ LBL #h6, PRED times_rel, ARG1 #x1, ARG2 #h4, ARG3 #h5 ] > ]. ;;; ;;; _fix_me_ ;;; maybe we should consider `_each_q' here too, since `every' and each are not ;;; quite in identical distribution (`each of them' vs. `*every of them') and ;;; differ in terms of scope preferences. (9-nov-04; oe & jtl) ;;; --- and, indeed we do, for now. ;;; hver_each_q := quantifier_omtr & [ INPUT.RELS < [ PRED "hver_q_rel" ] >, OUTPUT.RELS < [ PRED _each_q_rel ] > ]. ;;; ;;; _fix_me_ ;;; jan tore, actually, would like to talk me into dropping this one, since we ;;; fail to think of any context that would strongly prefer `every'. talk to ;;; dan or someone else to check whether there are such contrasts in English. ;;; (10-nov-04; oe) ;;; --- although, looking it up in the OMC, we now both agree that both outputs ;;; are probably useful. having come this far, what about translating `hver' ;;; or `enhver' as `any' then? (10-nov-04; oe & jtl) ;;; hver_every_q := quantifier_mtr & [ INPUT.RELS < [ PRED "hver_q_rel" ] >, OUTPUT.RELS < [ PRED _every_q_rel ] > ]. ;;; ;;; _fix_me_ ;;; the ERG makes a distinction between `which_q' in decomposed WH pronouns, ;;; e.g. `who' and `what', vs. `_which_q' for `which chair'. possibly this is ;;; a grammar idiosyncrasy, and we should fix it up towards the end, based on ;;; the type of entity bound by the quantifier? (10-nov-04; oe) ;;; hvilken_q := quantifier_mtr & [ INPUT.RELS < [ PRED "hvilken_q_rel" ] >, OUTPUT.RELS < [ PRED which_q_rel ] > ]. hvilken-som-helst_dem_q := quantifier_mtr & [ INPUT.RELS < [ PRED "hvilken-som-helst_dem_rel" ] >, OUTPUT.RELS < [ PRED _any_q_rel ] > ]. ingen_q := quantifier_mtr & [ INPUT.RELS < [ PRED "ingen_q_rel" ] >, OUTPUT.RELS < [ PRED _no_q_rel ] > ]. ;;; ;;; in fact, this is a problem we have encountered a few times: splitting one ;;; variable into two, i.e. creating a new partitive, would require that there ;;; is a way of (at least) re-attaching all intersective modifier to the (new) ;;; embedded variable, i.e. `kilometervis med fine daler' --> `kilometers of ;;; fine valleys'. (1-dec-04; oe) ;;; --- using the downstream variable equate mechanism (in the `snug' phase), ;;; we might be able to provide a very reasonable approximation, if nothing ;;; else. it is hard just now to foresee all possible forms the downstream NP ;;; might take ... finally, note that we need to protect the `_of_p' PP, which ;;; would look like an intersective modifier on the former index otherwise, and ;;; end up being re-attached inside the downstairs NP. (18-dec-06; oe) kilometervis-med_q := monotonic_mtr & [ CONTEXT.HCONS < qeq & [ HARG #h1, LARG #h2 ] >, INPUT.RELS < [ LBL #h0, PRED "kilometervis-med_q_rel", ARG0 #x0, RSTR #h1, BODY #h3 ], [ LBL #h2, PRED #pred, ARG0 #x0 & x ] >, OUTPUT [ RELS < [ LBL #h0, PRED udef_q_rel, ARG0 #x0 & [ NUM pl ], RSTR #h1, BODY #h3 ], [ LBL #h2, PRED "_kilometer_n_1_rel", ARG0 #x0 ], [ LBL #h2, PRED _of_p_rel, ARG0 #e0 & e_untensed, ARG1 #x0, ARG2 #x1 ], [ PRED udef_q_rel, ARG0 #x1, RSTR #h4 ], [ LBL #h5, PRED #pred, ARG0 #x1 & [ PERS 3, NUM pl, GRIND - ] ], [ PRED intersective_equate, ARG0 #x1, ARG1 #x0 ], [ PRED intersective_equate, ARG0 #h5, ARG1 #h2 ], [ PRED equate_mark, ARG0 #e0 ] >, HCONS < qeq & [ HARG #h4, LARG #h5 ] > ], FLAGS.EQUAL < #x0 > ]. litt_q := quantifier_mtr & [ INPUT.RELS < [ PRED "litt_q_rel" ] >, OUTPUT.RELS < [ PRED _a+little_q_rel ] > ]. massevis-av_q := quantifier_adjective_mtr & [ INPUT.RELS < [ PRED "massevis-av_q_rel" ] >, OUTPUT.RELS < [ PRED udef_q_rel ], [ PRED much-many_a_rel ] > ]. mesteparten_q := monotonic_mtr & [ CONTEXT.HCONS < qeq & [ HARG #h2, LARG #h4 ] >, INPUT.RELS < [ PRED "mesteparten_q_rel", LBL #h0, ARG0 #x1, RSTR #h2, BODY #h3 ] >, OUTPUT.RELS < [ PRED udef_q_rel, LBL #h0, ARG0 #x1, RSTR #h2, BODY #h3 ], [ PRED superl_rel, LBL #h4, ARG0 e_untensed, ARG1 #e5 ], [ PRED much-many_a_rel, LBL #h4, ARG0 #e5 & e_untensed, ARG1 #x1 ] > ]. nest_q := quantifier_adjective_mtr & [ INPUT.RELS < [ PRED "neste_q_rel" ] >, OUTPUT.RELS < [ PRED _the_q_rel ], [ PRED "_next_a_1_rel" ] > ]. noen-få_q := quantifier_adjective_mtr & [ INPUT.RELS < [ PRED "noen-få_q_rel" ] >, OUTPUT.RELS < [ PRED udef_q_rel ], [ PRED "_a+few_a_1_rel" ] > ]. noen_any_q := quantifier_omtr & [ INPUT.RELS < [ PRED "noen_q_rel" ] >, OUTPUT.RELS < [ PRED _any_q_rel ] > ]. noen_some_q := quantifier_mtr & [ INPUT.RELS < [ PRED "noen_q_rel" ] >, OUTPUT.RELS < [ PRED _some_q_rel ] > ]. noen+hundre_q := monotonic_mtr & [ CONTEXT.HCONS < qeq & [ HARG #h2, LARG #h6 ] >, INPUT.RELS < [ LBL #h1, PRED "noen+hundre_q_rel", ARG0 #x1, RSTR #h2, BODY #h3 ] >, OUTPUT.RELS < [ LBL #h1, PRED udef_q_rel, ARG0 #x1, RSTR #h2, BODY #h3 ], [ LBL #h4, PRED card_rel, ARG1 #x1, CARG "a+few" ], [ LBL #h5, PRED card_rel, ARG1 #x1, CARG "100" ], [ LBL #h6, PRED times_rel, ARG1 #x1, ARG2 #h4, ARG3 #h5 ] > ]. noen+tusen_q := monotonic_mtr & [ CONTEXT.HCONS < qeq & [ HARG #h2, LARG #h6 ] >, INPUT.RELS < [ LBL #h1, PRED "noen+tusen_q_rel", ARG0 #x1, RSTR #h2, BODY #h3 ] >, OUTPUT.RELS < [ LBL #h1, PRED udef_q_rel, ARG0 #x1, RSTR #h2, BODY #h3 ], [ LBL #h4, PRED card_rel, ARG1 #x1, CARG "a+few" ], [ LBL #h5, PRED card_rel, ARG1 #x1, CARG "1000" ], [ LBL #h6, PRED times_rel, ARG1 #x1, ARG2 #h4, ARG3 #h5 ] > ]. nok_enough_q := quantifier_mtr & [ INPUT.RELS < [ PRED "nok_q_rel" ] >, OUTPUT.RELS < [ PRED _enough_q_rel ] > ]. number_q := quantifier_mtr & [ INPUT.RELS < [ PRED "number_q_rel" ] >, OUTPUT.RELS < [ PRED number_q_rel ] > ]. pronoun_q := quantifier_mtr & [ INPUT.RELS < [ PRED "pronoun_q_rel" ] >, OUTPUT.RELS < [ PRED pronoun_q_rel ] > ]. proper_q := quantifier_mtr & [ INPUT.RELS < [ PRED "proper_q_rel" ] >, OUTPUT.RELS < [ PRED proper_q_rel ] > ]. quant_q := quantifier_mtr & [ INPUT.RELS < [ PRED "quant_rel" ] >, OUTPUT.RELS < [ PRED quant_rel ] > ]. samme_q := quantifier_adjective_mtr & [ INPUT.RELS < [ PRED "samme_q_rel" ] >, OUTPUT.RELS < [ PRED _the_q_rel ], [ PRED "_same_a_as_rel" ] > ]. samtlige_q := quantifier_mtr & [ INPUT.RELS < [ PRED "samtlige_q_rel" ] >, OUTPUT.RELS < [ PRED _all_q_rel ] > ]. ;;; ;;; `Selve hunden' can't mean `the same dog', but it can mean `the very dog'. ;;; (21-nov-05; jtl) ;;; _fix_me_ ;;; additionally, what about `the dog itself'? (15-sep-06; oe) ;;; selve_q := quantifier_adjective_mtr & [ INPUT.RELS < [ PRED "selve_q_rel" ] >, OUTPUT.RELS < [ PRED _the_q_rel ], [ PRED "_very_a_1_rel" ] > ]. some_q := quantifier_mtr & [ INPUT.RELS < [ PRED "some_q_rel" ] >, OUTPUT.RELS < [ PRED _some_q_rel ] > ]. some_indiv_q := quantifier_mtr & [ INPUT.RELS < [ PRED "some_q_indiv_rel" ] >, OUTPUT.RELS < [ PRED _some_q_indiv_rel ] > ]. ;;; ;;; _fix_me_ ;;; analyzing `tusenvis av forskere' as a non-partitive quantifier seems like a ;;; pragmatic short cut, maybe? on the other hand, the ERG deploys a peculiar ;;; nominal use of `card' for the equivalent construction, i.e. making its ARG0 ;;; be a full referential index. investigate further! (1-dec-04; oe) ;;; ;;; --- in fact, this is a problem we have failed to solve earlier: splitting a ;;; variable into two, i.e. creating a new partitive, would require that there ;;; is a way of (at least) re-attaching all intersective modifiers to the (new) ;;; embedded variable, i.e. `tusenvis av trøtte forskere' --> `thousands of ;;; tired researchers', assuming the `top' INDEX is preserved so that we need ;;; not worry about that variable in even larger contexts ... (1-dec-04; oe) ;;; #| tusenvis-av_q := monotonic_mtr & [ INPUT.RELS < [ PRED "tusenvis-av_q_rel", LBL #h0, ARG0 #x0, RSTR #h1, BODY #h2 ] >, OUTPUT [ RELS < [ PRED udef_q_rel, LBL #h0, ARG0 #x0, RSTR #h1, BODY #h2 ], [ PRED card_rel, LBL #h4, ARG0 #x0, ARG1 #x1, CARG "1000" ], [ PRED _of_p_sel_rel, LBL #h4, ARG0 e_untensed, ARG2 #x1 ], [ PRED udef_q_rel, ARG0 #x0, RSTR #h1, BODY #h2 ] >, HCONS < qeq & [ HARG #h3, LARG #h4 ] > ] ]. |# ;;; ;;; This is a simplified solution: the translation is ``nearly right'', and the ;;; rule is so much easier to write :). cf `hundrevis'. (10-oct-06; jtl) ;;; tusenvis_q := monotonic_mtr & [ CONTEXT.HCONS < qeq & [ HARG #h2, LARG #h6 ] >, INPUT.RELS < [ LBL #h1, PRED "tusenvis-av_q_rel", ARG0 #x1, RSTR #h2, BODY #h3 ] >, OUTPUT.RELS < [ LBL #h1, PRED udef_q_rel, ARG0 #x1, RSTR #h2, BODY #h3 ], [ LBL #h4, PRED card_rel, ARG1 #x1, CARG "several" ], [ LBL #h5, PRED card_rel, ARG1 #x1, CARG "1000" ], [ LBL #h6, PRED times_rel, ARG1 #x1, ARG2 #h4, ARG3 #h5 ] > ]. ;;; ;;; `flest' -> `the most'. (2-jun-06; jtl) ;;; udef+superl_pos_q := quantifier_mtr & [ CONTEXT.RELS < [ LBL #h1, PRED "_mange_a_rel", ARG0 #e2, ARG1 #x3 ], [ LBL #h1, PRED "superl_pos_rel", ARG1 #e4] >, INPUT.RELS < [ PRED "udef_q_rel", ARG0 #x3 ] >, OUTPUT.RELS < [ PRED def_q_rel ] > ]. udef_q := quantifier_mtr & [ INPUT.RELS < [ PRED "udef_q_rel" ] >, OUTPUT.RELS < [ PRED udef_q_rel ] > ]. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; ;;; simple arithmetic ;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; plus_arit := arit_mtr & [ INPUT.RELS < [ PRED "plus_rel" ] >, OUTPUT.RELS < [ PRED plus_rel ] > ]. times_arit := arit_mtr & [ INPUT.RELS < [ PRED "times_rel" ] >, OUTPUT.RELS < [ PRED times_rel ] > ]. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; ;;; other meta-level (construction-specific) predicates ;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; abstr_deg := monotonic_mtr & [ INPUT.RELS < [ PRED "abstr_deg_rel", LBL #h0, ARG0 #x2, ARG1 #i3 ] >, OUTPUT.RELS < [ PRED abstr_deg_rel, LBL #h0, ARG0 #x2, ARG1 #i3 ] > ]. colon_copula_1 := monotonic_mtr & [ CONTEXT.RELS < [ LBL #h5, ARG0 #x2 ] >, INPUT.RELS < [ PRED "colon_copula_rel", LBL #h0, ARG0 #e1, ARG1 #x2 & x, ARG2 #i3 ] >, FILTER [ RELS < [ ARG0 #x2, RSTR #h6 & h ] >, HCONS < qeq & [ HARG #h6, LARG #h5 ] > ], OUTPUT [ RELS < [ PRED _colon_v_id_rel, LBL #h0, ARG0 #e1, ARG1 #x2, ARG2 #i3 ], [ PRED udef_q_rel, ARG0 #x2, RSTR #h4 ] >, HCONS < qeq & [ HARG #h4, LARG #h5 ] > ], FLAGS.EQUAL < #x2 > ]. colon_copula_2 := monotonic_mtr & [ CONTEXT.RELS < [ ARG0 #x2 ] >, INPUT.RELS < [ PRED "colon_copula_rel", LBL #h0, ARG0 #e1, ARG1 #x2 & x, ARG2 #i3 ] >, OUTPUT.RELS < [ PRED _colon_v_id_rel, LBL #h0, ARG0 #e1, ARG1 #x2, ARG2 #i3 ] >, FLAGS.EQUAL < #x2 > ]. comp_equ := comparative_mtr & [ INPUT.RELS < [ PRED "comp_equ_rel" ] >, OUTPUT.RELS < [ PRED comp_equal_rel ] > ]. comp_pos := comparative_mtr & [ INPUT.RELS < [ PRED "comp_pos_rel" ] >, OUTPUT.RELS < [ PRED comp_rel ] > ]. comp_neg := comparative_mtr & [ INPUT.RELS < [ PRED "comp_neg_rel" ] >, OUTPUT.RELS < [ PRED comp_less_rel ] > ]. comp_så := comparative_mtr & [ INPUT.RELS < [ PRED "comp_så_rel" ] >, OUTPUT.RELS < [ PRED comp_so_rel ] > ]. compound_name := monotonic_mtr & [ INPUT.RELS < [ PRED "compound_name_rel" ] >, OUTPUT.RELS < +copy+ & [ PRED compound_name_rel, ARG0 e_untensed ] > ]. disc-focus := monotonic_mtr & [ INPUT.RELS < [ PRED "disc-focus_rel", LBL #h0, ARG0 #e1, ARG1 #x2, ARG2 #h3 ] >, OUTPUT.RELS < [ PRED _be_v_itcleft_rel, LBL #h0, ARG0 #e1, ARG1 #x2, ARG2 #h3 ] > ]. ellipsis := comparative_mtr & [ INPUT.RELS < [ PRED "ellipsis_rel" ] >, OUTPUT.RELS < [ PRED ellipsis_rel ] > ]. ;;; ;;; _fix_me_ ;;; the ERG has `generic_nom' and `generic_nonpro' as siblings, where we seem ;;; to hit some NorGram inputs that should come out one way, others the other ;;; way. work out what the distinction is, and then remedy. (29-aug-04; oe) ;;; generic-nom := monotonic_mtr & [ INPUT.RELS < [ PRED "generic-nom_rel" ] >, OUTPUT.RELS < +copy+ & [ PRED generic_entity_rel ] > ]. ;;; ;;; _fix_me_ ;;; The ERG derives this ``one'' from the cardinal adjective (since we also ;;; want ``the three that ...''), so also need a card_rel. (14-jul-06; dpf) ;;; generic_nonpro_sg := monotonic_mtr & [ INPUT.RELS < [ PRED "generic_nonpro_rel", LBL #h1, ARG0 #x2 & [ NUM sg ] ] >, FILTER.RELS < [ PRED card_rel, LBL #h1, ARG1 #x2, CARG "1" ] >, OUTPUT.RELS < +copy+ & [ PRED generic_entity_rel ], [ PRED card_rel, LBL #h1, ARG1 #x2, CARG "1" ] > ]. generic_nonpro_pl := monotonic_mtr & [ INPUT.RELS < [ PRED "generic_nonpro_rel", LBL #h1, ARG0 #x2 & [ NUM pl ] ] >, FILTER.RELS < [ PRED card_rel, LBL #h1, ARG1 #x2, CARG "2+" ] >, OUTPUT.RELS < +copy+ & [ PRED generic_entity_rel ], [ PRED card_rel, LBL #h1, ARG1 #x2, CARG "2+" ] > ]. ;;; ;;; _fix_me_ ;;; why the `m-or-f' here? (25-apr-05; dan & oe) ;;; generic_pron := noun_mtr & [ INPUT.RELS < [ PRED "generic_pron_rel" ] >, OUTPUT.RELS < [ PRED pron_rel, ARG0 [ GEND m-or-f ] ] > ]. identical := monotonic_mtr & [ INPUT.RELS < [ PRED "identical_rel" ] >, OUTPUT.RELS < +copy+ & [ PRED identity_rel ] > ]. measure := monotonic_mtr & [ INPUT.RELS < [ PRED "measure_rel", LBL #h0, ARG1 #e1, ARG2 #x2 ] >, OUTPUT.RELS < [ PRED measure_rel, LBL #h0, ARG1 #e1, ARG2 #x2 ] > ]. measure_of := monotonic_mtr & [ INPUT.RELS < [ PRED "measure_of_rel", LBL #h0, ARG1 #e1, ARG2 #x2 ] >, OUTPUT.RELS < [ PRED measure_rel, LBL #h0, ARG1 #e1, ARG2 #x2 ] > ]. nominalize := monotonic_mtr & [ INPUT.RELS < [ PRED "nominalize_rel" ] >, OUTPUT.RELS < +copy+ & [ PRED nominalization_rel ] > ]. numbered_hour := monotonic_mtr & [ INPUT.RELS < [ PRED "numbered_hour_rel" ] >, OUTPUT.RELS < +copy+ & [ PRED numbered_hour_rel ] > ]. parg := monotonic_mtr & [ INPUT.RELS < [ PRED "parg_d_rel" ] >, OUTPUT.RELS < +copy+ & [ PRED parg_d_rel, ARG0 e_untensed ] > ]. part_of := monotonic_mtr & [ INPUT.RELS < [ PRED "part_of_rel" ] >, OUTPUT.RELS < +copy+ & [ PRED part_of_rel ] > ]. poss := monotonic_mtr & [ INPUT.RELS < [ PRED "poss_rel" ] >, OUTPUT.RELS < +copy+ & [ PRED poss_rel ] > ]. pron := noun_mtr & [ INPUT.RELS < [ PRED "pron_rel" ] >, OUTPUT.RELS < [ PRED pron_rel ] > ]. recip_pro := noun_mtr & [ INPUT.RELS < [ PRED "recip_pro_rel" ] >, OUTPUT.RELS < [ PRED recip_pro_rel ] > ]. ref-identity := monotonic_mtr & [ INPUT.RELS < [ PRED "ref-identity_rel", LBL #h0, ARG1 #x1, ARG2 #x2 ] >, OUTPUT.RELS < [ PRED appos_rel, LBL #h0, ARG0 e_untensed, ARG1 #x1, ARG2 #x2 ] > ]. ;;; ;;; New type superlative_mtr (compared to comparative_mtr) ;;; to prevent ARG2 which again prevents generation. (11-may-06; jtl) ;;; superl_pos := superlative_mtr & [ INPUT.RELS < [ PRED "superl_pos_rel" ] >, OUTPUT.RELS < [ PRED superl_rel ] > ]. title_id := monotonic_mtr & [ INPUT.RELS < [ PRED "title_id_rel" ] >, OUTPUT.RELS < +copy+ & [ PRED title_id_rel, ARG0 e_untensed ] > ]. unknown := monotonic_mtr & [ INPUT.RELS < [ PRED "unknown_rel" ] >, OUTPUT.RELS < +copy+ & [ PRED unknown_rel ] > ]. ;;; ;;; _fix_me_ ;;; i suspect this is no longer used in NorGram, but while it is in the SEM-I, ;;; we might as well play things safe today. (4-jan-07; oe) ;;; compound := monotonic_mtr & [ INPUT.RELS < [ PRED "compound_rel" ] >, OUTPUT.RELS < +copy+ & [ PRED compound_rel, ARG0 e_untensed ] > ]. unspec := monotonic_mtr & [ INPUT.RELS < [ PRED "unspec_rel" ] >, OUTPUT.RELS < +copy+ & [ PRED compound_rel, ARG0 e_untensed ] > ]. unspec_loc := monotonic_mtr & [ INPUT.RELS < [ PRED "unspec_loc_rel" ] >, OUTPUT.RELS < +copy+ & [ PRED unspec_loc_rel ] > ]. unspec_manner := monotonic_mtr & [ INPUT.RELS < [ PRED "unspec_manner_rel" ] >, OUTPUT.RELS < +copy+ & [ PRED unspec_manner_rel ] > ]. subord := subordination_mtr & [ INPUT.RELS < [ PRED "subord_rel" ] >, OUTPUT.RELS < [ PRED subord_rel ] > ]. topic := monotonic_mtr & [ INPUT.RELS < [ PRED "topic_d_rel" ] >, OUTPUT.RELS < +copy+ & [ PRED focus_d_rel, ARG0 e_untensed ] > ]. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; ;;; coordination, no longer broken down by event vs. instance coordination ;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; and := conjunction_mtr & [ INPUT.RELS < [ PRED "and_rel" ] >, OUTPUT.RELS < [ PRED _and_c_rel ] > ]. and_then := conjunction_mtr & [ INPUT.RELS < [ PRED "and+then_rel" ] >, OUTPUT.RELS < [ PRED _and+then_c_rel ] > ]. basic_conj := conjunction_mtr & [ INPUT.RELS < [ PRED "basic_conj_rel" ] >, OUTPUT.RELS < [ PRED implicit_conj_rel ] > ]. ;;; ;;; _fix_me_ ;;; we lack a suitable ERG target predicate here. (25-aug-04; oe) ;;; both_and := conjunction_mtr & [ INPUT.RELS < [ PRED "both_and_rel" ] >, OUTPUT.RELS < [ PRED _and_c_rel ] > ]. but := conjunction_mtr & [ INPUT.RELS < [ PRED "but_rel" ] >, OUTPUT.RELS < [ PRED _but_c_rel ] > ]. either_or := conjunction_mtr & [ INPUT.RELS < [ PRED "either_or_rel" ] >, OUTPUT.RELS < [ PRED _or_c_rel ] > ]. for_conj := coord_subord_mtr & [ INPUT.RELS < [ PRED "for_rel" ] >, OUTPUT.RELS < [ PRED "_for_x_cause_rel" ] > ]. implicit_conj := conjunction_mtr & [ INPUT.RELS < [ PRED "implicit_conj_rel" ] >, OUTPUT.RELS < [ PRED implicit_conj_rel ] > ]. neither_nor := conjunction_mtr & [ INPUT.RELS < [ PRED "neither_nor_rel" ] >, OUTPUT.RELS < [ PRED _nor_c_rel ] > ]. or := conjunction_mtr & [ INPUT.RELS < [ PRED "or_rel" ] >, OUTPUT.RELS < [ PRED _or_c_rel ] > ]. pluss := conjunction_mtr & [ INPUT.RELS < [ PRED "pluss_rel" ] >, OUTPUT.RELS < [ PRED _plus_c_rel ] > ]. samt := conjunction_mtr & [ INPUT.RELS < [ PRED "samt_rel" ] >, OUTPUT.RELS < [ PRED _as+well+as_c_rel ] > ]. så := conjunction_mtr & [ INPUT.RELS < [ PRED "så_rel" ] >, OUTPUT.RELS < [ PRED _so_c_rel ] > ]. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; ;;; modals ;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; epist-burde_v := modal_mtr & [ INPUT.RELS < [ PRED "_epist-burde_v_rel", ARG0 [ TENSE past_or_pres ] ] >, OUTPUT.RELS < [ PRED _ought_v_modal_rel, ARG0 [ TENSE pres ] ] > ]. ;;; ;;; _fix_me_ ;;; `may' and several other English modals have no past tense forms; what can ;;; we do instead then? (13-aug-04; oe) ;;; --- for right now, output ERG-specific values here. (25-aug-04; oe) ;;; --- dan has reworked `could', `should', et al. review these rules and aim ;;; to eliminate extra post-processing in ERG fix-up phase. (16-sep-06; oe) ;;; epist-kunne_could_v := modal_mtr & [ INPUT.RELS < [ PRED "_epist-kunne_v_rel", ARG0 [ TENSE past ] ] >, OUTPUT.RELS < [ PRED _could_v_modal_rel, ARG0 [ TENSE pres ] ] > ]. epist-kunne_may_v := modal_mtr & [ INPUT.RELS < [ PRED "_epist-kunne_v_rel" ] >, OUTPUT.RELS < [ PRED _may_v_modal_rel ] > ]. epist-måtte_v := modal_mtr & [ INPUT.RELS < [ PRED "_epist-måtte_v_rel" ] >, OUTPUT.RELS < [ PRED _must_v_modal_rel ] > ]. epist-skulle_past_v := modal_mtr & [ INPUT.RELS < [ PRED "_epist-skulle_v_rel", ARG0 [ TENSE past_or_pres ] ] >, OUTPUT.RELS < [ PRED _should_v_modal_rel, ARG0 [ TENSE pres ] ] > ]. epist-skulle_v := modal_mtr & [ INPUT.RELS < [ PRED "_epist-skulle_v_rel" ] >, OUTPUT.RELS < [ PRED _should_v_modal_rel ] > ]. ;;; ;;; _fix_me_ ;;; this might be a case where we would like to unify two variables that were ;;; distinct in the input MRS, viz. the LBL of the modal operator and the LBL ;;; of the verbal EP that we mark for future tense. we can (more or less) hack ;;; the intended effect, but it would seem potentially somewhat simpler to say ;;; something like, say, [ FLAGS.UNIFY < #h0, #h2 > ] and take that to mean ;;; that post input matching, the two variables have to be unified (ignoring ;;; offending Skolem constants) and the result be used in assembling the final ;;; output. (11-nov-04; oe) ;;; ;;; ;;; _fix_me_ ;;; after elimination of messages, the following rules fails to fire on inputs ;;; like `Jon vil spise.', but works well for `Han tror at Jon vil spise.' It ;;; almost looks as if the transfer engine fails to bind the second QEQ from ;;; the INPUT condition against the QEQ that NorGram provides below the TOP. ;;; i want to debug this further, but for now provide an alternate version of ;;; the rule, which should only apply to modals as the top-level predicate. ;;; (18-oct-07; ph & oe) ;;; ;;; --- this should now be fixed, rendering the alternate rule unncessary. ;;; (13-nov-07; oe) ;;; epist-ville_v := monotonic_omtr & [ INPUT [ RELS < [ PRED "~_v_(?:[^_]+_)?rel$", LBL #h0, ARG0 #e0 & [ TENSE untensed ] ], [ PRED "_epist-ville_v_rel", LBL #h2, ARG0 #e2 & [ TENSE pres ], ARG1 #h4 ] >, HCONS < qeq & [ HARG #h4, LARG #h0 ], qeq & [ HARG #h5, LARG #h2 ] > ], OUTPUT [ RELS < +copy+ & [ ARG0 [ TENSE fut ] ], [ PRED intersective_equate, ARG0 #e0, ARG1 #e2 ], [ PRED intersective_equate, ARG0 #h0, ARG1 #h2 ] >, HCONS < qeq & [ HARG #h5, LARG #h0 ] > ] ]. epist-ville_past_v := modal_mtr & [ INPUT.RELS < [ PRED "_epist-ville_v_rel", ARG0 #e2 & [ TENSE past ] ] >, OUTPUT.RELS < [ PRED _would_v_modal_rel, ARG0 #e2 & [ TENSE pres ] ] > ]. root-burde_should := arg12_modal_omtr & [ INPUT.RELS < [ PRED "_root-burde_v_rel", ARG0 [ TENSE pres, PERF - ] ] >, OUTPUT.RELS < [ PRED _should_v_modal_rel ] > ]. root-burde_ought := arg12_modal_omtr & [ INPUT.RELS < [ PRED "_root-burde_v_rel", ARG0 [ TENSE pres, PERF - ] ] >, OUTPUT.RELS < [ PRED _ought_v_modal_rel ] > ]. root-burde_have+to := arg12_modal_mtr & [ INPUT.RELS < [ PRED "_root-burde_v_rel" ] >, OUTPUT.RELS < [ PRED "_have_v_to_rel" ] > ]. root-kunne_can_v := arg12_modal_omtr & [ INPUT.RELS < [ PRED "_root-kunne_v_rel", ARG0 [ TENSE past_or_pres, PERF - ] ] >, OUTPUT.RELS < [ PRED _can_v_modal_rel ] > ]. root-kunne_able_v := arg12_v_mtr & [ INPUT.RELS < [ PRED "_root-kunne_v_rel" ] >, OUTPUT.RELS < [ PRED "_able_a_1_rel" ] > ]. root-måtte_must := arg12_modal_omtr & [ INPUT.RELS < [ PRED "_root-måtte_v_rel", ARG0 [ TENSE pres, PERF - ] ] >, OUTPUT.RELS < [ PRED _must_v_modal_rel ] > ]. root-måtte_have+to := arg12_modal_mtr & [ INPUT.RELS < [ PRED "_root-måtte_v_rel" ] >, OUTPUT.RELS < [ PRED "_have_v_to_rel" ] > ]. root-skulle_should := arg12_modal_omtr & [ INPUT.RELS < [ PRED "_root-skulle_v_rel", ARG0 [ TENSE past_or_pres ] ] >, OUTPUT.RELS < [ PRED _should_v_modal_rel, ARG0 [ TENSE pres ] ] > ]. root-skulle_must := arg12_modal_mtr & [ INPUT.RELS < [ PRED "_root-skulle_v_rel" ] >, OUTPUT.RELS < [ PRED _must_v_modal_rel ] > ]. root-tore_v := arg12_v_mtr & [ INPUT.RELS < [ PRED "_root-tore_v_rel" ] >, OUTPUT.RELS < [ PRED "_dare_v_1_rel" ] > ]. root-ville_v := arg12_v_mtr & [ INPUT.RELS < [ PRED "_root-ville_v_rel" ] >, OUTPUT.RELS < [ PRED "_want_v_1_rel" ] > ]. ;;; ;;; at this point, we are done with Norwegian modals, so put in a few rules to ;;; prune transfer branches (containing left-over predicates or outputs that we ;;; know cannot generate in English) early; this, effectively, will not affect ;;; the formal properties of the transfer grammar but might (a) lead to better ;;; diagnostics and (b) cut back transfer ambiguity, so that complex inputs may ;;; succeed within a certain edge limit, where they would otherwise fail ... ;;; leftover_modal_block := monotonic_mtr & [ CONTEXT.RELS < [ PRED "~^_(?:epist|root)-[^_]+_v_rel" ] >, FLAGS.BLOCK "left-over Norwegian modal EP" ]. untensed_modal_block := monotonic_mtr & [ CONTEXT.RELS < [ PRED "~_(?:can|must|ought|should)_v_modal_rel", ARG0 [ TENSE untensed ] ] >, FLAGS.BLOCK "untensed English modal EP" ]. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; ;;; transfer correspondences for pieces of fragmented (incomplete) MRSs ;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; fragment := monotonic_mtr & [ INPUT.RELS < [ PRED "fragment_rel", LBL #h0, L-HNDL #h1, R-HNDL #h2 ] >, OUTPUT.RELS < [ PRED unspec_conj_rel, LBL #h0, L-HNDL #h1, R-HNDL #h2 ] > ]. colon := monotonic_mtr & [ INPUT.RELS < [ PRED "colon_rel", LBl #h0 ] >, OUTPUT.RELS < [ PRED colon_rel, LBl #h0 ] > ]. comma := monotonic_mtr & [ INPUT.RELS < [ PRED "comma_rel", LBl #h0 ] >, OUTPUT.RELS < [ PRED comma_rel, LBl #h0 ] > ]. dash := monotonic_mtr & [ INPUT.RELS < [ PRED "dash_rel", LBl #h0 ] >, OUTPUT.RELS < [ PRED hyphen_rel, LBl #h0 ] > ]. excl-point := monotonic_mtr & [ INPUT.RELS < [ PRED "excl-point_rel", LBl #h0 ] >, OUTPUT.RELS < [ PRED exclamation_point_rel, LBl #h0 ] > ]. int-mark := monotonic_mtr & [ INPUT.RELS < [ PRED "int-mark_rel", LBl #h0 ] >, OUTPUT.RELS < [ PRED question_mark_rel, LBl #h0 ] > ]. period := monotonic_mtr & [ INPUT.RELS < [ PRED "period_rel", LBl #h0 ] >, OUTPUT.RELS < [ PRED period_rel, LBl #h0 ] > ]. quote := monotonic_mtr & [ INPUT.RELS < [ PRED "quote_rel", LBl #h0 ] >, OUTPUT.RELS < [ PRED quote_rel, LBl #h0 ] > ]. token := monotonic_mtr & [ INPUT.RELS < [ PRED "token_rel", LBl #h0, CARG #carg ] >, OUTPUT.RELS < [ PRED token_rel, LBl #h0, CARG #carg ] > ].