We propose neural models to generate text from formal meaning representations based on Discourse Representation Structures (DRSs). DRSs are document-level representations which encode rich semantic detail pertaining to rhetorical relations, presupposition, and co-reference within and across sentences. We formalize the task of neural DRS-to-text generation and provide modeling solutions for the problems of condition ordering and variable naming which render generation from DRSs non-trivial. Our generator relies on a novel sibling treeLSTM model which is able to accurately represent DRS structures and is more generally suited to trees with wide branches. We achieve competitive performance (59.48 BLEU) on the GMB benchmark against several strong baselines. It is not uncommon for text generation systems to produce natural language output from intermediate semantic representations (Yao et al., 2012; Takase et al., 2016). The literature presents several examples of generating text from logical forms underlying various grammar formalisms (Wang, 1980; Shieber et al., 1990; Carroll and Oepen, 2005; White et al., 2007), typed lambda calculus (Lu and Ng, 2011), Abstract Meaning Representations (AMR; Flanigan et al. 2016; Konstas et al. 2017; Song et al. 2018; Beck et al. 2018; Damonte and Cohen 2019; Ribeiro et al. 2019; Zhu et al. 2019; Cai and Lam 2020; Wang et al. 2020), Discourse Representation Theory (DRT; Basile and Bos 2011; Basile 2015), and Minimal Recursion Semantics (MRS; Horvat et al. 2015; Hajdik et al. 2019). In this work, we propose neural models to generate high-quality text from semantic representations based on Discourse Representation Structures (DRSs). DRSs are the basic meaning-carrying units in Discourse Representation Theory (DRT; Kamp b 5 b 6 : x 1 , b 1 : e 1 , b 1 : x 2 , b 2 : t 1 b 1 b 6 : Pred( x 1 , male.n.02) b 1 : Pred( e 1 , play.v.03) b 1 : Agent( e 1 , x 1 ) b 1 : Theme( e 1 , x 2 ) b 1 : Pred( x 2 , piano.n.01) b 2 : Pred( t 1 , now.n.01) b 1 : temp after( e 1 , t 1 ) b 4 b 4 : (cid:5) : b 3 : x 3 , b 3 : e 2 b 3 b 3 : Named( x 3 , tom) b 3 : Pred( e 2 , stop.v.05) b 3 : Agent( e 2 , x 3 ) b 1 : Pred( x 1 , male.n.02) b 3 : Patient( e 2 , x 1 ) b 3 : temp before( e 2 , e 1 ) CONTRAST( b 1 , b 4 ) The man is going to play the piano. 1981; Kamp and Reyle 1993; Asher and Lascarides 2003), a formal semantic theory designed to handle a variety of linguistic phenomena, including anaphora, presuppositions (Van der Sandt, 1992; Venhuizen et al., 2018), and temporal expressions within and across sentences. DRSs are scoped meaning representations, they capture the semantics of negation, modals, and quantification. Figure 1 displays in box format the meaning representation for a discourse consisting of two sentences. The outermost box is a segmented DRS expressing the rhetorical relation CONTRAST between box b 1 representing the first sentence and box b 4 representing the second sentence. Boxes b 1 and b 2 are DRSs, the top layers contain variables (e.g., x 1 , x 2 ) indicating discourse referents and the bottom layers contain conditions (e.g., Named( x 3 , tom)) representing information about discourse referents. Variables and conditions have pointers (denoted by b in the figure) pointing to the boxes where they should be interpreted. 1 Predicates are disambiguated to their Wordnet (Fellbaum, 1998) senses (e.g., male.n.02 and play.v.03). Although there has been considerable activity recently in developing models which analyze text in the style of DRT (van Noord et al., 2018, 2019; Liu et al., 2019a, 2018; Fancellu et al., 2019), attempts 1 In Figure 1, b 6 is a presuppositional box for the interpretation of the man in the context of the two-sentence discourse. to generate text from DRSs have been few and far between (however see Basile 2015 and Narayan and Gardent 2014 for notable exceptions). This is primarily due to two properties of DRS-based semantic representations which render generation from them challenging. Firstly, DRS conditions are unordered representing a set (rather than a list). 2 A hypothetical generator would have to produce the same output text for any DRSs which convey the same meaning but appear different due to their conditions having a different order (see Figures 1 and 2a which are otherwise identical but the order of conditions in boxes b 1 and b 4 varies). The second challenge concerns variables and their prominent status in DRSs. Variables identify objects in discourse (such as entities and predicates), and are commonly used to model semantic phenomena including coreference, control constructions, and scope. In Figure 1, variables x, e, s, t, p, and b denote entities, events, states, time, propositions and boxes, respectively. Variable names themselves are arbitrary and meaningless posing a challenge for learning. Our generator must verbalize different variable names to the same surface form. The meaning representations in Figures 1 and 2b are identical and both correspond to the same discourse except that the variables have been given different names ( b 5 in Figure 1 has been named b 1 in Figure 2b, b 1 is now b 2 , x 1 is x 2 , e 1 is e 9 , and so on). These two problems are further compounded by the way DRSs are displayed, in a box-like format which is intuitive and easy to read but not convenient for modeling purposes. As a result, DRSs are often post-processed in a format that can be handled more easily by modern neural network models. For example, DRS variables and conditions are converted to clauses (van Noord et al., 2018) or DRSs are modified to trees where each box is a subtree and conditions within the box correspond to children of the subtree (Liu et al., 2019a, 2018). In this paper we propose novel solutions to condition ordering and variable naming. We argue that even though DRS conditions appear unordered, they have a latent order due to biases in the way the training data is created. To give a concrete example, the Groningen Meaning Bank (GMB; Bos et al. 2017) provides the largest collection to date of English texts annotated with DRSs. These annotations were generated with the aid of a CCG parser (Clark and Curran, 2007); atomic DRS conditions were associated with CCG supertags and then semantically combined following the syntactic CCG derivations. Even annotators creating DRSs manually would be prone to follow a canonical order (e.g., listing named entities first, then verbal predicates and their thematic roles, and finally temporal conditions). We propose a graph-based model which learns to recover the latent order of conditions without explicitly enumerating all possible orders which can be prohibitive. We also handle variable names with a method which rewrites arbitrary indices to relative ones which are in turn determined by the order of conditions. Following previous work, we convert DRSs to a more amenable format. Specifically, we consider Discourse Representation Tree Structures (DRTSs; Liu et al. 2019b) as the semantic representation input to our document generation task, and generate a sequence of words autoregressively. We adopt an encoder-decoder framework with a treeLSTM (Tai et al., 2015) encoder and a standard LSTM (Hochre-iter and Schmidhuber, 1997) decoder. Problematically, DRS trees are wide and the number of children for a given node can be as many as 180. It therefore becomes memory-consuming and sparse to assign a forget gate for each child as in the case of conventional ( N -ary) treeLSTM (Tai et al., 2015). We propose a variant which we call Sibling treeLSTM that replaces N forget gates with a parent gate and a sibling gate. As a result, it reduces memory usage from O ( N ) to O (2) , and is more suitable for modeling wide and flat trees. Our contributions can be summarized as follows: (1) we formalize the task of neural DRS-to-text generation; (2) we provide solutions for the problems of condition ordering and variable naming, which render generation from DRS-based meaning representations non-trivial; and (3) propose a novel sibling treeLSTM model that can be also generally used to model wide tree structures. We make our code and datasets publicly available. 3 2 Problem Formulation Let S denote a DRS-based meaning representation. The aim of DRS-to-text generation is to produce text T that verbalizes input meaning S : T  = arg max T  TP ( T | S, ) , where T is the set of all possible texts, S has an arbitrary order of conditions and indexing of variables, and  is the set of model parameters. Our generation model is based on the encoder-decoder framework (Bahdanau et al., 2015) and operates over tree structures. Moreover, prior to training, variable names are rewritten so that their (arbitrary) indices denote relative order of appearance. We propose a novel sibling TreeLSTM for encoding tree structures. The decoder is a sequential LSTM equipped with an attention mechanism generating word sequence T = [ t 0 , t 1 , ..., t m  1 ] , where m is the length of the text. At test time, DRS conditions are normalized, i.e., they are reordered following a canonical order learned from data, and used as input to our generation model. We first describe our DRS-to-tree conversion and variable renaming procedures (Sections 2.1 and 2.2). We next present our tree-to-sequence generation model (Section 2.3), and explain how DRS conditions are ordered (Section 2.4). The algorithm of Liu et al. (2018) renders DRSs in a tree-style format. It constructs trees based on DRS conditions in the bottom box layers, without considering variables in the top layer. This results in oversimplified semantic representations and information loss (e.g., presuppositions cannot be handled). We improve upon their approach by 3 https://github.com/LeonCrashCode/ Discourse-Representation-Tree-Structure/tree/main/gmb/DRS-to-text merging variables in the top layer with variables in the bottom layer via introducing special conditions. We collect variables in top layers of DRS boxes to construct a dictionary d = { v : b } , where v denotes a variable and b is a presupposition box label (e.g., x 1 : b 1 ). We then move variables from the top to the bottom layer by expressing them as special conditions b : Ref( v ) and placing them before conditions on variable v . For example, b 6 : x 1 in Figure 1 becomes special condition b 6 : Ref( x 1 ) and is placed before condition b 6 : Pred( x 1 , male.n.02) in Figure 3(a). Once top variables have been rewritten as special conditions, the resulting DRSs are converted into trees as shown in Figure3(b). Box variables (e.g., b 1 , b 5 ) become parent nodes, while conditions, which are also subtrees, become children. We rename variables with regard to their relative position in a given DRS following a predefined traversal order. We obtain the sequence of box variables by traversing DRSs in an outer-to-inner and left-to-right manner, e.g., [ b 5 , b 1 , b 4 , b 3 ] in Figure 1. For SDRSs, we replace variables in discourse relations with k i , where i denotes th i th box from left to right. For example CONTRAST( b 1 , b 4 ) in Figure 1 is rewritten to CONTRAST( k 0 , k 1 ). Variables and conditions within presupposition boxes are rewritten to B i , where i  Z denotes the distance of the current box to the presupposition box. For example, b 1 : Agent( e 1 , x 1 ) is rewritten to B 0 : Agent( e 1 , x 1 ) because it is in the current box b 1 , while b 1 : Pred( x 1 , male.n.02) is rewritten to B  2 : Pred( x 1 , male.n.02) because it is in box b 3 and two hops away from presupposition box b 1 . We use special label O for presupposition boxes pertaining to semantic content outwith the current DRS. For example, b 6 : Ref( x 1 ) is rewritten to O : Ref( x 1 ) because it introduces a new presupposition box, and b 6 : Pred( x 1 , male.n.02) is rewritten to O 0 : Pred( x 1 , male.n.02) because the condition can only be interpreted in this new presupposition box (now O 0 and previoulsy b 6 ). We obtain a sequence of general variables by traversing conditions as they appear in the DRS. Variables introduced for the first time are denoted by their type (going from left-to-right), while subsequent mentions of the same variables are rewritten with relative indices denoting their distance from the position where they were first introduced. Take Figure 3(a) as an example. The sequence of general variables is [ x 1 , x 1 , e 1 , e 1 , e 1 , x 1 , x 2 , e 1 , x 2 , x 2 , t 1 , t 1 , e 1 , t 1 , x 3 , x 3 , e 2 , e 2 , e 2 , x 3 , x 1 , e 2 , x 1 , e 2 , e 1 ], and is rewritten to [ X , X 0 , E , E 0 , E 0 , X 0 , X , E 0 , X 0 , X 0 , T , T 0 , E 0 , T 0 , X , X 0 , E , E 0 , E 0 , X 0 , X  2 , E 0 , X  2 , E 0 , E  1 ]. The DRS from Figure 3(a) is shown in Figure 4 with relative variables. Our generation model is based on the encoder-decoder framework, where an encoder is used to encode input DRS trees and a decoder outputs a sequence of words. A limitation of sequential encoders is that they only allow sequential information propagation without considering the structure of the input (Tai et al., 2015; Wang et al., 2019). In b 6 x 1 Ref b 6 x 1 male.n.02 our case, DRS tree structures are additionally wide (the longer a document, the wider the tree) and relatively flat (see Figure 3(b)). To better model these aspects, we propose a treeLSTM encoder which takes sibling information into account. As shown in Figure 5, the hidden representations of the sibling TreeLSTM cells are updated from preceding sibling and child nodes. More formally, the hidden representation for node j is given by: u j = tanh( g u ([ x j ; h js ; h jp ])) (1) i j , o j =  ( g io ([ x j ; h js ; h jp ])) (2) f js =  ( g fs ([ x j ; h js ])) (3) f jp =  ( g fp ([ x j ; h jp ])) (4) c j = i j  u j + f js  c js + f jp  c jp (5) h j = o j  tanh( c j ) , (6) where x j is the token input representation, h js is the hidden representation of the sibling node preceding j , h jp is the hidden representation of the last child of node j (Equation (1)), g  are linear functions, and  is a sigmoid function (Equations (2) (4)). For each node j , we obtain its cell input representation u j (Equation (1)), its input gate i j and output gate o j (Equation (2)), and two forget gates f js (Equation (3)) and f jp (Equation (4)) for its neighbor cell and the last child cell, respectively. The memory of the current cell c j (Equation (5)) is updated by the gated sum of its cell input representation and the memories of its neighbor and child cells. The hidden representation of current node h j is computed with its output gate o j (Equation (6)). Finally, a DRS tree is represented by the hidden representations of its nodes [ h 0 , h 1 , ..., h n (cid:48)  1 ] as computed by the sibling treeLSTM ( n (cid:48) denotes the number of nodes). The decoder is a standard LSTM with global attention (Bahdanau et al., 2015). As discussed previously, DRSs at test time may exhibit an arbitrary order of conditions, which our model should be able to handle. Our solution is to to reorder conditions prior to generation by learning a latent canonical order from training data (e.g., to recover boxes b 1 and b 3 in Figure 1 from boxes b 1 and b 3 in Figure 2). More formally, given a set of conditions R set , we obtain an optimal ordering R = [ r 0 , r 1 , ..., r n  1 ] such that: R  = arg max R   ( R set ) SCOREK ( R | R set ) , (7) where  ( R set ) are all permutations of R set , and R  is the order with the highest likelihood according to SCOREK . Here, K parametrizes SCORE as knowledge we collect from our training data by observing canonical orders of conditions. Unfortunately, the time complexity of calculating Equation (7) is O ( n !) , we must enumerate all possible permutations for a set of conditions with n as large as 180 . Since this is prohibitive, we resort to graph ordering which allows us to recover the order of the conditions without enumeration. Graph Construction We construct a graph from the set of DRS conditions which we break down into graph nodes and edges. Conditions in DRSs can be simple or complex according to their type of arguments. A simple condition might have a relation name with two arguments (e.g., Named( x 3 , tom) and Agent( e 1 , x 3 )), while a complex condition has a scoped name (e.g., possibility (cid:5) ) and takes one or more DRSs as arguments. Simple conditions are denoted by a 3-tuple ( l s , a 0 , a 1 ) , where l s is the condition name (e.g., Named and Agent) and a 0 and a 1 are its first and the second argument, respectively, which could be a variable or constant (e.g., e 1 , x 3 and piano.n.01). Complex conditions are a 2-tuple ( l c , V r ), where l c is the scope name, and V r the set of arguments scoped by the condition. For example, the set of arguments for the possibility scope ( (cid:5) ) in Figure 1 is { e 1 , e 2 , x 1 , x 3 , tom, stop.v.05, male.n. } . Condition names become nodes in our graph. Simple conditions are further divided into constant and thematic nodes. Constant nodes are constructed by concatenating the relation name in the condition with the constant argument (e.g., condition Pred( x 1 , male.n.02) becomes node Pred male.n.02). Thematic nodes correspond to the relation name of the thematic condition (e.g., Agent( e 1 , x 1 ) becomes the node Agent). Complex nodes correspond to the name of complex conditions (e.g., possibility (cid:5) ). We insert edges between graph nodes if these share arguments. For example, in Figure 6(b), there is an edge connecting node Pred male.n.02 with Agent as they share argument x 1 . We label this edge with a 1 to denote the fact that it is the second argument of Agent. Another edge is drawn between Pred play.v.03 and Agent (as they share argument e 1 ) with label a 0 denoting that this is the first argument of Agent. Edges between nodes are bidirectional, with inverse edges bearing the suffix -of. Edges drawn between constant and complex nodes bear the label Related, while edges between two constant nodes (with the same variables) bear the label Equal (we provide a more formal description in the Appendix). Ordering Model Given graph G = ( R set , E ) , where R set = { r 0 , r 1 , ..., r n  1 } is the set of nodes and E is the set of edges in G , our model outputs R  as the optimal order of R set . As shown Figure 6(a), each node is a sequence of words. A BiLSTM is applied to obtain representation x i of each node r i = [ w i 0 , ..., w im  1 ] : x i = BiLSTM ([ w i 0 , ..., w im  1 ]) . each node r i , we collect information from neighbor hidden representations with a gate controling the information flow from neighbors to current nodes: h (cid:48) ki = (cid:88) j g kj  h k  1 j ; (9) g kj =  ( f ([ e ji , h k  1 i , h k  1 j ])) , (10) where e ji is the embedding of edges from node r j to r i , and k is the recurrent step in the GRU. The node hidden representations are updated as: h ki = GRUCell ([ x i ; g k  1 G ] , h k  1 i ) (11) g kG = GRUCell ( 1 n (cid:88) i h ki , g k  1 G ) (12) where g G represents the hidden representation of the graph as the average of (hidden) node representations, and GRUCell denotes the gated recurrent cell function. We obtain the hidden representations of nodes in the final recurrent step ( K ) as HK = { h K 0 , h K 1 , ..., h Kn  1 } . Our decoder obtains the orders with the highest probability. We avoid enumerating all possible permutations for a set of nodes by generating their order autoregressively with an LSTM-based Pointer Network (PN; Vinyals et al. 2015): SCOREK ( R | R set ) = PN ( R | R set , HK ,  ) (13) PN ( R | R set , HK ,  ) = (cid:89) i P ( r i | r <i , HK ) (14) P ( r i | r <i , HK ) = softmax( v T tanh( W [ h di ; HK ])) (15) where  are the parameters of the Pointer Network, h di is the i th step hidden representation of the Pointer Network, and v , and W are parameters. Hidden representation h di is updated by the input representation of the ( i  1) th ordered node: h di = LSTMCell ( x r i  1 , h di  1 ) . All parameters are optimized with standard back-propagation. Our experiments were carried out on the Groningen Meaning Bank (GMB; Bos et al. 2017) which provides a large collection of English documents annotated with DRSs. We used the standard training, development, and test splits that come with the distribution of the corpus. All DRSs in the GMB were preprocessed into the tree-based format discussed in Section 2.1. We also extracted from the training data conditions and their order for training our graph ordering model. Dataset statistics are shown in Table 1. Models and Settings Before evaluating our generator per se, we assess the effectiveness of the proposed condition ordering model (see Section 2.4). Specifically we compare four kinds of graphs: NoEdges , is a graph without edges; FullEdges , is a complete graph where each pair of nodes has edges; SiGraph , is the proposed graph without bidirectional edges; and BiGraph , is the proposed graph with bidirectional edges (see Figure 6). We also consider Counting , a baseline model which greedily orders pairs of conditions according to their frequency of appearance in the training data (see the Appendix for details). For all neural models the embedding dimension was 50 and the hidden dimension 300. The bidirectional LSTM used for representing the graph nodes has a single layer, and the recurrent step in the GCRN is 2 ( K = 2 ). We applied the Adam optimizer (Kingma and Ba, 2014). We use accuracy to measure the percentage of absolute orders which are predicted correctly and Kendall's  co-efficient to measure the relationship between two lists of ordered items;  ranges from  1 to 1, where  1 means perfect inversion and 1 means perfect agreement. Results Table 2 summarizes our results. SiGraph performs better than NoEdges ( + 14.83% accu-racy), showing that edge information is helpful for the representation of nodes which are used to order conditions. FullEdges performs worse than SiGraph (  13.68% accuracy), underlying the fact that graph structure matters (i.e., edges are helpful when connecting certain pairs of nodes). BiGraph achieves the best ordering performance by a large margin compared to SiGraph ( + 9.63 % accuracy). One possible reason is that bidirectionality ensures all nodes have incoming edges, which can be used to update the node representations. Models and Settings We first examine generation performance in an ideal setting where (gold standard) condition orders are given and the indices of variables are fixed. We compared the proposed treeLSTM against Seq , a baseline sequence-to-sequence model which adopts a bidirectional LSTM as its encoder. 4 Trees were linearized in a top-down and left-to-right fashion, X = [ x 0 , x 1 , ...x n  1 ] , where n is the tree length. We obtained hidden representations H = [ h 0 , h 1 , ..., h n  1 ] of the input with: [ h 0 , h 1 , ..., h n  1 ] = BiLSTM ([ x 0 , x 1 , ..., x n ]) In addition, we included various models with tree-based encoders: ChildSum , is the bidirectional childsum-treeLSTM encoder of Tai et al. (2015); it operates over right-branch binarized trees; Nary , is the bidirectional Nary-TreeLSTM of Tai et al. (2015), again over right-branch binarized trees; 5 and Sibling is our bidirectional sibling-TreeLSTM. All models were equipped with the same LSTM decoder, global attention (Bahdanau et al., 2015), and the copy strategy of See et al. (2017). The embedding dimension was 300 and the hidden dimension 512. All encoders and decoders have 2 layers. The detailed settings are shown in 4 The length of the input tokens can be around 4,000. the Appendix. We measure generation quality with case-insensitive BLEU (Papineni et al., 2002). Results Table 3 shows our results on the development dataset. Overall, treeLSTM models performs better (average + 1.69 BLEU) than sequence models. Nary performs better ( + 0.26 BLEU) than ChildSum because the latter cannot model the order of children. Sibling performs best (74.22 BLEU), because it it not only encodes the tree structure but also keeps track of sequential information. Models and Settings We finally, present our results in a more realistic setting where both problems of condition ordering and variable naming must be addressed. We recover condition order using four approaches: a Naive method which has no special-purpose ordering mechanism; the order of conditions is random in the development/test sets and fixed in the training set; Random , the order of conditions is random in the training, development, and test sets; Counting , the order of conditions is recovered by the Counting method; GraphOrder recovers the order of conditions with BiGraph . All comparison systems employ variable renaming as introduced in Section 2.2. We report experiments with a sequence-to-sequence generator and our sibling-TreeLSTM. Results Table 4 summarizes our results on the development set. Naive performs poorly, indicating that both Seq and Sibling models are sensitive to the order of conditions. Random, has higher variance with Seq ( + 16.51) compared to Sibling. Hidden representations for each timestep in Seq are heavily influenced by all previous steps, which are sequentially encoded; subtrees are encoded as a unit in Sibling, which is a more global representation for capturing patterns. Overall, we observe that the order of conditions plays a key role in the generation: both Seq and Sibling models improve when ordering of conditions is explicitly incorporated (either with Counting or GraphOrder). We observe that the combination of Sibling with GraphOrder achieves the best results (58.73 BLEU). Table 5 presents our results on the test set. We compare our Sibling encoder against a sequential one. Both models are interfaced with GraphOrder. We also compare to a previous graph-to-text model (Song et al., 2018; Damonte and Cohen, 2019) which has been used for generating from AMRs. We converted DRSs to graphs following the method of Liu et al. (2020); graphs were encoded with a GCRN (Seo et al., 2018) and decoded with an LSTM. As can be seen, Sibling+GraphOrder outperforms all comparison systems achieving a BLEU of 59.26. However, compared to ideal-world generation (see Table 3) there is still considerable room for improvement. Figure 7 shows model performance on test set against DRS size (i.e., the number of nodes in a DRS tree). Perhaps unsurprisingly, we see that generation quality deteriorates with bigger DRSs (i.e., with > 1,600 nodes). While BLEU is frequently adopted as an automatic evaluation metric for genration tasks, it is somewhat problematic in our case as it merely calculates word overlap between generated and gold-standard text without assessing whether model output is faithful to the semantics of the input (i.e., the DRS meaning representations). To this effect, we present examples of text generated by our model, demonstrating how the DRS input constrains and affects the output text. Figure 8 shows examples of text generation from the test set. In the first example, the model generates the word because from the rhetorical relation, BECAUSE( b 10 , b 12 ). Temporal information (highlighted in blue in the figure) is also accurately reflected in the generated text ( sell is inflected to its present tense form). In addition, the model tends to over-generate (e.g., the word dollar is mentioned twice) and sometimes misses out on important determiners (e.g., some ). In the second example, the model generates the word themselves referring to the entities mentioned before, e.g., x 29 equals to x 27 which refers to inmates , resolving the coref-erence. In the third example, the model generates the modal verb must in accordance with the scope operator NEC (a shorthand for Necessity, (cid:3) ). Also, the model generates all for food and goods corresponding to the Implication (IMP) condition (i.e.,  x ( P ( x )  Q ( x )) ). Much previous work has focused on text generation from formal representations of meaning focusing exclusively on isolated sentences or queries. The literature offers a collection of approaches to generating from AMRs most of which employ neural models and structured encoders (Song et al., 2018; Beck et al., 2018; Damonte and Cohen, 2019; Ribeiro et al., 2019; Zhu et al., 2019; Cai and Lam, 2020; Wang et al., 2020). Other work generates text from structured query language (SQL) adopting either sequence-to-sequence (Iyer et al., 2016) or graph-to-sequence models (Xu et al., 2018). Basile (2015) was the first to attempt generation from DRT-based meaning representations. He proposes a pipeline system which operates over graphs and consists of three components: an alignment module learns the correspondence between surface text and DRS structure, an ordering module determines the relative position of words and phrases in the surface form and a realizer generates the final text. Narayan and Gardent (2014) simplify complex sentences with a two-stage model which DRS ... first performs sentence splitting and deletion operations over DRSs and then uses a phrase-based machine translation model for surface realization. Our work is closest to Basile (2015); we share the same goal of generating from DRSs, however, our model is trained end-to-end and can perform long-form generation for documents and sentences alike. We also adopt an ordering component, but we order DRS conditions rather than lexical items, and propose a model capable of inferring a global order. There has been long-standing interest in information ordering within NLP (Lapata, 2003; Abend et al., 2015; Chen et al., 2016; Gong et al., 2016; Logeswaran et al., 2018; Cui et al., 2018; Yin et al., 2019; Honovich et al., 2020). Our innovation lies in conceptualizing ordering as a graph scoring task which can be further realized with graph neural network models (Wu et al., 2020). In this paper, we have focused on document-level generation from formal meaning representations. We have adopted DRT as our formalism of choice and highlighted various challenges associated with the generation task. We have introduced a novel sibling treeLSTM for encoding DRSs rendered as trees and shown it is particularly suited to trees with wide branches. We have experimentally demonstrated that our encoder coupled with a graph-based condition ordering model outperforms strong comparison systems. In the future, we would like to embed our generator in practical applications such as summarization and question answering. We thank the anonymous reviewers for their feedback. We gratefully acknowledge the support of the European Research Council (Lapata, Liu; award number 681760), the EU H2020 project SUMMA (Cohen, Liu; grant agreement 688139) and Bloomberg (Cohen, Liu).
objective abstain objective objective result abstain other objective other abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain objective method abstain abstain abstain objective abstain method method method abstain abstain objective abstain objective abstain abstain abstain abstain abstain objective abstain method objective method abstain abstain abstain other abstain method abstain abstain abstain abstain abstain abstain method abstain abstain method other method abstain abstain abstain abstain abstain other abstain abstain method abstain abstain abstain abstain abstain abstain other abstain abstain abstain abstain abstain abstain method other abstain abstain abstain method abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain method abstain abstain abstain abstain method other other abstain abstain method abstain abstain abstain abstain abstain abstain abstain abstain abstain result abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain result abstain abstain abstain abstain abstain abstain result abstain abstain abstain result abstain abstain abstain abstain abstain abstain abstain result result result abstain abstain abstain abstain abstain abstain abstain result abstain abstain abstain abstain abstain abstain abstain abstain abstain other other other other other other other abstain objective other abstain method result objective objective method other other