Original: B EAM T REE R ECURSIVE C ELLS
Revised: B EAM T REE R ECURSIVE C ELLS

Original: Anonymous authors
Revised: Anonymous authors

Original: Paper under double-blind review
Revised: Paper under double-blind review

Original: A BSTRACT
Revised: A BSTRACT

Original: Recursive Neural Networks (RvNNs) generalize Recurrent Neural Networks (RNNs) by allowing sequential composition in a more flexible order, typically, based on some tree structure.
Revised: Recursive Neural Networks (RvNNs) generalize Recurrent Neural Networks (RNNs) by allowing sequential composition in a more flexible order, typically, based on some tree structure.

Original: While initially user-annotated tree structures were used, in due time, several approaches were proposed to automatically induce treestructures from raw text to guide the recursive compositions in RvNNs.
Revised: While initially user-annotated tree structures were used, in due time, several approaches were proposed to automatically induce treestructures from raw text to guide the recursive compositions in RvNNs.

Original: In this paper, we present an approach called Beam Tree Recursive Cell (or BT-Cell) based on a simple yet overlooked backpropagation-friendly framework.
Revised: In this paper, we present an approach called Beam Tree Recursive Cell (or BT-Cell) based on a simple yet overlooked backpropagation-friendly framework.

Original: BT-Cell adapts beam search easy-first parsing for simulating RvNNs with automatic structureinduction.
Revised: BT-Cell adapts beam search easy-first parsing for simulating RvNNs with automatic structureinduction.

Original: Our results show that BT-Cell achieves near-perfect performance on several aspects of challenging structure-sensitive synthetic tasks like ListOps and also comparable performance in realistic data to other RvNN-based models.
Revised: Our results show that BT-Cell achieves near-perfect performance on several aspects of challenging structure-sensitive synthetic tasks like ListOps and also comparable performance in realistic data to other RvNN-based models.

Original: We further introduce and analyze several extensions of BT-Cell based on relaxations of the hard top-k operators in beam search.
Revised: We further introduce and analyze several extensions of BT-Cell based on relaxations of the hard top-k operators in beam search.

Original: We evaluate the models in different out of distribution splits in both synthetic and realistic data.
Revised: We evaluate the models in different out of distribution splits in both synthetic and realistic data.

Original: Additionally, we identify a previously unknown failure case for neural models in generalization to unseen number of arguments in ListOps.
Revised: Additionally, we identify a previously unknown failure case for neural models in generalization to unseen number of arguments in ListOps.

Original: Code is in the supplementary.
Revised: Code is in the supplementary.

Original:  I NTRODUCTION
Revised:  I NTRODUCTION

Original: In the space of sequence encoders, Recursive Neural Networks (RvNNs) can be said to lie somewhere in-between Recurrent Neural Networks (RNNs) and Transformers in terms of flexibility.
Revised: In the space of sequence encoders, Recursive Neural Networks (RvNNs) can be said to lie somewhere in-between Recurrent Neural Networks (RNNs) and Transformers in terms of flexibility.

Original: While vanilla Transformers show phenomenal performance and efficient scalability on a variety of tasks, it can often struggle in length generalization and systematicity in syntax-sensitive tasks (Tran et al., 2018;
Revised: While vanilla Transformers show phenomenal performance and efficient scalability on a variety of tasks, it can often struggle in length generalization and systematicity in syntax-sensitive tasks (Tran et al., 2018;

Original: Shen et al., 2019a; Lakretz et al., 2021; Csord ´ as et al., 2022).
Revised: Shen et al., 2019a; Lakretz et al., 2021; Csord ´ as et al., 2022).

Original: RvNN-based models, on the other hand, can often excel on some of the latter kind of tasks (Shen et al., 2019a; Chowdhury &
Revised: RvNN-based models, on the other hand, can often excel on some of the latter kind of tasks (Shen et al., 2019a; Chowdhury &

Original: Caragea, 2021; Liu et al., 2021; Bogin et al., 2021) making them worthy of further study although they may suffer from limited scalability in their current formulations.
Revised: Caragea, 2021; Liu et al., 2021; Bogin et al., 2021) making them worthy of further study although they may suffer from limited scalability in their current formulations.

Original: Given an input text, RvNNs
Revised: Given an input text, RvNNs

Original: (Pollack, 1990; Socher et al., 2010) are designed to build up the representation of the whole text by recursively building up the representations of its constituents starting from the most elementary representations (tokens) in a bottom-up fashion.
Revised: (Pollack, 1990; Socher et al., 2010) are designed to build up the representation of the whole text by recursively building up the representations of its constituents starting from the most elementary representations (tokens) in a bottom-up fashion.

Original: As such, RvNNs can model the hierarchical part-whole structures underlying texts.
Revised: As such, RvNNs can model the hierarchical part-whole structures underlying texts.

Original: However, originally RvNNs required access to pre-defined hierarchical constituency-tree structures.
Revised: However, originally RvNNs required access to pre-defined hierarchical constituency-tree structures.

Original: Several works (Socher et al., 2011;
Revised: Several works (Socher et al., 2011;

Original: Havrylov et al., 2019; Choi et al., 2018; Maillard et al., 2019; Chowdhury & Caragea, 2021) introduced latent-tree RvNNs that sought to move beyond this limitation by making RvNNs able to learn to automatically determine the structure of composition from any arbitrary downstream task objective, given just the raw input text.
Revised: Havrylov et al., 2019; Choi et al., 2018; Maillard et al., 2019; Chowdhury & Caragea, 2021) introduced latent-tree RvNNs that sought to move beyond this limitation by making RvNNs able to learn to automatically determine the structure of composition from any arbitrary downstream task objective, given just the raw input text.

Original: Among these approaches, Gumbel-Tree models (Choi et al., 2018) are particularly attractive for its simplicity.
Revised: Among these approaches, Gumbel-Tree models (Choi et al., 2018) are particularly attractive for its simplicity.

Original: It often serves as a standard baseline for latent-tree models.
Revised: It often serves as a standard baseline for latent-tree models.

Original: However, Gumbel-Tree models not only suffer from biased gradients (due to use of Straight-Through Estimation (STE)), but they also perform poorly on synthetic tasks like ListOps (Nangia & Bowman, 2018) that were specifically designed to diagnose the capacity of neural models for automatically inducing underlying hierarchical structures.
Revised: However, Gumbel-Tree models not only suffer from biased gradients (due to use of Straight-Through Estimation (STE)), but they also perform poorly on synthetic tasks like ListOps (Nangia & Bowman, 2018) that were specifically designed to diagnose the capacity of neural models for automatically inducing underlying hierarchical structures.

Original: In this paper, we tackle these issues by introducing the Beam Tree Cell (BT-Cell) framework that applies beam-search as a simple modification over Gumbel-Tree models.
Revised: In this paper, we tackle these issues by introducing the Beam Tree Cell (BT-Cell) framework that applies beam-search as a simple modification over Gumbel-Tree models.

Original: Instead of greedily selecting the highest scored sub-tree representations like Gumbel-Tree models, BT-Cell chooses and maintains top- k highest scored sub-tree representations.
Revised: Instead of greedily selecting the highest scored sub-tree representations like Gumbel-Tree models, BT-Cell chooses and maintains top- k highest scored sub-tree representations.

Original: We show that this simple modification increases the performance of Gumbel-Tree models in challenging structure sensitive tasks by several folds.
Revised: We show that this simple modification increases the performance of Gumbel-Tree models in challenging structure sensitive tasks by several folds.

Original: For example, in ListOps, when testing for samples of length 900 - 1000 , a BT-Cell based model increases the performance of a comparable Gumbel-Tree model from 37 .
Revised: For example, in ListOps, when testing for samples of length 900 - 1000 , a BT-Cell based model increases the performance of a comparable Gumbel-Tree model from 37 .

Original: 9% to 86 .
Revised: 9% to 86 .

Original: 7% (see: Table 1).
Revised: 7% (see: Table 1).

Original: We further explore several variants of BT-Cell.
Revised: We further explore several variants of BT-Cell.

Original: Particularly, we explore ways to replace the non-differentiable top-k operators involved in beam search with different alternatives such as top-k gumbel softmax with STE and a novel strategy of maintaining a convex combination of bottom scoring paths.
Revised: Particularly, we explore ways to replace the non-differentiable top-k operators involved in beam search with different alternatives such as top-k gumbel softmax with STE and a novel strategy of maintaining a convex combination of bottom scoring paths.

Original: Our best extension achieves a new state-of-the-art in length generalization and depth-generalization in structure-sensitive synthetic tasks like ListOps and performs comparably in realistic data against other latent-tree models.
Revised: Our best extension achieves a new state-of-the-art in length generalization and depth-generalization in structure-sensitive synthetic tasks like ListOps and performs comparably in realistic data against other latent-tree models.

Original: A few recently proposed latent-tree models simulating RvNNs
Revised: A few recently proposed latent-tree models simulating RvNNs

Original: like LSTM-RL (Havrylov et al., 2019), Ordered Memory (OM) (Shen et al., 2019a) or CRvNN (Chowdhury & Caragea, 2021) are also strong contenders to BT-Cell and its extensions on synthetic data.
Revised: like LSTM-RL (Havrylov et al., 2019), Ordered Memory (OM) (Shen et al., 2019a) or CRvNN (Chowdhury & Caragea, 2021) are also strong contenders to BT-Cell and its extensions on synthetic data.

Original: However, unlike BT-Cell,
Revised: However, unlike BT-Cell,

Original: LSTM-RL relies on expensive reinforcement learning and several sophisticated techniques to stabilize training.
Revised: LSTM-RL relies on expensive reinforcement learning and several sophisticated techniques to stabilize training.

Original: Moreover, compared to OM and CRvNN, one distinct advantage of BT-Cell is that it not just provides the final sequence encoding (representing the whole input text) but also the intermediate constituent representations at different levels of hierarchy (representations of all nodes of the underlying induced trees).
Revised: Moreover, compared to OM and CRvNN, one distinct advantage of BT-Cell is that it not just provides the final sequence encoding (representing the whole input text) but also the intermediate constituent representations at different levels of hierarchy (representations of all nodes of the underlying induced trees).

Original: Such tree-structured node representations can be useful as inputs to further downstream modules like a Transformer (Vaswani et al., 2017) or GNN (Scarselli et al., 2009) in a full end-to-end setting 1 .
Revised: Such tree-structured node representations can be useful as inputs to further downstream modules like a Transformer (Vaswani et al., 2017) or GNN (Scarselli et al., 2009) in a full end-to-end setting 1 .

Original: While CYK-based RvNNs (Maillard et al., 2019) are also promising and similarly can provide multiple span representations they tend to be much more expensive than
Revised: While CYK-based RvNNs (Maillard et al., 2019) are also promising and similarly can provide multiple span representations they tend to be much more expensive than

Original: BT-Cell.
Revised: BT-Cell.

Original: All these architectural trade-offs among different latent-tree models are discussed in more details in Appendix E.6.
Revised: All these architectural trade-offs among different latent-tree models are discussed in more details in Appendix E.6.

Original: Besides proposal and evaluation of BT-Cell variants, our paper also serves as a survey of how well prior proposed latent-tree RvNNs work in structure-sensitive synthetic tasks and out-of-distributionsplits in natural language tasks, particularly when combined with more powerful recursive cells.
Revised: Besides proposal and evaluation of BT-Cell variants, our paper also serves as a survey of how well prior proposed latent-tree RvNNs work in structure-sensitive synthetic tasks and out-of-distributionsplits in natural language tasks, particularly when combined with more powerful recursive cells.

Original: Additionally, as a further contribution, we identify a previously unknown failure case for even the best performing neural models when it comes to argument generalization in ListOps (Nangia &
Revised: Additionally, as a further contribution, we identify a previously unknown failure case for even the best performing neural models when it comes to argument generalization in ListOps (Nangia &

Original: Bowman, 2018) - opening up a new challenge for future research.
Revised: Bowman, 2018) - opening up a new challenge for future research.

Original:  P RELIMINARIES
Revised:  P RELIMINARIES

Original: Problem Formulation: Similar to Choi et al.
Revised: Problem Formulation: Similar to Choi et al.

Original: (2018), throughout this paper, we explore the use of RvNNs as a sentence encoder.
Revised: (2018), throughout this paper, we explore the use of RvNNs as a sentence encoder.

Original: Formally, given a sequence of token embeddings X = ( e 1 , e 2 , . . .
Revised: Formally, given a sequence of token embeddings X = ( e 1 , e 2 , . . .

Original: , e n ) (where X ∈ IR n × d e , e i ∈ IR
Revised: , e n ) (where X ∈ IR n × d e , e i ∈ IR

Original: d e , and d e is the embedding size), the task of a sentence encoding function E :
Revised: d e , and d e is the embedding size), the task of a sentence encoding function E :

Original: IR n × d e → IR d h is to encode the whole sequence of vectors into a single vector o = E ( X ) (where o ∈ IR d h and d h is the size of the encoded vector).
Revised: IR n × d e → IR d h is to encode the whole sequence of vectors into a single vector o = E ( X ) (where o ∈ IR d h and d h is the size of the encoded vector).

Original: We can use a sentence encoder for sentence-pair comparison tasks like logical inference or for text classification.
Revised: We can use a sentence encoder for sentence-pair comparison tasks like logical inference or for text classification.

Original: 2. R ECCURENT N EURAL N ETWORKS AND R ECURSIVE N EURAL N ETWORKS
Revised: 2. R ECCURENT N EURAL N ETWORKS AND R ECURSIVE N EURAL N ETWORKS

Original: A core component of both RNNs and RvNNs is a recursive cell.
Revised: A core component of both RNNs and RvNNs is a recursive cell.

Original: In our contexts, the cell function takes as arguments two vectors ( a 1 ∈ IR
Revised: In our contexts, the cell function takes as arguments two vectors ( a 1 ∈ IR

Original: d a 1 and a 2 ∈ IR
Revised: d a 1 and a 2 ∈ IR

Original: d a 2 ) and returns a single vector v = cell ( a 1 , a 2 ) (where v ∈ IR d v ).
Revised: d a 2 ) and returns a single vector v = cell ( a 1 , a 2 ) (where v ∈ IR d v ).

Original: cell : IR d a 1 × IR d a 2 → IR d v .
Revised: cell : IR d a 1 × IR d a 2 → IR d v .

Original: In our settings, we generally set d a 1 = d
Revised: In our settings, we generally set d a 1 = d

Original: a 2 =
Revised: a 2 =

Original: d v = d h .
Revised: d v = d h .

Original: Given a sequence X , both RNNs and RvNNs sequentially process it through recursive application of the cell function.
Revised: Given a sequence X , both RNNs and RvNNs sequentially process it through recursive application of the cell function.

Original: For a concrete example, consider a sequence of token embeddings such as (2 + 4 × 4 + 3) (Assume the symbols 2 , 4 , + etc. represent transformations of corresponding embedding vectors ∈ d h ).
Revised: For a concrete example, consider a sequence of token embeddings such as (2 + 4 × 4 + 3) (Assume the symbols 2 , 4 , + etc. represent transformations of corresponding embedding vectors ∈ d h ).

Original: Given any such sequence, RNNs can only follow a fixed left-to-right order of composition.
Revised: Given any such sequence, RNNs can only follow a fixed left-to-right order of composition.

Original: For the particular aforementioned sequence, an RNN-like application of the cell function can be expressed as:
Revised: For the particular aforementioned sequence, an RNN-like application of the cell function can be expressed as:

Original: [Equation]
Revised: [Equation]

Original: ( cell ( cell (
Revised: ( cell ( cell (

Original: [Equation]
Revised: [Equation]

Original: [Equation] [Equation]
Revised: [Equation] [Equation]

Original: [Equation] [Equation]
Revised: [Equation] [Equation]

Original: Here h 0 is some input-independent initial state (“initial hidden state”) set in the model.
Revised: Here h 0 is some input-independent initial state (“initial hidden state”) set in the model.

Original: In contrast to RNNs, RvNNs can compose the sequence in more flexible orders.
Revised: In contrast to RNNs, RvNNs can compose the sequence in more flexible orders.

Original: For example, one way (among many) that RvNNs could apply the cell function is as follows:
Revised: For example, one way (among many) that RvNNs could apply the cell function is as follows:

Original: [Equation]
Revised: [Equation]

Original: Thus, RNNs can be considered as, roughly, a special case of RvNNs where a strict left-to-right order of composition is enforced.
Revised: Thus, RNNs can be considered as, roughly, a special case of RvNNs where a strict left-to-right order of composition is enforced.

Original: As we can see, by these strategies of recursively reducing two vectors into a single vector, both RNNs and RvNNs can implement the sentence encoding function in the form of E .
Revised: As we can see, by these strategies of recursively reducing two vectors into a single vector, both RNNs and RvNNs can implement the sentence encoding function in the form of E .

Original: Moreover, the form of application of cell function exhibited by RNNs and RvNNs can also be said to reflect a tree-structure.
Revised: Moreover, the form of application of cell function exhibited by RNNs and RvNNs can also be said to reflect a tree-structure.

Original: For any application of the cell function in the form v = cell ( a 1 , a 2 ) , v can be treated as the representation of the immediate parent node of child nodes a 1 and a 2 in a underlying tree.
Revised: For any application of the cell function in the form v = cell ( a 1 , a 2 ) , v can be treated as the representation of the immediate parent node of child nodes a 1 and a 2 in a underlying tree.

Original: In Eqn. 2, we find that RvNNs can align the order of composition to PEMDAS whereas RNNs cannot.
Revised: In Eqn. 2, we find that RvNNs can align the order of composition to PEMDAS whereas RNNs cannot.

Original: Nevertheless, RNNs can still learn to simulate RvNNs by modeling tree-structures implicitly in their hidden state dimensions (Bowman et al., 2015b).
Revised: Nevertheless, RNNs can still learn to simulate RvNNs by modeling tree-structures implicitly in their hidden state dimensions (Bowman et al., 2015b).

Original: For example, RNNs can learn to hold off the information related to “ 2+ ” until “ 4 × 4 ” is processed.
Revised: For example, RNNs can learn to hold off the information related to “ 2+ ” until “ 4 × 4 ” is processed.

Original: Their abilities to handle tree-structures is analogous to how we can use pushdown automation in a recurrent manner through an infinite stack to detect tree-structured grammar.
Revised: Their abilities to handle tree-structures is analogous to how we can use pushdown automation in a recurrent manner through an infinite stack to detect tree-structured grammar.

Original: Still, RNNs can struggle to effectively learn to appropriately organize information in practice for large sequences.
Revised: Still, RNNs can struggle to effectively learn to appropriately organize information in practice for large sequences.

Original: Special inductive biases can be incorporated to enhance their abilities to handle their internal memory structures (Shen et al., 2019b;a).
Revised: Special inductive biases can be incorporated to enhance their abilities to handle their internal memory structures (Shen et al., 2019b;a).

Original: However, even then, memories remain bounded in practice and there is a limit to what depth of nested structures they can model.
Revised: However, even then, memories remain bounded in practice and there is a limit to what depth of nested structures they can model.

Original: More direct approaches to RvNNs, in contrast, can alleviate the above problems and mitigate the need of sophisticated memory operations to arrange information corresponding to a tree-structure because they can directly compose according to the underlying structure (Eqn. 2).
Revised: More direct approaches to RvNNs, in contrast, can alleviate the above problems and mitigate the need of sophisticated memory operations to arrange information corresponding to a tree-structure because they can directly compose according to the underlying structure (Eqn. 2).

Original: However, in the case of RvNNs, we have the problem of first determining the underlying structure to even start composition.
Revised: However, in the case of RvNNs, we have the problem of first determining the underlying structure to even start composition.

Original: One approach to handle the issue can be to train a separate parser to induce a tree structure from sequences using gold tree parses.
Revised: One approach to handle the issue can be to train a separate parser to induce a tree structure from sequences using gold tree parses.

Original: Then we can use the trained parser in RvNNs.
Revised: Then we can use the trained parser in RvNNs.

Original: However, this is not ideal.
Revised: However, this is not ideal.

Original: Not all tasks or languages would come with gold trees for training a parser and a parser trained in one domain may not translate well to another.
Revised: Not all tasks or languages would come with gold trees for training a parser and a parser trained in one domain may not translate well to another.

Original: A potentially better approach is to jointly learn both the cell function and structure induction from a downstream objective.
Revised: A potentially better approach is to jointly learn both the cell function and structure induction from a downstream objective.

Original: We focus on this latter approach.
Revised: We focus on this latter approach.

Original: Below we discuss one framework for this approach.
Revised: Below we discuss one framework for this approach.

Original: 2. E ASY -F IRST P ARSING AND G UMBEL T REE M ODELS
Revised: 2. E ASY -F IRST P ARSING AND G UMBEL T REE M ODELS

Original: Here, we describe an adaptation (Choi et al., 2018) of easy-first parsing (Goldberg & Elhadad, 2010) for RvNN-based sentence-encoding.
Revised: Here, we describe an adaptation (Choi et al., 2018) of easy-first parsing (Goldberg & Elhadad, 2010) for RvNN-based sentence-encoding.

Original: The algorithm relies on a scorer function score : IR d h → IRthat scores parsing decisions.
Revised: The algorithm relies on a scorer function score : IR d h → IRthat scores parsing decisions.

Original: Particularly, if we have v = cell ( a 1 , a 2 ) , then score ( v ) represents the plausibility of a 1 and a 2 belonging to the same immediate parent constituent.
Revised: Particularly, if we have v = cell ( a 1 , a 2 ) , then score ( v ) represents the plausibility of a 1 and a 2 belonging to the same immediate parent constituent.

Original: In practice, similar to
Revised: In practice, similar to

Original: Choi et al.
Revised: Choi et al.

Original: , we keep the scorer as a simple linear transformation: score ( v ) =
Revised: , we keep the scorer as a simple linear transformation: score ( v ) =

Original: W v v (where
Revised: W v v (where

Original: W v ∈ IR 1 × d h and v ∈ IR d h ).
Revised: W v ∈ IR 1 × d h and v ∈ IR d h ).

Original: Recursive Loop: In this algorithm, at every iteration in a recursive loop, given a sequence of hidden states ( h 1 , h 2 , . .
Revised: Recursive Loop: In this algorithm, at every iteration in a recursive loop, given a sequence of hidden states ( h 1 , h 2 , . .

Original: , h n ) we consider all possible immediate candidate parent compositions taking the current states as children: ( cell ( h 1 , h 2 ) , cell ( h 2 , h 3 ) , . .
Revised: , h n ) we consider all possible immediate candidate parent compositions taking the current states as children: ( cell ( h 1 , h 2 ) , cell ( h 2 , h 3 ) , . .

Original: , cell ( h n − 1 , h n )) 2 .
Revised: , cell ( h n − 1 , h n )) 2 .

Original: We then score each of the candidates with the score function and greedily select the highest scoring candidate (i.e. we commit to the “easiest” decision first).
Revised: We then score each of the candidates with the score function and greedily select the highest scoring candidate (i.e. we commit to the “easiest” decision first).

Original: For the sake of illustration, assume score ( cell ( h i , h i +1 )) ≥ score ( cell ( h j , h j +1 )) ∀ j ∈ { 1 , 2 , . . . , n } .
Revised: For the sake of illustration, assume score ( cell ( h i , h i +1 )) ≥ score ( cell ( h j , h j +1 )) ∀ j ∈ { 1 , 2 , . . . , n } .

Original: Thus, following the algorithm the parent candidate cell ( h i , h i +1 ) can be chosen.
Revised: Thus, following the algorithm the parent candidate cell ( h i , h i +1 ) can be chosen.

Original: The parent representation cell ( h i , h i +1 ) would then replace its immediate children
Revised: The parent representation cell ( h i , h i +1 ) would then replace its immediate children

Original: h i and h
Revised: h i and h

Original: i +1 .
Revised: i +1 .

Original: Thus, the resulting sequence will become: ( h 1 , . . .
Revised: Thus, the resulting sequence will become: ( h 1 , . . .

Original: , h i − 1 , cell ( h i , h i +1 ) ,
Revised: , h i − 1 , cell ( h i , h i +1 ) ,

Original: h i +2 , . . .
Revised: h i +2 , . . .

Original: , h n ) .
Revised: , h n ) .

Original: Like this, the sequence will be iteratively reduced to a single element representing the final sentence encoding.
Revised: Like this, the sequence will be iteratively reduced to a single element representing the final sentence encoding.

Original: The full algorithm is presented in the
Revised: The full algorithm is presented in the

Original: Appendix (see Algorithm 1).
Revised: Appendix (see Algorithm 1).

Original: One issue here is how to choose the highest scoring candidate.
Revised: One issue here is how to choose the highest scoring candidate.

Original: One way to do it is to simply use an argmax operator but it will not be differentiable.
Revised: One way to do it is to simply use an argmax operator but it will not be differentiable.

Original: Gumbel-Tree-Cell models (Choi et al., 2018) address this difficulty by using Straight Through Estimation (STE) (Bengio et al., 2013) with
Revised: Gumbel-Tree-Cell models (Choi et al., 2018) address this difficulty by using Straight Through Estimation (STE) (Bengio et al., 2013) with

Original: Gumbel Softmax (Jang et al., 2017; Maddison et al., 2017) instead of argmax.
Revised: Gumbel Softmax (Jang et al., 2017; Maddison et al., 2017) instead of argmax.

Original: However, STE is known to cause high bias in gradient estimation.
Revised: However, STE is known to cause high bias in gradient estimation.

Original: Moreover, as it was previously discovered (Nangia & Bowman, 2018), and as we independently verify, STE Gumbel-based strategies perform poorly when tested in structure-sensitive tasks.
Revised: Moreover, as it was previously discovered (Nangia & Bowman, 2018), and as we independently verify, STE Gumbel-based strategies perform poorly when tested in structure-sensitive tasks.

Original: Instead, to overcome these issues, we present an alternative of extending argmax with a top-k operator under a beam search strategy.
Revised: Instead, to overcome these issues, we present an alternative of extending argmax with a top-k operator under a beam search strategy.

Original:  B EAM T REE C ELL
Revised:  B EAM T REE C ELL

Original: Motivation: Gumbel-Tree models, as described, are relatively fast and simple but they are fundamentally based on a greedy algorithm for a task where the greedy solution is not guaranteed to be optimal.
Revised: Motivation: Gumbel-Tree models, as described, are relatively fast and simple but they are fundamentally based on a greedy algorithm for a task where the greedy solution is not guaranteed to be optimal.

Original: On the other hand, adaptation of dynamic programming-based CYK-models (Maillard et al., 2019) leads to high computational complexity (discussed more in Appendix E.6).
Revised: On the other hand, adaptation of dynamic programming-based CYK-models (Maillard et al., 2019) leads to high computational complexity (discussed more in Appendix E.6).

Original: A“middle way” between the two extremes is then to simply extend Gumbel-Tree models with beam-search to make it less greedy while still being less costly than CYK-parsers (See Appendix E.6)).
Revised: A“middle way” between the two extremes is then to simply extend Gumbel-Tree models with beam-search to make it less greedy while still being less costly than CYK-parsers (See Appendix E.6)).

Original: Moreover, Using beam-search also provides additional opportunity to recover from local errors whereas a greedy single-path approach (like Gumbel Tree models) will be stuck with any errors made.
Revised: Moreover, Using beam-search also provides additional opportunity to recover from local errors whereas a greedy single-path approach (like Gumbel Tree models) will be stuck with any errors made.

Original: All these factors motivate the framework of Beam Tree Cells (BT-Cell).
Revised: All these factors motivate the framework of Beam Tree Cells (BT-Cell).

Original: Implementation: The beam search extension to Gumbel-Tree models is straight-forward and similar to standard beam search.
Revised: Implementation: The beam search extension to Gumbel-Tree models is straight-forward and similar to standard beam search.

Original: The method is described more precisely in Appendix A.1 and Algorithm 2.
Revised: The method is described more precisely in Appendix A.1 and Algorithm 2.

Original: In summary, in BT-Cell, given a beam size k , we maintain a maximum of k hypotheses (or beams) at each recursion.
Revised: In summary, in BT-Cell, given a beam size k , we maintain a maximum of k hypotheses (or beams) at each recursion.

Original: In any given iteration, each beam constitutes a sequence of hidden states representing a particular path of composition and an associated score for that beam based on the addition of log-softmaxed outputs of the score function (as defined in 2.2) over each chosen compositions for that sequence.
Revised: In any given iteration, each beam constitutes a sequence of hidden states representing a particular path of composition and an associated score for that beam based on the addition of log-softmaxed outputs of the score function (as defined in 2.2) over each chosen compositions for that sequence.

Original: At the end of the recursion, we will have k sentence encodings ( ( o 1 , o 2 , . . .
Revised: At the end of the recursion, we will have k sentence encodings ( ( o 1 , o 2 , . . .

Original: , o k ) where o i ∈ IR d h ) and their corresponding scores ( ( s 1 , s 2 , . . .
Revised: , o k ) where o i ∈ IR d h ) and their corresponding scores ( ( s 1 , s 2 , . . .

Original: , s k ) where s i ∈ IR 1 ).
Revised: , s k ) where s i ∈ IR 1 ).

Original: The final sequence encoding can be then represented as: (cid:80) ki
Revised: The final sequence encoding can be then represented as: (cid:80) ki

Original: =1 (cid:16) exp
Revised: =1 (cid:16) exp

Original: ( s i ) · o i (cid:80) ki
Revised: ( s i ) · o i (cid:80) ki

Original: =1 exp ( s i ) (cid:17) .
Revised: =1 exp ( s i ) (cid:17) .

Original: This aims at computing the expectation over the k sequence encodings.
Revised: This aims at computing the expectation over the k sequence encodings.

Original: 3. T OP K V ARIANTS
Revised: 3. T OP K V ARIANTS

Original: As in standard beam search, BT-Cell requires two top-k operators.
Revised: As in standard beam search, BT-Cell requires two top-k operators.

Original: The first top-k replaces the straight-through gumbel softmax (simulating top-1) in Gumbel-Tree models.
Revised: The first top-k replaces the straight-through gumbel softmax (simulating top-1) in Gumbel-Tree models.

Original: However, selecting and maintaining k possible choices for every beams in every iteration leads to an exponential increase in the number of total beams.
Revised: However, selecting and maintaining k possible choices for every beams in every iteration leads to an exponential increase in the number of total beams.

Original: Thus, a second top-k operator is used for pruning the beams to maintain only a maximum of k beams at the end of each iteration.
Revised: Thus, a second top-k operator is used for pruning the beams to maintain only a maximum of k beams at the end of each iteration.

Original: Now, different variants of BT-Cell can be established depending on what kind of top-k operator we use.
Revised: Now, different variants of BT-Cell can be established depending on what kind of top-k operator we use.

Original: Plain Top-k: The simplest variant is to simply use the vanilla top-k operator.
Revised: Plain Top-k: The simplest variant is to simply use the vanilla top-k operator.

Original: However, the vanilla top-k operator is discrete and non-differentiable preventing gradient propagation to non-selected paths.
Revised: However, the vanilla top-k operator is discrete and non-differentiable preventing gradient propagation to non-selected paths.

Original: Despite that this can still work for the following reasons: (1) Gradients can still pass through the final top k beams and scores.
Revised: Despite that this can still work for the following reasons: (1) Gradients can still pass through the final top k beams and scores.

Original: The scorer function can thus learn to increase the scores of better beams and lower the scores of the worse ones among the final k beams; (2) A rich enough cell function can be robust to local errors in the structure and learn to adjust for it by organizing information better in its hidden states.
Revised: The scorer function can thus learn to increase the scores of better beams and lower the scores of the worse ones among the final k beams; (2) A rich enough cell function can be robust to local errors in the structure and learn to adjust for it by organizing information better in its hidden states.

Original: We believe that as a combination of these two factors, plain BT-Cell even with non-differentiable top-k operators can learn to perform well for structure-sensitive tasks (as we will empirically observe).
Revised: We believe that as a combination of these two factors, plain BT-Cell even with non-differentiable top-k operators can learn to perform well for structure-sensitive tasks (as we will empirically observe).

Original: ST-Gumbel Top-k: While non-differentiable top-k operators can work, they still can be a bottleneck because gradient signals will be received only for k beams in a space of exponential possibilities.
Revised: ST-Gumbel Top-k: While non-differentiable top-k operators can work, they still can be a bottleneck because gradient signals will be received only for k beams in a space of exponential possibilities.

Original: To address this, we replace the plain top-k operator with a STE (Bengio et al., 2013) through Gumbel
Revised: To address this, we replace the plain top-k operator with a STE (Bengio et al., 2013) through Gumbel

Original: top-k
Revised: top-k

Original: (Kool et al., 2019).
Revised: (Kool et al., 2019).

Original: We refer to this operator as ST-Gumbel Top-k. This serves as a natural generalization of the original straight-through gumbel softmax from Choi et al.
Revised: We refer to this operator as ST-Gumbel Top-k. This serves as a natural generalization of the original straight-through gumbel softmax from Choi et al.

Original: (2018) (where we had to select only one item) to the top-k context 3 .
Revised: (2018) (where we had to select only one item) to the top-k context 3 .

Original: However, ST-Gumbel Top-K can exacerbate the original issues of biased estimation related to straight-through methods (we discuss more in
Revised: However, ST-Gumbel Top-K can exacerbate the original issues of biased estimation related to straight-through methods (we discuss more in

Original: Appendix D).
Revised: Appendix D).

Original: Softpath Top-k: Here, we focus on the second top-k operator that is involved in truncating beams.
Revised: Softpath Top-k: Here, we focus on the second top-k operator that is involved in truncating beams.

Original: As a concrete case, assume we have m beams (sequences and their corresponding scores).
Revised: As a concrete case, assume we have m beams (sequences and their corresponding scores).

Original: The target for a top-k operator is to keep only the top scoring k beams (where k ≤ m ).
Revised: The target for a top-k operator is to keep only the top scoring k beams (where k ≤ m ).

Original: Ideally we want to keep the beam representations “sharp” and avoid washed out representations owing to interpolation (weighted vector averaging) of distinct paths (Drozdov et al., 2020).
Revised: Ideally we want to keep the beam representations “sharp” and avoid washed out representations owing to interpolation (weighted vector averaging) of distinct paths (Drozdov et al., 2020).

Original: This can be achieved by either plain top-k or ST-Gumbel top-k. However, the former prevents propagation of gradient signals through the bottom m − k beams, and the latter can exacerbate bias (see Appendix
Revised: This can be achieved by either plain top-k or ST-Gumbel top-k. However, the former prevents propagation of gradient signals through the bottom m − k beams, and the latter can exacerbate bias (see Appendix

Original: D) as discussed before.
Revised: D) as discussed before.

Original: Another line of approach is to create a soft permutation matrix P ∈
Revised: Another line of approach is to create a soft permutation matrix P ∈

Original: IR m × m through a differentiable sorting algorithm such that P ij represents the probability of the i th beam being the j th highest scoring beam.
Revised: IR m × m through a differentiable sorting algorithm such that P ij represents the probability of the i th beam being the j th highest scoring beam.

Original: P can then be used to soflty select the top k beams.
Revised: P can then be used to soflty select the top k beams.

Original: However, running differentiable sorting in a recursive loop can significantly increase computation overheads and also create more “washed out” representations leading to higher error accumulation (we discuss more in Appendix E.1).
Revised: However, running differentiable sorting in a recursive loop can significantly increase computation overheads and also create more “washed out” representations leading to higher error accumulation (we discuss more in Appendix E.1).

Original: We tackle all these challenges by instead proposing a simple hybrid strategy to approach top-k selection.
Revised: We tackle all these challenges by instead proposing a simple hybrid strategy to approach top-k selection.

Original: We provide a formal description of our proposed strategy below and a visualization of the process in Figure 1.
Revised: We provide a formal description of our proposed strategy below and a visualization of the process in Figure 1.

Original: Assume we have m beams consisting of m sequences:
Revised: Assume we have m beams consisting of m sequences:

Original: H =
Revised: H =

Original: ( H 1 , . .
Revised: ( H 1 , . .

Original: , H m ) ( H i ∈ IR n × d h and n being the sequence length) and m corresponding scores: S =
Revised: , H m ) ( H i ∈ IR n × d h and n being the sequence length) and m corresponding scores: S =

Original: ( s 1 , . . .
Revised: ( s 1 , . . .

Original: , s m ) .
Revised: , s m ) .

Original: First, we simply use the plain top-k operator to discretely select the top k − 1 beams (instead of k ).
Revised: First, we simply use the plain top-k operator to discretely select the top k − 1 beams (instead of k ).

Original: This allows us to keep the most promising beams “sharp”:
Revised: This allows us to keep the most promising beams “sharp”:

Original: [Equation]
Revised: [Equation]

Original: Second, for the k th beam we instead perform a softmax-based marginalization of the bottom m − ( k − 1) beams.
Revised: Second, for the k th beam we instead perform a softmax-based marginalization of the bottom m − ( k − 1) beams.

Original: This allows us to still propagate gradients through the bottom scoring beams (unlike in the pure plain top-k operator):
Revised: This allows us to still propagate gradients through the bottom scoring beams (unlike in the pure plain top-k operator):

Original: [Equation]
Revised: [Equation]

Original: Finally we add the softpath to the top k − 1 discretely selected beams to get the final set of k beams:
Revised: Finally we add the softpath to the top k − 1 discretely selected beams to get the final set of k beams:

Original: Top ∪ { softpath } .
Revised: Top ∪ { softpath } .

Original: Thus, we get to achieve a “middle way” between plain top-k and differentiable sorting: partially getting the benefit of sharp representations of the former through discrete top k −selection, and partially getting the benefit of gradient propagation of the latter through soft-selection of the k th beam.
Revised: Thus, we get to achieve a “middle way” between plain top-k and differentiable sorting: partially getting the benefit of sharp representations of the former through discrete top k −selection, and partially getting the benefit of gradient propagation of the latter through soft-selection of the k th beam.

Original: In practice, we find it beneficial to switch to plain top-k during inference.
Revised: In practice, we find it beneficial to switch to plain top-k during inference.

Original: Gumbelpath Top-k: Here, we replace the softmax in the softpath extension (eqn 5) with a straightthrough gumbel softmax making the induced structure discrete during training as well.
Revised: Gumbelpath Top-k: Here, we replace the softmax in the softpath extension (eqn 5) with a straightthrough gumbel softmax making the induced structure discrete during training as well.

Original:  E XPERIMENTS AND R ESULTS
Revised:  E XPERIMENTS AND R ESULTS

Original: Hyperparameters and other architectural details are in the Appendix H. Next, we discuss the main models that we compare.
Revised: Hyperparameters and other architectural details are in the Appendix H. Next, we discuss the main models that we compare.

Original: RecurrentGRC: RecurrentGRC is an RNN implemented with the Gated Recursive Cell (GRC) (Shen et al., 2019a) as the cell function (see Appendix B for description of GRC).
Revised: RecurrentGRC: RecurrentGRC is an RNN implemented with the Gated Recursive Cell (GRC) (Shen et al., 2019a) as the cell function (see Appendix B for description of GRC).

Original: RandomTreeGRC:
Revised: RandomTreeGRC:

Original: RandomTreeGRC is an RvNN with GRC that randomly chooses parent compositions at each iteration (based on uniform probabilities).
Revised: RandomTreeGRC is an RvNN with GRC that randomly chooses parent compositions at each iteration (based on uniform probabilities).

Original: BalancedTreeGRC: BalancedTreeGRC is an RvNN with GRC that enforces a binary balanced tree structure.
Revised: BalancedTreeGRC: BalancedTreeGRC is an RvNN with GRC that enforces a binary balanced tree structure.

Original: Some prior experiments (Shi et al., 2018) have shown strong results just by using balanced trees like this.
Revised: Some prior experiments (Shi et al., 2018) have shown strong results just by using balanced trees like this.

Original: GoldTreeGRC:
Revised: GoldTreeGRC:

Original: GoldTreeGRC is a GRC-based RvNN with gold tree structures.
Revised: GoldTreeGRC is a GRC-based RvNN with gold tree structures.

Original: GumbelTreeLSTM: This is the straight-through Gumbel-tree implementation by Choi et al.
Revised: GumbelTreeLSTM: This is the straight-through Gumbel-tree implementation by Choi et al.

Original: It uses the LSTM cell (Hochreiter & Schmidhuber, 1997; Tai et al., 2015).
Revised: It uses the LSTM cell (Hochreiter & Schmidhuber, 1997; Tai et al., 2015).

Original: GumbelTreeGRC:
Revised: GumbelTreeGRC:

Original: This is same as GumbelTreeLSTM
Revised: This is same as GumbelTreeLSTM

Original: but with GRC instead of LSTM.
Revised: but with GRC instead of LSTM.

Original: BSRP-GRC: Maillard & Clark (2018) proposed a similar approach to ours where they apply beam search into a shift-reduce parsing framework instead of easy-first-parsing.
Revised: BSRP-GRC: Maillard & Clark (2018) proposed a similar approach to ours where they apply beam search into a shift-reduce parsing framework instead of easy-first-parsing.

Original: We adapt that framework with the GRC cell and call it as BSRP-GRC.
Revised: We adapt that framework with the GRC cell and call it as BSRP-GRC.

Original: More details are provided in Appendix C. 8.
Revised: More details are provided in Appendix C. 8.

Original: CYK-GRC:
Revised: CYK-GRC:

Original: This is the CYK-based model proposed by Maillard et al.
Revised: This is the CYK-based model proposed by Maillard et al.

Original: (2019) but with GRC.
Revised: (2019) but with GRC.

Original: Ordered Memory:
Revised: Ordered Memory:

Original: This is a form of memory-augmented RNN simulating certain classes of RvNN functions as proposed by (Shen et al., 2019a).
Revised: This is a form of memory-augmented RNN simulating certain classes of RvNN functions as proposed by (Shen et al., 2019a).

Original: Ordered Memory also uses GRC.
Revised: Ordered Memory also uses GRC.

Original: CRvNN: CRvNN is a variant of RvNN with a continuoux relaxation over its structural operations as proposed by Chowdhury & Caragea (2021).
Revised: CRvNN: CRvNN is a variant of RvNN with a continuoux relaxation over its structural operations as proposed by Chowdhury & Caragea (2021).

Original: CRvNN also uses GRC.
Revised: CRvNN also uses GRC.

Original: In our implementation, we ignore some extraneous elements from CRvNN such as transition features and halt penalty which were deemed to have little effect during ablation.
Revised: In our implementation, we ignore some extraneous elements from CRvNN such as transition features and halt penalty which were deemed to have little effect during ablation.

Original: BT-LSTM: Base BT-Cell model with LSTM cell and plain top-k operator.
Revised: BT-LSTM: Base BT-Cell model with LSTM cell and plain top-k operator.

Original: BT-GRC: Base BT-Cell model with GRC and plain top-k operator.
Revised: BT-GRC: Base BT-Cell model with GRC and plain top-k operator.

Original: Gumbel BT-GRC: BT-Cell model with GRC and ST-Gumbel top-k operator.
Revised: Gumbel BT-GRC: BT-Cell model with GRC and ST-Gumbel top-k operator.

Original: BT-GRC + Softpath: BT-Cell model with GRC and Softpath top-k operator.
Revised: BT-GRC + Softpath: BT-Cell model with GRC and Softpath top-k operator.

Original: BT-GRC + Gumbelpath: BT-Cell model with GRC and Gumbelpath top-k operator.
Revised: BT-GRC + Gumbelpath: BT-Cell model with GRC and Gumbelpath top-k operator.

Original: For experiments with BT-Cell models, we consider beam size 5 as a practical choice which is neither too big nor too small.
Revised: For experiments with BT-Cell models, we consider beam size 5 as a practical choice which is neither too big nor too small.

Original: However, we also explore beam size 2 for the most promising variants of BTCell to see how far we can get with the minimally costly version of beam search.
Revised: However, we also explore beam size 2 for the most promising variants of BTCell to see how far we can get with the minimally costly version of beam search.

Original: 4. L IST O PS L ENGTH G ENERALIZATION R ESULTS
Revised: 4. L IST O PS L ENGTH G ENERALIZATION R ESULTS

Original: Dataset Settings: ListOps Nangia & Bowman (2018) is a challenging synthetic task that requires solving of nested mathematical operations over lists of arguments.
Revised: Dataset Settings: ListOps Nangia & Bowman (2018) is a challenging synthetic task that requires solving of nested mathematical operations over lists of arguments.

Original: We present our results on ListOps in Table 1.
Revised: We present our results on ListOps in Table 1.

Original: To test for length-generalization performance, we train the models only on sequences with ≤ 100 lengths (we filter the rest) and test on splits of much larger lengths (eg. 200 − 300 or 900 − 1000 ) taken from Havrylov et al.
Revised: To test for length-generalization performance, we train the models only on sequences with ≤ 100 lengths (we filter the rest) and test on splits of much larger lengths (eg. 200 − 300 or 900 − 1000 ) taken from Havrylov et al.

Original: “Near-IID” is the original test set of ListOps (it is “near” IID and not fully IID because a percentage of the split has > 100 length sequences whereas such lengths are absent in the training split).
Revised: “Near-IID” is the original test set of ListOps (it is “near” IID and not fully IID because a percentage of the split has > 100 length sequences whereas such lengths are absent in the training split).

Original: Results: 1.
Revised: Results: 1.

Original: Heuristic Tree Models: As discussed before in § 2.1, RNNs has to model tree structures implicitly in their bounded hidden states and thus can struggle generalizing to unseen structural depths.
Revised: Heuristic Tree Models: As discussed before in § 2.1, RNNs has to model tree structures implicitly in their bounded hidden states and thus can struggle generalizing to unseen structural depths.

Original: This is reflected in the sharp degradation in its length generalization performance.
Revised: This is reflected in the sharp degradation in its length generalization performance.

Original: Unsurprisingly, other heuristic-tree-based models (BalancedTreeGRC or RandomTreeGRC) do not perform well either in this structure-sensitive task.
Revised: Unsurprisingly, other heuristic-tree-based models (BalancedTreeGRC or RandomTreeGRC) do not perform well either in this structure-sensitive task.

Original: Gumbel Tree Models: Consistent with prior work Nangia & Bowman (2018), Gumbel-Tree models fail to perform well in this task; likely, due to its biased gradient estimation.
Revised: Gumbel Tree Models: Consistent with prior work Nangia & Bowman (2018), Gumbel-Tree models fail to perform well in this task; likely, due to its biased gradient estimation.

Original: CYK-GRC: CYK-GRC shows some promise to length generalization but it was too slow to run in higher lengths (see discussion in Appendix E.6).
Revised: CYK-GRC: CYK-GRC shows some promise to length generalization but it was too slow to run in higher lengths (see discussion in Appendix E.6).

Original: Ordered
Revised: Ordered

Original: Memory (OM):
Revised: Memory (OM):

Original: Here, we find OM struggles to generalize to higher unseen lengths.
Revised: Here, we find OM struggles to generalize to higher unseen lengths.

Original: OM’s reliance of soft sequential updates in a nested loop can lead to higher error accumulation over larger unseen lengths or depth.
Revised: OM’s reliance of soft sequential updates in a nested loop can lead to higher error accumulation over larger unseen lengths or depth.

Original: CRvNN: Consistent with Chowdhury & Caragea (2021), CRvNN performs
Revised: CRvNN: Consistent with Chowdhury & Caragea (2021), CRvNN performs

Original: [Table]
Revised: [Table]

Original: For our models we report the median of 3 runs.
Revised: For our models we report the median of 3 runs.

Original: Our models were trained on lengths ≤ 100, depth ≤ 20, and arguments ≤ 5.
Revised: Our models were trained on lengths ≤ 100, depth ≤ 20, and arguments ≤ 5.

Original: We bold the best results and underline the second models do not use gold trees.
Revised: We bold the best results and underline the second models do not use gold trees.

Original: Subscript represents standard deviation.
Revised: Subscript represents standard deviation.

Original: As an example, 90 1 = 90 ± 0 .. relatively decently at higher lengths. 6.
Revised: As an example, 90 1 = 90 ± 0 .. relatively decently at higher lengths. 6.

Original: BSRPC-GRC:
Revised: BSRPC-GRC:

Original: Surprisingly, despite using a similar framework to BT-Cell, BSRPC-GRC performs quite poorly.
Revised: Surprisingly, despite using a similar framework to BT-Cell, BSRPC-GRC performs quite poorly.

Original: We suspect this is because of the limited gradient signals from its top-k operators coupled with the doubling of recurrent steps (that can cause gradient issues) due to taking a shift-reduce strategy.
Revised: We suspect this is because of the limited gradient signals from its top-k operators coupled with the doubling of recurrent steps (that can cause gradient issues) due to taking a shift-reduce strategy.

Original: Moreover, BSRPC-GRC.
Revised: Moreover, BSRPC-GRC.

Original: unlike BT-Cell, also lacks the global competition among all parent compositions when making shift/reduce choices.
Revised: unlike BT-Cell, also lacks the global competition among all parent compositions when making shift/reduce choices.

Original: BT-GRC and BT-LSTM:
Revised: BT-GRC and BT-LSTM:

Original: Here, we find a massive boost over Gumbel-tree baselines even when using the base models: BT-GRC or BT-LSTM (beam size 5 ).
Revised: Here, we find a massive boost over Gumbel-tree baselines even when using the base models: BT-GRC or BT-LSTM (beam size 5 ).

Original: In the 900 - 1000 length generalization split, BT-GRC increases the performance of GumbelTreeGRC from 37 .
Revised: In the 900 - 1000 length generalization split, BT-GRC increases the performance of GumbelTreeGRC from 37 .

Original: 9% to 86 .
Revised: 9% to 86 .

Original: 7% - all just by adding beam search with plain top-k.
Revised: 7% - all just by adding beam search with plain top-k.

Original: But as expected, the performance degrades severely when the beam size is reduced to 2 .
Revised: But as expected, the performance degrades severely when the beam size is reduced to 2 .

Original: Note that the recurrent depth for BT-Cell as it pertains to backpropagation is just the tree depth (not the doubled sequence length as in BSRP-GRC).
Revised: Note that the recurrent depth for BT-Cell as it pertains to backpropagation is just the tree depth (not the doubled sequence length as in BSRP-GRC).

Original: This may further explain its superiority to BSRP-GRC. 8.
Revised: This may further explain its superiority to BSRP-GRC. 8.

Original: Gumbel BT-GRC:
Revised: Gumbel BT-GRC:

Original: This model does not perform as good.
Revised: This model does not perform as good.

Original: Part of its issue could be related to, again, the biased estimation due to STE.
Revised: Part of its issue could be related to, again, the biased estimation due to STE.

Original: We also discuss more specific issues that applies to this model but not Gumbelpath in Appendix D. 9.
Revised: We also discuss more specific issues that applies to this model but not Gumbelpath in Appendix D. 9.

Original: Softpath and Gumbelpath:
Revised: Softpath and Gumbelpath:

Original: Softpath was specifically designed to counteract the bottleneck of gradient propagation being limited through only k beams in the base BT-Cell (with plain top-k).
Revised: Softpath was specifically designed to counteract the bottleneck of gradient propagation being limited through only k beams in the base BT-Cell (with plain top-k).

Original: The bottleneck is even worse when k (beam size) is 2 - empirically this is reflected in the poor performance of base BT-GRC with beam size 2 .
Revised: The bottleneck is even worse when k (beam size) is 2 - empirically this is reflected in the poor performance of base BT-GRC with beam size 2 .

Original: However, Softpath does what it’s designed to: it counteracts the bottleneck.
Revised: However, Softpath does what it’s designed to: it counteracts the bottleneck.

Original: Empirically, this is reflected in its much higher performance than base BT-GRC under beam size 2 .
Revised: Empirically, this is reflected in its much higher performance than base BT-GRC under beam size 2 .

Original: Where base
Revised: Where base

Original: BT-GRC gets only 50 .
Revised: BT-GRC gets only 50 .

Original: 2% in the 900 − 1000 split, BT-GRC+Softpath gets 91% .
Revised: 2% in the 900 − 1000 split, BT-GRC+Softpath gets 91% .

Original: BT-GRC+Softpath has near perfect length generalization with beam size 5 .
Revised: BT-GRC+Softpath has near perfect length generalization with beam size 5 .

Original: The performance of Gumbelpath is more
Revised: The performance of Gumbelpath is more

Original: [Table] [Table]
Revised: [Table] [Table]

Original: mysterious.
Revised: mysterious.

Original: While it struggles on lower beam, it is on par with Softpath with beam size 5 .
Revised: While it struggles on lower beam, it is on par with Softpath with beam size 5 .

Original: It appears higher beam size is necessary to unlock the potential of Gumbelpath.
Revised: It appears higher beam size is necessary to unlock the potential of Gumbelpath.

Original: 4. L IST O PS A RGUMENT G ENERALIZATION R ESULTS
Revised: 4. L IST O PS A RGUMENT G ENERALIZATION R ESULTS

Original: Dataset Settings: While length generalization (Havrylov et al., 2019; Chowdhury & Caragea, 2021) and depth generalization (Csord ´ as et al., 2022) have been tested before for ListOps, the performance on argument generalization was yet to be considered.
Revised: Dataset Settings: While length generalization (Havrylov et al., 2019; Chowdhury & Caragea, 2021) and depth generalization (Csord ´ as et al., 2022) have been tested before for ListOps, the performance on argument generalization was yet to be considered.

Original: In this paper, we also consider what would happen if we increase the number of arguments in the test set beyond the maximum number encountered in the training set.
Revised: In this paper, we also consider what would happen if we increase the number of arguments in the test set beyond the maximum number encountered in the training set.

Original: The training set of the original listops data only has ≤ 5 arguments for each operator.
Revised: The training set of the original listops data only has ≤ 5 arguments for each operator.

Original: To test for argument generalization we created two new splits - one with 10 arguments per operator and another with 15 arguments per operator.
Revised: To test for argument generalization we created two new splits - one with 10 arguments per operator and another with 15 arguments per operator.

Original: In addition, we also consider the test set of ListOps from Long Range Arena (LRA) dataset (Tay et al., 2021) which serves as check for both length generalization (it has sequences of length 2000 ) and argument generalization (it has 10 arguments per operators) simultaneously.
Revised: In addition, we also consider the test set of ListOps from Long Range Arena (LRA) dataset (Tay et al., 2021) which serves as check for both length generalization (it has sequences of length 2000 ) and argument generalization (it has 10 arguments per operators) simultaneously.

Original: Results in Table 1.
Revised: Results in Table 1.

Original: Results: Interestingly, we find all the models perform poorly ( < 90% ) on argument generalization.
Revised: Results: Interestingly, we find all the models perform poorly ( < 90% ) on argument generalization.

Original: However, with the exception of Ordered Memory (OM), BT-cell models (discounting Gumbel-BTGRC) with higher beam size performs much better than any other models (including otherwise strong contenders like CRvNN).
Revised: However, with the exception of Ordered Memory (OM), BT-cell models (discounting Gumbel-BTGRC) with higher beam size performs much better than any other models (including otherwise strong contenders like CRvNN).

Original: Surprising, OM performs quite well in this split.
Revised: Surprising, OM performs quite well in this split.

Original: We do not know the exact reason, but we can eliminate some reasons.
Revised: We do not know the exact reason, but we can eliminate some reasons.

Original: First, we know OM is not performing better simply due to better parsing because it even surpasses GoldTreeGRC at times.
Revised: First, we know OM is not performing better simply due to better parsing because it even surpasses GoldTreeGRC at times.

Original: Second, we also know OM’s performance is not just due to a better recursive cell, since its cell (GRC) is shared by many other models that do not perform as well.
Revised: Second, we also know OM’s performance is not just due to a better recursive cell, since its cell (GRC) is shared by many other models that do not perform as well.

Original: This may suggest that the memory-augmented RNN style setup in OM is more amenable for argument generalization.
Revised: This may suggest that the memory-augmented RNN style setup in OM is more amenable for argument generalization.

Original: 4. S EMANTIC A NALYSIS (SST AND IMDB) R ESULTS
Revised: 4. S EMANTIC A NALYSIS (SST AND IMDB) R ESULTS

Original: Dataset Settings: SST (Socher et al., 2013) and IMDB (Maas et al., 2011) are natural language classification datasets.
Revised: Dataset Settings: SST (Socher et al., 2013) and IMDB (Maas et al., 2011) are natural language classification datasets.

Original: In the IID splits (standard split) of SST2 and SST5 all the models perform similarly.
Revised: In the IID splits (standard split) of SST2 and SST5 all the models perform similarly.

Original: To better check for OOD performance, we create a length-generalization (LG) split in
Revised: To better check for OOD performance, we create a length-generalization (LG) split in

Original: SST5 (we call this the LG split).
Revised: SST5 (we call this the LG split).

Original: Particularly, we only keep sequences of length ≤ 15 in the training set, we keep sequences of length ≤ 16 - 29 in the validation set, and we keep all sequences of length ≥ 30 in the test set.
Revised: Particularly, we only keep sequences of length ≤ 15 in the training set, we keep sequences of length ≤ 16 - 29 in the validation set, and we keep all sequences of length ≥ 30 in the test set.

Original: For IMDB, besides the IID test set, we also test our models on the contrast set from Gardner et al.
Revised: For IMDB, besides the IID test set, we also test our models on the contrast set from Gardner et al.

Original: and the counterfactual test set from Kaushik et al.
Revised: and the counterfactual test set from Kaushik et al.

Original: We present our results on these datasets in Table 2.
Revised: We present our results on these datasets in Table 2.

Original: Results: The results in this natural language tasks is rather mixed and do not provide clear consistent differences among these models.
Revised: Results: The results in this natural language tasks is rather mixed and do not provide clear consistent differences among these models.

Original: There are, however, some interesting highlights.
Revised: There are, however, some interesting highlights.

Original: Similar to
Revised: Similar to

Original: Shi et al.
Revised: Shi et al.

Original: (2018), we found BalancedTreeGRC can perform competitively in most test splits, however, it performs more poorly than others when it comes to length generalization (SST5 LG split).
Revised: (2018), we found BalancedTreeGRC can perform competitively in most test splits, however, it performs more poorly than others when it comes to length generalization (SST5 LG split).

Original: CRvNN and OM do particularly well in the OOD splits (contrast set and counterfactual split) of
Revised: CRvNN and OM do particularly well in the OOD splits (contrast set and counterfactual split) of

Original: IMDB, correlating with their better OOD generalization in synthetic data.
Revised: IMDB, correlating with their better OOD generalization in synthetic data.

Original: BT-GRC + Softpath is also relatively competitive in those splits and better than any other models besides CRvNN and OM.
Revised: BT-GRC + Softpath is also relatively competitive in those splits and better than any other models besides CRvNN and OM.

Original: STE Gumbel-based models tend to pareform particularly worse on IMDB.
Revised: STE Gumbel-based models tend to pareform particularly worse on IMDB.

Original:  A DDITIONAL E XPERIMENTS AND A NALYSIS
Revised:  A DDITIONAL E XPERIMENTS AND A NALYSIS

Original: Synthetic Logical Inference : We present our results on a challenging synthetic logical inference task (Bowman et al., 2015b) in Appendix E.4.
Revised: Synthetic Logical Inference : We present our results on a challenging synthetic logical inference task (Bowman et al., 2015b) in Appendix E.4.

Original: We find that most variants of BT-Cell can perform on par with prior SOTA models in this task.
Revised: We find that most variants of BT-Cell can perform on par with prior SOTA models in this task.

Original: ListOps Depth Generalization : We also run experiments to test depth-generalization performance on ListOps (see Appendix E.2)
Revised: ListOps Depth Generalization : We also run experiments to test depth-generalization performance on ListOps (see Appendix E.2)

Original: Transformers : We experiment briefly with Neural Data Routers (Csord´as et al., 2022) which is a Transformer-based model proven to do well in tasks like ListOps.
Revised: Transformers : We experiment briefly with Neural Data Routers (Csord´as et al., 2022) which is a Transformer-based model proven to do well in tasks like ListOps.

Original: However, we find that Neural
Revised: However, we find that Neural

Original: Data Routers (NDRs), despite their careful inductive biases, still struggle with sample efficiency and length generalization compared to strong RvNN-based models.
Revised: Data Routers (NDRs), despite their careful inductive biases, still struggle with sample efficiency and length generalization compared to strong RvNN-based models.

Original: We discuss more in Appendix E.3.
Revised: We discuss more in Appendix E.3.

Original: Natural Language Inference : We present our results MNLI along with some stress-test splits in
Revised: Natural Language Inference : We present our results MNLI along with some stress-test splits in

Original: Appendix E.5.
Revised: Appendix E.5.

Original: We find that BT-Cell variants can improve robustness to some stress test splits of
Revised: We find that BT-Cell variants can improve robustness to some stress test splits of

Original: MNLI compared to most other models.
Revised: MNLI compared to most other models.

Original: Parse Tree Analysis : We analyze parsed trees and score distributions in Appendix E.7.
Revised: Parse Tree Analysis : We analyze parsed trees and score distributions in Appendix E.7.

Original:  R ELATED W ORKS
Revised:  R ELATED W ORKS

Original: Goldberg & Elhadad (2010) proposed the easy-first algorithm for dependency parsing.
Revised: Goldberg & Elhadad (2010) proposed the easy-first algorithm for dependency parsing.

Original: Ma et al.
Revised: Ma et al.

Original: (2013) extended it with beam search for parsing tasks.
Revised: (2013) extended it with beam search for parsing tasks.

Original: Choi et al.
Revised: Choi et al.

Original: (2018) integrated easy-first-parsing with an RvNN.
Revised: (2018) integrated easy-first-parsing with an RvNN.

Original: Similar to us, Maillard & Clark (2018) used beam search to extend shift-reduce parsing whereas Drozdov et al.
Revised: Similar to us, Maillard & Clark (2018) used beam search to extend shift-reduce parsing whereas Drozdov et al.

Original: (2020) used beam search to extend CYK-based algorithms.
Revised: (2020) used beam search to extend CYK-based algorithms.

Original: However,
Revised: However,

Original: BT-Cell-based models achieve higher accuracy than the former style of models (eg. BSRP-GRC) and are computationally more efficient than the latter style of models (eg.
Revised: BT-Cell-based models achieve higher accuracy than the former style of models (eg. BSRP-GRC) and are computationally more efficient than the latter style of models (eg.

Original: CYK-GRC)
Revised: CYK-GRC)

Original: (see Appendix
Revised: (see Appendix

Original: E.6).
Revised: E.6).

Original: Similar to us, Collobert et al.
Revised: Similar to us, Collobert et al.

Original: (2019) also use beam search in an end-to-end fashion during training but in the context of sequence generation.
Revised: (2019) also use beam search in an end-to-end fashion during training but in the context of sequence generation.

Original: However, none of the above approaches explored beyond hard top-k operators in beam search.
Revised: However, none of the above approaches explored beyond hard top-k operators in beam search.

Original: One exception is Xie et al.
Revised: One exception is Xie et al.

Original: (2020) where a differentiable top-k operator is used in beam search for language generation (We compare against Xie et al.
Revised: (2020) where a differentiable top-k operator is used in beam search for language generation (We compare against Xie et al.

Original: (2020) in Appendix E.1).
Revised: (2020) in Appendix E.1).

Original: We provide an extended related works survey in Appendix F.
Revised: We provide an extended related works survey in Appendix F.

Original:  C ONCLUSION
Revised:  C ONCLUSION

Original: Overall, we find all three of Ordered Memory, CRvNN, and BT-Cell are competitive against each other; none being completely superior in all aspects.
Revised: Overall, we find all three of Ordered Memory, CRvNN, and BT-Cell are competitive against each other; none being completely superior in all aspects.

Original: BT-Cell with Softpath excels in length generalization at ListOps and offers moderate performance on argument generalization but hurts at systematicity (disccussed in Appendix E.4).
Revised: BT-Cell with Softpath excels in length generalization at ListOps and offers moderate performance on argument generalization but hurts at systematicity (disccussed in Appendix E.4).

Original: Ordered Memory excels in argument generalization while struggling in length generalization.
Revised: Ordered Memory excels in argument generalization while struggling in length generalization.

Original: CRvNN performs decently in length generalization but struggles in argument generalization.
Revised: CRvNN performs decently in length generalization but struggles in argument generalization.

Original: CYK-GRC shows some promise too but is several times more expensive (Appendix E.6) to run while having poor performance in systematicity (Appendix E.4) and argument generalization.
Revised: CYK-GRC shows some promise too but is several times more expensive (Appendix E.6) to run while having poor performance in systematicity (Appendix E.4) and argument generalization.

Original: We discuss future works in Appendix G.
Revised: We discuss future works in Appendix G.

Original: A P SEUDOCODES
Revised: A P SEUDOCODES

Original: We present the pseudocode of the easy first composition in Algorithm 1 and the pseudocode of BTcell in Algorithm 2.
Revised: We present the pseudocode of the easy first composition in Algorithm 1 and the pseudocode of BTcell in Algorithm 2.

Original: Note that the algorithms are written as they are for the sake of illustration: in practice, many of the nested loops are made parallel through batched operations in GPU.
Revised: Note that the algorithms are written as they are for the sake of illustration: in practice, many of the nested loops are made parallel through batched operations in GPU.

Original: A. B EAM T REE C ELL A LGORITHM
Revised: A. B EAM T REE C ELL A LGORITHM

Original: Here, we briefly describe the algorithm of BT-cell (Algorithm 2) in words.
Revised: Here, we briefly describe the algorithm of BT-cell (Algorithm 2) in words.

Original: In BT-Cell, instead of maintaining a single sequence per sample, we maintain some k (initially 1 ) number of sequences and their corresponding scores (initialized to 0 ).
Revised: In BT-Cell, instead of maintaining a single sequence per sample, we maintain some k (initially 1 ) number of sequences and their corresponding scores (initialized to 0 ).

Original: k is a hyperparameter defining the beam size.
Revised: k is a hyperparameter defining the beam size.

Original: Each sequence (henceforth, interchangeably referred to as “beam”) is a hypothesis representing a particular sequence of choices of parents.
Revised: Each sequence (henceforth, interchangeably referred to as “beam”) is a hypothesis representing a particular sequence of choices of parents.

Original: Thus, each beam represents a different path of composition (for visualization see Figure 1).
Revised: Thus, each beam represents a different path of composition (for visualization see Figure 1).

Original: At any moment the score represents the log-probability for its corresponding beam.
Revised: At any moment the score represents the log-probability for its corresponding beam.

Original: Now, we describe the steps in each iteration in the recursion of BT-Cell.
Revised: Now, we describe the steps in each iteration in the recursion of BT-Cell.

Original: Step 1: similar to gumbel-tree models, we create all candidate parent compositions for each of the k beams.
Revised: Step 1: similar to gumbel-tree models, we create all candidate parent compositions for each of the k beams.

Original: Step 2: we score the candidates with the score function (defined in § 2.2).
Revised: Step 2: we score the candidates with the score function (defined in § 2.2).

Original: Step 3: we choose top-k highest scoring candidates.
Revised: Step 3: we choose top-k highest scoring candidates.

Original: We treat the top-k choices as mutually exclusive.
Revised: We treat the top-k choices as mutually exclusive.

Original: Thus, each of the k beams encounters k branching choices, and are updated into k distinct beams (similar to before, the children are replaced by the chosen parent).
Revised: Thus, each of the k beams encounters k branching choices, and are updated into k distinct beams (similar to before, the children are replaced by the chosen parent).

Original: Thus, we get k × k beams.
Revised: Thus, we get k × k beams.

Original: Step 4: we update the beam scores.
Revised: Step 4: we update the beam scores.

Original: The sub-steps involved in the update are described next.
Revised: The sub-steps involved in the update are described next.

Original: Step 4.1: we apply a log-softmax to the scores of the latest candidates to put the scores into the log-probability space.
Revised: Step 4.1: we apply a log-softmax to the scores of the latest candidates to put the scores into the log-probability space.

Original: Step 4.2: we add the log-softmaxed scores of the latest chosen candidate to the existing beam score for the corresponding beam where the candidate is chosen.
Revised: Step 4.2: we add the log-softmaxed scores of the latest chosen candidate to the existing beam score for the corresponding beam where the candidate is chosen.

Original: As a result, we will have k × k beam scores.
Revised: As a result, we will have k × k beam scores.

Original: Step 5: we truncate the k × k beams and beam scores into k beams and their corresponding k scores to prevent exponential increase of the number of beams.
Revised: Step 5: we truncate the k × k beams and beam scores into k beams and their corresponding k scores to prevent exponential increase of the number of beams.

Original: For that, we again simply use a top-k operator to keep only the highest scored beams.
Revised: For that, we again simply use a top-k operator to keep only the highest scored beams.

Original: At the end of the recursion, instead of a single item representing the sequence-encoding, we will have k beams of items with their k scores.
Revised: At the end of the recursion, instead of a single item representing the sequence-encoding, we will have k beams of items with their k scores.

Original: At this point, to get a single item, we do a weighted summation with the softmaxed scores as the weights as described in § 3.
Revised: At this point, to get a single item, we do a weighted summation with the softmaxed scores as the weights as described in § 3.

Original: B G ATED R ECURSIVE C ELL (GRC)
Revised: B G ATED R ECURSIVE C ELL (GRC)

Original: The Gated Recursive Cell (GRC) was originally introduced by Shen et al.
Revised: The Gated Recursive Cell (GRC) was originally introduced by Shen et al.

Original: (2019a)
Revised: (2019a)

Original: drawing inspiration from the Transformer’s feed-forward networks.
Revised: drawing inspiration from the Transformer’s feed-forward networks.

Original: In our implementation, we use the same variant of GRC as was used in Chowdhury & Caragea (2021) where a GELU Hendrycks & Gimpel (2016)
Revised: In our implementation, we use the same variant of GRC as was used in Chowdhury & Caragea (2021) where a GELU Hendrycks & Gimpel (2016)

Original: Algorithm 2 Beam Tree
Revised: Algorithm 2 Beam Tree

Original: Input: data X =
Revised: Input: data X =

Original: [ x 1 , x 2 , ....
Revised: [ x 1 , x 2 , ....

Original: x n ] , k (beam size)
Revised: x n ] , k (beam size)

Original: BeamX ← [ X ]
Revised: BeamX ← [ X ]

Original: BeamScores ← [0] while True do if len ( BeamX [0]) =
Revised: BeamScores ← [0] while True do if len ( BeamX [0]) =

Original: = 1 then
Revised: = 1 then

Original: BeamX ← [ beam [0] for beam in BeamX ] break end if if len ( BeamX [0]) =
Revised: BeamX ← [ beam [0] for beam in BeamX ] break end if if len ( BeamX [0]) =

Original: = 2 then
Revised: = 2 then

Original: BeamX ← [ cell ( beam [0] , beam [1]) for beam in BeamX ] break end if
Revised: BeamX ← [ cell ( beam [0] , beam [1]) for beam in BeamX ] break end if

Original: NewBeamX ← []
Revised: NewBeamX ← []

Original: NewBeamScores ← [] for Beam , BeamScore in zip ( BeamX, BeamScores ) do
Revised: NewBeamScores ← [] for Beam , BeamScore in zip ( BeamX, BeamScores ) do

Original: Parents ← [ cell ( beam [ i ] , beam [ i + 1]) for i in range (0 , len ( beam ) − 1)]
Revised: Parents ← [ cell ( beam [ i ] , beam [ i + 1]) for i in range (0 , len ( beam ) − 1)]

Original: Scores ← log ◦ softmax ([ scorer ( parent ) for parent in Parents ])
Revised: Scores ← log ◦ softmax ([ scorer ( parent ) for parent in Parents ])

Original: Indices ← topk ( Scores, k ) for i in range ( K ) do newBeam ← deepcopy ( Beam ) newBeam [ Indices [ i ]] ← Parents [ Indices [ i ]]
Revised: Indices ← topk ( Scores, k ) for i in range ( K ) do newBeam ← deepcopy ( Beam ) newBeam [ Indices [ i ]] ← Parents [ Indices [ i ]]

Original: Delete newBeam [ Indices [ i ] + 1]
Revised: Delete newBeam [ Indices [ i ] + 1]

Original: NewBeamX.append ( newBeam ) newScore ← BeamScore + Scores [ indices [ i ]] newBeamScores.append ( newScore ) end for end for
Revised: NewBeamX.append ( newBeam ) newScore ← BeamScore + Scores [ indices [ i ]] newBeamScores.append ( newScore ) end for end for

Original: Indices ← topk ( newBeamScores, k )
Revised: Indices ← topk ( newBeamScores, k )

Original: BeamScores ← [ newBeamScores [ i ] for i in Indices ]
Revised: BeamScores ← [ newBeamScores [ i ] for i in Indices ]

Original: BeamX ← [ newBeamX [ i ] for i in Indices ] end while
Revised: BeamX ← [ newBeamX [ i ] for i in Indices ] end while

Original: BeamScores ← Softmax ( BeamScores )
Revised: BeamScores ← Softmax ( BeamScores )

Original: Return sum ([ score ∗ X for score, X in zip ( BeanScores, BeamX )]) activation function was used.
Revised: Return sum ([ score ∗ X for score, X in zip ( BeanScores, BeamX )]) activation function was used.

Original: We present the equations of GRC here: 
Revised: We present the equations of GRC here: 

Original: [Equation]
Revised: [Equation]

Original: GeLU (cid:18)
Revised: GeLU (cid:18)

Original: [Equation]
Revised: [Equation]

Original: Cell(cid:20) child left child right (cid:21) + b(cid:19) + b(6)
Revised: Cell(cid:20) child left child right (cid:21) + b(cid:19) + b(6)

Original: o
Revised: o

Original: i = LN
Revised: i = LN

Original: ( σ ( z i ) ⊙ child left + σ ( h i ) ⊙ child right + σ ( c i ) ⊙ u i ) (7) σ is sigmoid ; o i is the parent composition ∈
Revised: ( σ ( z i ) ⊙ child left + σ ( h i ) ⊙ child right + σ ( c i ) ⊙ u i ) (7) σ is sigmoid ; o i is the parent composition ∈

Original: IR d h × 1 ; child left , child right ∈ IR
Revised: IR d h × 1 ; child left , child right ∈ IR

Original: d h × 1 ; W cell∈
Revised: d h × 1 ; W cell∈

Original: IR d cell × 2 · d h ; b 1 ∈ IR d cell × 1 ; W 2 ∈ IR
Revised: IR d cell × 2 · d h ; b 1 ∈ IR d cell × 1 ; W 2 ∈ IR

Original: d h × d cell ; b 1 ∈ IR
Revised: d h × d cell ; b 1 ∈ IR

Original: d h × 1 .
Revised: d h × 1 .

Original: We use this same GRC function for any recursive model (including our implementation of Ordered Memory) that constitutes GRC.
Revised: We use this same GRC function for any recursive model (including our implementation of Ordered Memory) that constitutes GRC.

Original: C BSRP-GRC D ETAILS
Revised: C BSRP-GRC D ETAILS

Original: For the decisions about whether to shift or reduce, we use a scorer function similar to that used in
Revised: For the decisions about whether to shift or reduce, we use a scorer function similar to that used in

Original: Chowdhury & Caragea (2021).
Revised: Chowdhury & Caragea (2021).

Original: Where Chowdhury & Caragea (2021) use the decision function on concatenation of local hidden states (n-gram window), we use the decision function on the concatenation of last two items in the stack and the next item in the queue.
Revised: Where Chowdhury & Caragea (2021) use the decision function on concatenation of local hidden states (n-gram window), we use the decision function on the concatenation of last two items in the stack and the next item in the queue.

Original: The output is a scalar sigmoid activated logit score s .
Revised: The output is a scalar sigmoid activated logit score s .

Original: We then treat log ( s ) as the score for reducing in that step, and log (1 − s )
Revised: We then treat log ( s ) as the score for reducing in that step, and log (1 − s )

Original: [Table]
Revised: [Table]

Original: as the score for shifting in that step.
Revised: as the score for shifting in that step.

Original: The scores are manipulated appropriately for edge cases (when there are no next item to shift, or when there are no two items in the stack to reduce).
Revised: The scores are manipulated appropriately for edge cases (when there are no next item to shift, or when there are no two items in the stack to reduce).

Original: Besides that, we use the familiar beam search strategy over standard shift-reduce parsing.
Revised: Besides that, we use the familiar beam search strategy over standard shift-reduce parsing.

Original: Finally the beams of final states are merged through the weighted summation of the states based on the softmaxed scores of each beam similar to BT-Cell models as described in § 3.
Revised: Finally the beams of final states are merged through the weighted summation of the states based on the softmaxed scores of each beam similar to BT-Cell models as described in § 3.

Original: D ST-G UMBEL T OP - K I SSUES
Revised: D ST-G UMBEL T OP - K I SSUES

Original: Let us use the notation argmax k ( . ) to denote the function for selecting the index of the k th highest value element in a vector or a list.
Revised: Let us use the notation argmax k ( . ) to denote the function for selecting the index of the k th highest value element in a vector or a list.

Original: Let us say, we have s as a vector
Revised: Let us say, we have s as a vector

Original: such that s i represents the element at the i th dimension of s .
Revised: such that s i represents the element at the i th dimension of s .

Original: We can now, represent the standard straight-through gumbel softmax Choi et al.
Revised: We can now, represent the standard straight-through gumbel softmax Choi et al.

Original: (2018) as follows:
Revised: (2018) as follows:

Original: [Equation]
Revised: [Equation]

Original: Here G is the gumbel noise.
Revised: Here G is the gumbel noise.

Original: This strategy allows the forward propagation to have discrete one hot values (one hot ( argmax 1 ( p )) ) while backpropagation to propagate through the soft p .
Revised: This strategy allows the forward propagation to have discrete one hot values (one hot ( argmax 1 ( p )) ) while backpropagation to propagate through the soft p .

Original: However, this creates a discrepancy between forward propagation and backpropagation that leads to biased gradient estimation.
Revised: However, this creates a discrepancy between forward propagation and backpropagation that leads to biased gradient estimation.

Original: This problem can be exacerbated in ST-Gumbel Top-k. In this method, instead of top 1, top k items are selected from p .
Revised: This problem can be exacerbated in ST-Gumbel Top-k. In this method, instead of top 1, top k items are selected from p .

Original: The straight-through estimation involved in the selection of some r th item among the top k selections ( r ≤ k ) can be then expressed as:
Revised: The straight-through estimation involved in the selection of some r th item among the top k selections ( r ≤ k ) can be then expressed as:

Original: [Equation]
Revised: [Equation]

Original: Note that p argmax r ( p ) ≤ p argmax 1 ( p ) .
Revised: Note that p argmax r ( p ) ≤ p argmax 1 ( p ) .

Original: Thus the discrepancy between p and one hot ( argmax r ( p )) will only increase with increasing r .
Revised: Thus the discrepancy between p and one hot ( argmax r ( p )) will only increase with increasing r .

Original: Moreover while originally in ST-Gumbel, when selecting top-1, p i can be interpreted (in our context) as the probability that s i is “top-1” item.
Revised: Moreover while originally in ST-Gumbel, when selecting top-1, p i can be interpreted (in our context) as the probability that s i is “top-1” item.

Original: But in ST-Gumbel Topk, when selecting the top r th , item there is no corresponding interpretation - p i would still indicate probability for s i being the “top-1” item not the probability of s i being the “top r th ” item.
Revised: But in ST-Gumbel Topk, when selecting the top r th , item there is no corresponding interpretation - p i would still indicate probability for s i being the “top-1” item not the probability of s i being the “top r th ” item.

Original: Overall, we attempted ST-Gumbel Top-k more so because it’s a simple naive extension of plain top-k
Revised: Overall, we attempted ST-Gumbel Top-k more so because it’s a simple naive extension of plain top-k

Original: but it’s not a particularly principled approach.
Revised: but it’s not a particularly principled approach.

Original: As such, the poor performance is not that surprising.
Revised: As such, the poor performance is not that surprising.

Original: A possible extension could be to transform p to some p r for every top r th selection such that p r
Revised: A possible extension could be to transform p to some p r for every top r th selection such that p r

Original: i do reflect probability for s i to be top r th item but that would be non-trivial to do without adding significant overhead (similar to that caused by differentiable sorting - see Appendix E.6).
Revised: i do reflect probability for s i to be top r th item but that would be non-trivial to do without adding significant overhead (similar to that caused by differentiable sorting - see Appendix E.6).

Original: E A DDITIONAL E XPERIMENTS AND A NALYSIS E. D IFFERENTIABLE S ORTING
Revised: E A DDITIONAL E XPERIMENTS AND A NALYSIS E. D IFFERENTIABLE S ORTING

Original: Besides the three extensions considered for BT-Cell, another strategy can be to simply use differentiable versions of top-k operators or sorting functions (Adams & Zemel, 2011; Grover et al., 2019;
Revised: Besides the three extensions considered for BT-Cell, another strategy can be to simply use differentiable versions of top-k operators or sorting functions (Adams & Zemel, 2011; Grover et al., 2019;

Original: Cuturi et al., 2019; Xie et al., 2020; Blondel et al., 2020; Petersen et al., 2021; 2022).
Revised: Cuturi et al., 2019; Xie et al., 2020; Blondel et al., 2020; Petersen et al., 2021; 2022).

Original: However, as we discussed before these methods can lead to issues related to “washing out” of representations due to using soft permutation matrices leading to higher error accumulation (although temperature can be used to partially counteract that (Petersen et al., 2021)).
Revised: However, as we discussed before these methods can lead to issues related to “washing out” of representations due to using soft permutation matrices leading to higher error accumulation (although temperature can be used to partially counteract that (Petersen et al., 2021)).

Original: Besides that, using these techniques in a recursive loop can lead to significant overhead and added time complexity.
Revised: Besides that, using these techniques in a recursive loop can lead to significant overhead and added time complexity.

Original: Instead, in this paper, we mainly aim to show that a simple method, namely, softpath can already bring marked improvement compared to plain top-k especially in low beam size settings for listops.
Revised: Instead, in this paper, we mainly aim to show that a simple method, namely, softpath can already bring marked improvement compared to plain top-k especially in low beam size settings for listops.

Original: We keep a more exhaustive investigation of application of differentiable sorters for beam search as a future work.
Revised: We keep a more exhaustive investigation of application of differentiable sorters for beam search as a future work.

Original: Nevertheless,
Revised: Nevertheless,

Original: [Table]
Revised: [Table]

Original: the second-best among models that do not use gold trees.
Revised: the second-best among models that do not use gold trees.

Original: we present some preliminary results here.
Revised: we present some preliminary results here.

Original: Xie et al.
Revised: Xie et al.

Original: (2020) used an optimal transport-based differentiable top k method in beam decoding for machine translation.
Revised: (2020) used an optimal transport-based differentiable top k method in beam decoding for machine translation.

Original: Here, we use their method (SOFT
Revised: Here, we use their method (SOFT

Original: Top-k) and create a new variant of BT-GRC by replacing the softpath with SOFT Top-k. We call this new variant as BT-GRC + SOFT.
Revised: Top-k) and create a new variant of BT-GRC by replacing the softpath with SOFT Top-k. We call this new variant as BT-GRC + SOFT.

Original: We run this model in ListOps with the same dataset settings as used in Table 1.
Revised: We run this model in ListOps with the same dataset settings as used in Table 1.

Original: We report the results in Table 3.
Revised: We report the results in Table 3.

Original: As we can see in Table 3, BT-GRC+SOFT shows very poor performance.
Revised: As we can see in Table 3, BT-GRC+SOFT shows very poor performance.

Original: This supports our hypothesis that using soft permutation matrix in all recursive iterations may not be ideal because of increase chances of error accumulation and “washing out” through interpolations of what would be distinct path representations.
Revised: This supports our hypothesis that using soft permutation matrix in all recursive iterations may not be ideal because of increase chances of error accumulation and “washing out” through interpolations of what would be distinct path representations.

Original: In Appendix E.6, we also demonstrate that using SOFT significantly slows down BT-GRC.
Revised: In Appendix E.6, we also demonstrate that using SOFT significantly slows down BT-GRC.

Original: E. L IST O PS -DG E XPERIMENT
Revised: E. L IST O PS -DG E XPERIMENT

Original: Dataset Settings: The length generalization experiments in ListOps do not give us an exact perspective in depth generalization 4 capacities.
Revised: Dataset Settings: The length generalization experiments in ListOps do not give us an exact perspective in depth generalization 4 capacities.

Original: So there is a question of how models will perform in unseen depths.
Revised: So there is a question of how models will perform in unseen depths.

Original: To check for this, we create a new ListOps split which we call “ListOps-DG”.
Revised: To check for this, we create a new ListOps split which we call “ListOps-DG”.

Original: For this split, we create 100 , 000 training data with arguments ≤ 5 , lengths ≤ 100 , and depths ≤ 6 .
Revised: For this split, we create 100 , 000 training data with arguments ≤ 5 , lengths ≤ 100 , and depths ≤ 6 .

Original: We create 2000 development data with arguments ≤ 5 , lengths ≤ 100 , and depths 7 .
Revised: We create 2000 development data with arguments ≤ 5 , lengths ≤ 100 , and depths 7 .

Original: We createtest data with arguments ≤ 5 , lengths ≤ 100 , and depths 8 - 10 .
Revised: We createtest data with arguments ≤ 5 , lengths ≤ 100 , and depths 8 - 10 .

Original: In addition, we also still tested on the same length-generalization splits (which now simultaneously have much higher depths too: ≤ 20 ), argument generalization splits, and LRA.
Revised: In addition, we also still tested on the same length-generalization splits (which now simultaneously have much higher depths too: ≤ 20 ), argument generalization splits, and LRA.

Original: The results are presented in Table 4.
Revised: The results are presented in Table 4.

Original: We only evaluate the models that were promising ( ≥ 90% in near IID settings) in the original ListOps split.
Revised: We only evaluate the models that were promising ( ≥ 90% in near IID settings) in the original ListOps split.

Original: We report the median of 3 runs for each model (except in the last block of the table).
Revised: We report the median of 3 runs for each model (except in the last block of the table).

Original: Results: Interestingly, we find that base BT-GRC, CRvNN, and Ordered Memory now does much better in length generalization compared to the original listops split.
Revised: Results: Interestingly, we find that base BT-GRC, CRvNN, and Ordered Memory now does much better in length generalization compared to the original listops split.

Original: We think this is because of the increased data (the training data in the original ListOps is ∼ 75000 after filtering data of length > 100 whereas here we generated 100 , 000 training data).
Revised: We think this is because of the increased data (the training data in the original ListOps is ∼ 75000 after filtering data of length > 100 whereas here we generated 100 , 000 training data).

Original: However, while the median of 3 runs in
Revised: However, while the median of 3 runs in

Original: Ordered Memory is decent, we found one run to have very poor length generalization performance.
Revised: Ordered Memory is decent, we found one run to have very poor length generalization performance.

Original: To investigate more deeply if Ordered Memory has a particular stability issue, we ran Ordered
Revised: To investigate more deeply if Ordered Memory has a particular stability issue, we ran Ordered

Original: Memory for 10 times with diferent seeds, and we find that it frequently fails to learn to generalize over length.
Revised: Memory for 10 times with diferent seeds, and we find that it frequently fails to learn to generalize over length.

Original: As a baseline, we also ran BT-GRC similarly for 10 runs and found it to be much more stable.
Revised: As a baseline, we also ran BT-GRC similarly for 10 runs and found it to be much more stable.

Original: We report the mean and standard deviation of 10 runs of Ordered Memory and BT-GRC
Revised: We report the mean and standard deviation of 10 runs of Ordered Memory and BT-GRC

Original: [Table] [Table]
Revised: [Table] [Table]

Original: [Table] [Table]
Revised: [Table] [Table]

Original: in Table 5.
Revised: in Table 5.

Original: As can be seen, the mean of BT-GRC is much higher than that of Ordered Memory in length generalization splits.
Revised: As can be seen, the mean of BT-GRC is much higher than that of Ordered Memory in length generalization splits.

Original: E. NDR E XPERIMENTS
Revised: E. NDR E XPERIMENTS

Original: Dataset Settings: Neural Data Routers (NDR) is a Transformer-based model that was shown to perform well in algorithmic tasks including Listops (Csord ´ as et al., 2022).
Revised: Dataset Settings: Neural Data Routers (NDR) is a Transformer-based model that was shown to perform well in algorithmic tasks including Listops (Csord ´ as et al., 2022).

Original: We tried some experiments with it too.
Revised: We tried some experiments with it too.

Original: We found NDR to be struggling in the original ListOps splits or the ListOps-DG split.
Revised: We found NDR to be struggling in the original ListOps splits or the ListOps-DG split.

Original: We noticed that in the paper (Csord´as et al., 2022), NDR was trained in a much larger sample size ( ∼ 10 times more data than in ListOps-DG) and also on lower sequence lengths ( ∼ 50 ).
Revised: We noticed that in the paper (Csord´as et al., 2022), NDR was trained in a much larger sample size ( ∼ 10 times more data than in ListOps-DG) and also on lower sequence lengths ( ∼ 50 ).

Original: To better check for the capabilities of NDR, we created two new ListOps split - DG1 and DG2.
Revised: To better check for the capabilities of NDR, we created two new ListOps split - DG1 and DG2.

Original: In DG1, we set the sequence length to 10 - 50 in training, development
Revised: In DG1, we set the sequence length to 10 - 50 in training, development

Original: [Table]
Revised: [Table]

Original: and testing set.
Revised: and testing set.

Original: We created 1 million data for training, and 2000 data for development and testing.
Revised: We created 1 million data for training, and 2000 data for development and testing.

Original: Other parameters (number of arguments, depths etc.) are same as in ListOps-DG split.
Revised: Other parameters (number of arguments, depths etc.) are same as in ListOps-DG split.

Original: Split DG2 is the same as ListOps-DG split in terms of data-generation parameters (i.e it includes length sizes ≤ 100 ) but with much larger sample size for the training split (again, 1 million samples same as DG1).
Revised: Split DG2 is the same as ListOps-DG split in terms of data-generation parameters (i.e it includes length sizes ≤ 100 ) but with much larger sample size for the training split (again, 1 million samples same as DG1).

Original: We present the results in Table 6.
Revised: We present the results in Table 6.

Original: Results: We find that even when we focus on the best of 3 runs in the table, although NDR generalizes to slightly higher depths ( 8 - 10 from ≤ 6 ) (as reported in (Csord´as et al., 2022)), it still struggles with splits with orders of magnitude higher depths, lengths, and unseen arguments.
Revised: Results: We find that even when we focus on the best of 3 runs in the table, although NDR generalizes to slightly higher depths ( 8 - 10 from ≤ 6 ) (as reported in (Csord´as et al., 2022)), it still struggles with splits with orders of magnitude higher depths, lengths, and unseen arguments.

Original: Following the suggestions of Csord´as et al.
Revised: Following the suggestions of Csord´as et al.

Original: (2022), we also increase the number of layers during inference (eg. upto 48 ) to handle higher depth sequences but that did not help substantially.
Revised: (2022), we also increase the number of layers during inference (eg. upto 48 ) to handle higher depth sequences but that did not help substantially.

Original: Thus, even after experiencing more data, NDR generalizes worse than Ordered Memory, CRvNN, or BT-GRC.
Revised: Thus, even after experiencing more data, NDR generalizes worse than Ordered Memory, CRvNN, or BT-GRC.

Original: Moreover,
Revised: Moreover,

Original: NDR requires some prior estimation of the true computation depth of the task for its hyperparameter setup unlike the other latent-tree models.
Revised: NDR requires some prior estimation of the true computation depth of the task for its hyperparameter setup unlike the other latent-tree models.

Original: [Table]
Revised: [Table]

Original: different seeds.
Revised: different seeds.

Original: Subscript represents standard deviation.
Revised: Subscript represents standard deviation.

Original: As an example, 90 1 = 90 ± 0 ..
Revised: As an example, 90 1 = 90 ± 0 ..

Original: E. S YNTHETIC L OGICAL I NFERENCE R ESULTS
Revised: E. S YNTHETIC L OGICAL I NFERENCE R ESULTS

Original: Dataset Settings: We also consider the synthetic testbed for detecting logical relations between sequence pairs as provided by Bowman et al.
Revised: Dataset Settings: We also consider the synthetic testbed for detecting logical relations between sequence pairs as provided by Bowman et al.

Original: (2015b).
Revised: (2015b).

Original: Following Tran et al.
Revised: Following Tran et al.

Original: (2018), we train the models on sequences with ≤ 6 operators and test on data with greater number of operators (here, we check for cases with ≥ 8 operators) to check for capacity to generalize to unseen number of operators.
Revised: (2018), we train the models on sequences with ≤ 6 operators and test on data with greater number of operators (here, we check for cases with ≥ 8 operators) to check for capacity to generalize to unseen number of operators.

Original: Similar to Shen et al.
Revised: Similar to Shen et al.

Original: (2019a)
Revised: (2019a)

Original: ; Chowdhury & Caragea (2021), we also train the model on the systematicity split C .
Revised: ; Chowdhury & Caragea (2021), we also train the model on the systematicity split C .

Original: In this split we remove any sequence matching the pattern ∗ ( and ( not ∗ )) ∗ from the training set and put them in the test set to check for systematic generalization.
Revised: In this split we remove any sequence matching the pattern ∗ ( and ( not ∗ )) ∗ from the training set and put them in the test set to check for systematic generalization.

Original: Results:
Revised: Results:

Original: In Table 7, in terms of operation generalization, our proposed BT-Cell models perform similarly to prior SOTA models like Ordered Memory (OM) and CRvNN while approximating
Revised: In Table 7, in terms of operation generalization, our proposed BT-Cell models perform similarly to prior SOTA models like Ordered Memory (OM) and CRvNN while approximating

Original: GoldTreeGRC for both beam sizes.
Revised: GoldTreeGRC for both beam sizes.

Original: GRC-based models perform better than comparative LSTMbased models.
Revised: GRC-based models perform better than comparative LSTMbased models.

Original: Unsurprisingly, following discussions in Appendix D, Gumbel-BT-GRC does not perform as well.
Revised: Unsurprisingly, following discussions in Appendix D, Gumbel-BT-GRC does not perform as well.

Original: In terms of systematicity (split C), OM and BT-GRC (with beam size 5) perform similarly (both above 94% ) and much better than the other models.
Revised: In terms of systematicity (split C), OM and BT-GRC (with beam size 5) perform similarly (both above 94% ) and much better than the other models.

Original: Lower beam size extensions hurts systematicity performance for BT-GRC which is not too surprising given we are limiting the beam size.
Revised: Lower beam size extensions hurts systematicity performance for BT-GRC which is not too surprising given we are limiting the beam size.

Original: Surprisingly, however, softpath/gumbelpath extensions also hurt systematicity.
Revised: Surprisingly, however, softpath/gumbelpath extensions also hurt systematicity.

Original: CYKGRC shows promise in operator generalization but shows poor systematicity as well.
Revised: CYKGRC shows promise in operator generalization but shows poor systematicity as well.

Original: Gumbel-GRC
Revised: Gumbel-GRC

Original: [Table]
Revised: [Table]

Original: performs better than fixed tree models (ReccurentGRC or BalancedTreeCell) or RandomTreeCell but still far from SOTA which is not unexpected given its poor results in ListOps.
Revised: performs better than fixed tree models (ReccurentGRC or BalancedTreeCell) or RandomTreeCell but still far from SOTA which is not unexpected given its poor results in ListOps.

Original: E. N ATURAL L ANGUAGE I NFERENCE E XPERIMENTS
Revised: E. N ATURAL L ANGUAGE I NFERENCE E XPERIMENTS

Original: Dataset Settings: We ran our models on MNLI (Williams et al., 2018) which is a natural language inference task.
Revised: Dataset Settings: We ran our models on MNLI (Williams et al., 2018) which is a natural language inference task.

Original: We tested our models on the development set of MNLI and use a randomly sampled subset of 10 , 000 data points from the original training set as the development set.
Revised: We tested our models on the development set of MNLI and use a randomly sampled subset of 10 , 000 data points from the original training set as the development set.

Original: Our training setup is different from Chowdhury & Caragea (2021) and other prior latent tree models which combines
Revised: Our training setup is different from Chowdhury & Caragea (2021) and other prior latent tree models which combines

Original: SNLI (Bowman et al., 2015a) and MNLI training sets (we don’t add SNLI data.).
Revised: SNLI (Bowman et al., 2015a) and MNLI training sets (we don’t add SNLI data.).

Original: We filter sequences ≥ 150 from the training set for efficiency.
Revised: We filter sequences ≥ 150 from the training set for efficiency.

Original: We also test our models in various stress tests (Naik et al., 2018).
Revised: We also test our models in various stress tests (Naik et al., 2018).

Original: We report the results in Table 8.
Revised: We report the results in Table 8.

Original: M denotes matched development set (used as test set) of
Revised: M denotes matched development set (used as test set) of

Original: MNLI.
Revised: MNLI.

Original: MM denotes mismatched development set (used as test set) of MNLI.
Revised: MM denotes mismatched development set (used as test set) of MNLI.

Original: LenM denotes length matched stress set from (Naik et al., 2018).
Revised: LenM denotes length matched stress set from (Naik et al., 2018).

Original: LenMM denotes length mismatched stress set from (Naik et al., 2018).
Revised: LenMM denotes length mismatched stress set from (Naik et al., 2018).

Original: NegM denotes negation matched stress set from (Naik et al., 2018). NegMM denotes negation mismatched stress set from (Naik et al., 2018).
Revised: NegM denotes negation matched stress set from (Naik et al., 2018). NegMM denotes negation mismatched stress set from (Naik et al., 2018).

Original: Length matched/mismatched stress sets add to the length of the premise by adding tautologies.
Revised: Length matched/mismatched stress sets add to the length of the premise by adding tautologies.

Original: Negation matched/mismatched stress sets add tautologies containing “not” terms which can bias the model to falsely predict contradictions.
Revised: Negation matched/mismatched stress sets add tautologies containing “not” terms which can bias the model to falsely predict contradictions.

Original: Results: Results in Table 8 show BT-GRC variants are not particularly better than the other models in the standard matched/mismatched sets.
Revised: Results: Results in Table 8 show BT-GRC variants are not particularly better than the other models in the standard matched/mismatched sets.

Original: However, discounting Gumbelpath (which tends to break down), even the weakest BT-GRC variants outperform all other models on length matched/mismatched stress test.
Revised: However, discounting Gumbelpath (which tends to break down), even the weakest BT-GRC variants outperform all other models on length matched/mismatched stress test.

Original: BT-GRC (with beam 2 or 5 ) or BT-GRC with Softpath and beamalso tend to do marginally better than other models in negation matched/mismatched test sets.
Revised: BT-GRC (with beam 2 or 5 ) or BT-GRC with Softpath and beamalso tend to do marginally better than other models in negation matched/mismatched test sets.

Original: Overall most BT-Cell variants show better robustness to stress tests.
Revised: Overall most BT-Cell variants show better robustness to stress tests.

Original: We ignore testing Gumbel-BT-GRC because it generally is a bad performer.
Revised: We ignore testing Gumbel-BT-GRC because it generally is a bad performer.

Original: Overall, given both the performance here and at IMDB, gumbel-based models (including gumbelpath) may be better avoided in general (Also consider that GumbelTreeGRC, here, performs worse than RandomTreeGRC).
Revised: Overall, given both the performance here and at IMDB, gumbel-based models (including gumbelpath) may be better avoided in general (Also consider that GumbelTreeGRC, here, performs worse than RandomTreeGRC).

Original: E. E FFICIENCY A NALYSIS
Revised: E. E FFICIENCY A NALYSIS

Original: Settings: In Table 9, we compare the empirical performance of various models in terms of time and memory.
Revised: Settings: In Table 9, we compare the empirical performance of various models in terms of time and memory.

Original: We ran each models on ListOps splits of different sequence lengths ( 200 - 250 , 500 - 600 , and 900 - 1000 ).
Revised: We ran each models on ListOps splits of different sequence lengths ( 200 - 250 , 500 - 600 , and 900 - 1000 ).

Original: Each split contains 100 samples.
Revised: Each split contains 100 samples.

Original: We ran each model with the batch size of 1 .
Revised: We ran each model with the batch size of 1 .

Original: Other hyperparameters are same as those used for ListOps.
Revised: Other hyperparameters are same as those used for ListOps.

Original: Note that we are showing time and memory consumption during training (not inference).
Revised: Note that we are showing time and memory consumption during training (not inference).

Original: All models are ran in an Nvidia RTX A6000 GPU.
Revised: All models are ran in an Nvidia RTX A6000 GPU.

Original: [Table]
Revised: [Table]

Original: Discussions:
Revised: Discussions:

Original: Assume n denotes the sequence length, d denotes the hidden state dimensions, k denotes the beam size, and m denotes the number of memory slots (for Ordered Memory).
Revised: Assume n denotes the sequence length, d denotes the hidden state dimensions, k denotes the beam size, and m denotes the number of memory slots (for Ordered Memory).

Original: RecurrentGRC: Recurrent models performs reasonably well.
Revised: RecurrentGRC: Recurrent models performs reasonably well.

Original: While it need to go through n sequential steps but so do most other models.
Revised: While it need to go through n sequential steps but so do most other models.

Original: Moreover, computation in each iteration of the sequential loop is relatively simple - it is just the application of the recursive cell function.
Revised: Moreover, computation in each iteration of the sequential loop is relatively simple - it is just the application of the recursive cell function.

Original: The space complexity is also very little because of lack of parallel processing accross the sequence length (it has to only store the hidden state memory O( d )).
Revised: The space complexity is also very little because of lack of parallel processing accross the sequence length (it has to only store the hidden state memory O( d )).

Original: Thus the memory consumption stays nearly constant with increasing sequence length.
Revised: Thus the memory consumption stays nearly constant with increasing sequence length.

Original: BalancedTreeGRC: BalancedTreeGRC is also moderately efficient.
Revised: BalancedTreeGRC: BalancedTreeGRC is also moderately efficient.

Original: It can slightly increase memory consumption because of more parallelized processing.
Revised: It can slightly increase memory consumption because of more parallelized processing.

Original: It composes multiple children in every step.
Revised: It composes multiple children in every step.

Original: However, since it cuts off half of the sequence at every step, its outer sequential loop is only in the order of O ( logn ) .
Revised: However, since it cuts off half of the sequence at every step, its outer sequential loop is only in the order of O ( logn ) .

Original: Thus, its memory consumption does not increases as much compared to GumbelTreeGRC or RandomTreeGRC.
Revised: Thus, its memory consumption does not increases as much compared to GumbelTreeGRC or RandomTreeGRC.

Original: While the total sequential steps is much less for BalancedTreeGRC, it seems that the added overhead from more parallelized processing per iteration still makes it slightly slower than RecurrentGRC in practice (still it is faster than any other models).
Revised: While the total sequential steps is much less for BalancedTreeGRC, it seems that the added overhead from more parallelized processing per iteration still makes it slightly slower than RecurrentGRC in practice (still it is faster than any other models).

Original: However, there may be room for better code optimization for BalancedTreeCell.
Revised: However, there may be room for better code optimization for BalancedTreeCell.

Original: RandomTreeCell and GumbelTreeCell : Both are similar in terms of complexity.
Revised: RandomTreeCell and GumbelTreeCell : Both are similar in terms of complexity.

Original: Both chooses one composition at a time requiring them to still go through n seuqntial steps in the outer loop unlike
Revised: Both chooses one composition at a time requiring them to still go through n seuqntial steps in the outer loop unlike

Original: BalancedTreeGRC.
Revised: BalancedTreeGRC.

Original: However, unlike RecurrentGRC, in each loop, it has to also parallely compute all possible parent compositions - this leads to higher space complexity for each iteration O ( nd 2 ) that also scales up with increasing sequence length n and also higher computational overhead per iteration in the loop.
Revised: However, unlike RecurrentGRC, in each loop, it has to also parallely compute all possible parent compositions - this leads to higher space complexity for each iteration O ( nd 2 ) that also scales up with increasing sequence length n and also higher computational overhead per iteration in the loop.

Original: Thus, they run slower than RecurrentGRC and takes much more memory as well.
Revised: Thus, they run slower than RecurrentGRC and takes much more memory as well.

Original: Nevertheless, in comparison to other latent-tree models these are still relatively fast, simple, and lightweight.
Revised: Nevertheless, in comparison to other latent-tree models these are still relatively fast, simple, and lightweight.

Original: CYK-GRC: CYK-GRC is the worst offender of all in terms of computational efficiency.
Revised: CYK-GRC: CYK-GRC is the worst offender of all in terms of computational efficiency.

Original: Note also that GRC can itself be relatively expensive cell function because of high dimensional feedforward networks – adding up overhead compared to classical CYK models.
Revised: Note also that GRC can itself be relatively expensive cell function because of high dimensional feedforward networks – adding up overhead compared to classical CYK models.

Original: CYK-GRC takes a chart-filling approach in a dynamic programming style.
Revised: CYK-GRC takes a chart-filling approach in a dynamic programming style.

Original: The number of cells in the filled chart is n 2 / 2 .
Revised: The number of cells in the filled chart is n 2 / 2 .

Original: Each cell in the original CYK algorithm can again have multiple options, however, Maillard et al.
Revised: Each cell in the original CYK algorithm can again have multiple options, however, Maillard et al.

Original: (2019) simplifies this by keeping only one option per cell through attention-based pooling.
Revised: (2019) simplifies this by keeping only one option per cell through attention-based pooling.

Original: Even after that, each cell still has to contain a d dimensional hidden state.
Revised: Even after that, each cell still has to contain a d dimensional hidden state.

Original: This leads to atleast o ( n 2 d ) space complexity.
Revised: This leads to atleast o ( n 2 d ) space complexity.

Original: Moreover, it still has to take n sequential steps in the outer loop to recursively fill up the chart.
Revised: Moreover, it still has to take n sequential steps in the outer loop to recursively fill up the chart.

Original: At the same time each sequential step is also more expensive than any of the other models.
Revised: At the same time each sequential step is also more expensive than any of the other models.

Original: For filling up any cell it has to compute all valid possible ways to combine pre-computed cell and then perform an attention pooling.
Revised: For filling up any cell it has to compute all valid possible ways to combine pre-computed cell and then perform an attention pooling.

Original: It has to, thus, apply GRC multiple times to all possible ways of composition from prior chart cells.
Revised: It has to, thus, apply GRC multiple times to all possible ways of composition from prior chart cells.

Original: This step can be, however, parallelized (and we do parallelize it).
Revised: This step can be, however, parallelized (and we do parallelize it).

Original: Nevertheless, applying GRC in parellel to all possible left-right children pair (from prior computed chart cells) can still add to memmory consuption and temporal overheads.
Revised: Nevertheless, applying GRC in parellel to all possible left-right children pair (from prior computed chart cells) can still add to memmory consuption and temporal overheads.

Original: This reflects in both extremely high memory consumption and also the slowest speed among all else.
Revised: This reflects in both extremely high memory consumption and also the slowest speed among all else.

Original: BSRP-GRC: BSRP-GRC is essentially a form of stack augmented RNN.
Revised: BSRP-GRC: BSRP-GRC is essentially a form of stack augmented RNN.

Original: Similar to RecurrentGRC, it’s memory consuption is low because of limited parallel processing (although its stack size grow with each iteration which reflects in sharply rising memory with increasing sequence length compared to Recurrent GRC).
Revised: Similar to RecurrentGRC, it’s memory consuption is low because of limited parallel processing (although its stack size grow with each iteration which reflects in sharply rising memory with increasing sequence length compared to Recurrent GRC).

Original: However, it has added expenses in each recurrent iteration due to additional stack operations and shift/reduce decision computation.
Revised: However, it has added expenses in each recurrent iteration due to additional stack operations and shift/reduce decision computation.

Original: In effect this makes the model quite slow although better than some others.
Revised: In effect this makes the model quite slow although better than some others.

Original: BSRPC-GRC taking a shift-reduce parsing strategy also need to increase the sequential steps from n to 2 n .
Revised: BSRPC-GRC taking a shift-reduce parsing strategy also need to increase the sequential steps from n to 2 n .

Original: Although that doesn’t make an asymptotic difference, it still can further contribute to the empirical slowdown.
Revised: Although that doesn’t make an asymptotic difference, it still can further contribute to the empirical slowdown.

Original: We use a beam size of 5 for
Revised: We use a beam size of 5 for

Original: BSRP-GRC here for better comparison against BT-GRC.
Revised: BSRP-GRC here for better comparison against BT-GRC.

Original: Ordered Memory: Ordered Memory (OM) is also a form of stack augmented RNN and thus, have similar memory advantages as RecurrentGRC (although overall memory consumption is relative increased due to storing multiple slots of hidden states).
Revised: Ordered Memory: Ordered Memory (OM) is also a form of stack augmented RNN and thus, have similar memory advantages as RecurrentGRC (although overall memory consumption is relative increased due to storing multiple slots of hidden states).

Original: However, the main bottleneck in OM is time.
Revised: However, the main bottleneck in OM is time.

Original: Precisely, OM utilizes a nested loop.
Revised: Precisely, OM utilizes a nested loop.

Original: The outerloop is the same n times sequential operation as RecurrentGRC, but in the in each step of that loop, OM has to again sequentially apply GRC over the m memory slots.
Revised: The outerloop is the same n times sequential operation as RecurrentGRC, but in the in each step of that loop, OM has to again sequentially apply GRC over the m memory slots.

Original: This leads to a O ( nm ) sequential steps.
Revised: This leads to a O ( nm ) sequential steps.

Original: Thus, we get a heavy hit to time consumption with OM.
Revised: Thus, we get a heavy hit to time consumption with OM.

Original: CRvNN: The framework of CRvNN is roughly similar to GumbelTreeGRC.
Revised: CRvNN: The framework of CRvNN is roughly similar to GumbelTreeGRC.

Original: However, instead of choosing one parent at a time, it can choose multiple parents at a time, that too in a soft manner.
Revised: However, instead of choosing one parent at a time, it can choose multiple parents at a time, that too in a soft manner.

Original: But this comes at a cost.
Revised: But this comes at a cost.

Original: While GumbelTreeGRC can reduce the sequence size with each sequential step,
Revised: While GumbelTreeGRC can reduce the sequence size with each sequential step,

Original: CRvNN has to still maintain the whole sequence in each step with associated “existential probability” for each sequence item.
Revised: CRvNN has to still maintain the whole sequence in each step with associated “existential probability” for each sequence item.

Original: Moreover, computing the composition of contiguous representations also becomes harder.
Revised: Moreover, computing the composition of contiguous representations also becomes harder.

Original: Since in CRvNNs sequence items exists with some probability, what counts as the first existing contiguous item is also probabilistic.
Revised: Since in CRvNNs sequence items exists with some probability, what counts as the first existing contiguous item is also probabilistic.

Original: In effect, CRvNN needs to create a nattention matrix (similar to Transformers but based on existential probabilities instead of dot product attention) to retrieve neighbor (contiguous) elements to create parent candidates.
Revised: In effect, CRvNN needs to create a nattention matrix (similar to Transformers but based on existential probabilities instead of dot product attention) to retrieve neighbor (contiguous) elements to create parent candidates.

Original: Furthermore, in each sequential steps, this n 2 attention matrix needs to be applied multiple times - for example, to get local composition scores for sigmoid modulation and also to retrieve some w local items for its convolution-based decision function.
Revised: Furthermore, in each sequential steps, this n 2 attention matrix needs to be applied multiple times - for example, to get local composition scores for sigmoid modulation and also to retrieve some w local items for its convolution-based decision function.

Original: That can also add significant overhead (although still quite tame, in terms of temporal overhead, compared to the memory-slot-wise recursion in OM).
Revised: That can also add significant overhead (although still quite tame, in terms of temporal overhead, compared to the memory-slot-wise recursion in OM).

Original: Thus, in effect, we get increased memory consumption and time compared to GumbelTreeGRC.
Revised: Thus, in effect, we get increased memory consumption and time compared to GumbelTreeGRC.

Original: At the same time, however, efficiency analysis for CRvNN is complicated by the fact that it can dynamically halt early.
Revised: At the same time, however, efficiency analysis for CRvNN is complicated by the fact that it can dynamically halt early.

Original: That is, it does not need to take full n sequential steps unlike any of the other models (besides
Revised: That is, it does not need to take full n sequential steps unlike any of the other models (besides

Original: BalancedTreeGRC).
Revised: BalancedTreeGRC).

Original: However, this doesn’t mean CRvNN is guaranteed to take O ( logn ) sequentials steps.
Revised: However, this doesn’t mean CRvNN is guaranteed to take O ( logn ) sequentials steps.

Original: Ideally, it is intended to take as many sequential steps as is the induced binary tree depth.
Revised: Ideally, it is intended to take as many sequential steps as is the induced binary tree depth.

Original: Underlying binary tree depths are not necessarily always (or even in average) around O ( logn ) .
Revised: Underlying binary tree depths are not necessarily always (or even in average) around O ( logn ) .

Original: So while it can give an increase performance boost, there is not a clear boost asymptotically.
Revised: So while it can give an increase performance boost, there is not a clear boost asymptotically.

Original: Moreover, we found it challenging to evaluate CRvNN fairly.
Revised: Moreover, we found it challenging to evaluate CRvNN fairly.

Original: In the 100 samples dataset, CRvNN with early halting can just induce bad trees (given lack of enough data to be trained well) and halt very fast (unreflective of realistic performance) but increasing number of samples makes the analysis more cumbersome overall for all other models.
Revised: In the 100 samples dataset, CRvNN with early halting can just induce bad trees (given lack of enough data to be trained well) and halt very fast (unreflective of realistic performance) but increasing number of samples makes the analysis more cumbersome overall for all other models.

Original: So we instead show the “worst case” performance of CRvNN.
Revised: So we instead show the “worst case” performance of CRvNN.

Original: The “worst case” is the case when CRvNN does not halt early; thus, to simulate the “worst case” we disable early halting.
Revised: The “worst case” is the case when CRvNN does not halt early; thus, to simulate the “worst case” we disable early halting.

Original: The “worst case” is also still practically relevant and needed to be considered to set up the hyperparameters (like batch size) properly so that the model does not run out of memory during training because of the “worst case” induction.
Revised: The “worst case” is also still practically relevant and needed to be considered to set up the hyperparameters (like batch size) properly so that the model does not run out of memory during training because of the “worst case” induction.

Original: With this setup, we find CRvNN to be in-between in terms of performance.
Revised: With this setup, we find CRvNN to be in-between in terms of performance.

Original: We discuss more about it in comparison to
Revised: We discuss more about it in comparison to

Original: BT-Cell models in the next section.
Revised: BT-Cell models in the next section.

Original: BT
Revised: BT

Original: -GRC
Revised: -GRC

Original: : The time complexity of BT-GRC is O ( n ( knd 2 + k 3 nd )) .
Revised: : The time complexity of BT-GRC is O ( n ( knd 2 + k 3 nd )) .

Original: k (beam size) is technically a relative small constant and can be ignored in asymptotic analysis (bringing BT-GRC at a similar complexity level to Gumbel-Tree GRC), but we keep it here for better exposition of the effect of beam size ( k ).
Revised: k (beam size) is technically a relative small constant and can be ignored in asymptotic analysis (bringing BT-GRC at a similar complexity level to Gumbel-Tree GRC), but we keep it here for better exposition of the effect of beam size ( k ).

Original: Similar to most other models here, BT-GRC has to take an outer sequential steps of n .
Revised: Similar to most other models here, BT-GRC has to take an outer sequential steps of n .

Original: In each sequential step, similar to GumbelTreeGRC it has to calculate all parent candidates which can lead to a complexity of O ( nd 2 ) , but since now we have to do the same for each of the k beams we have a multiplicative effect: O ( knd 2 ) .
Revised: In each sequential step, similar to GumbelTreeGRC it has to calculate all parent candidates which can lead to a complexity of O ( nd 2 ) , but since now we have to do the same for each of the k beams we have a multiplicative effect: O ( knd 2 ) .

Original: However, this n d computation can be done in parallel (all parent candidates are computed in parallel in GumbelTreeGRC).
Revised: However, this nd 2 computation can be done in parallel (all parent candidates are computed in parallel in GumbelTreeGRC).

Original: Similarly each beams are independent and can be computed in parallel as well.
Revised: Similarly each beams are independent and can be computed in parallel as well.

Original: So in effect the computation cost here is similar to increasing the batch size of GumbelTreeGRC by k .
Revised: So in effect the computation cost here is similar to increasing the batch size of GumbelTreeGRC by k .

Original: The term k 3 nd indicates the selection costs of k vectors of size d from k 2 vectors of size d for a sequence of size n .
Revised: The term k 3 nd indicates the selection costs of k vectors of size d from k 2 vectors of size d for a sequence of size n .

Original: Again, in practice this can be also parallelized by creating a k 2 permutation matrix and performing a single matrix multiplication in CUDA.
Revised: Again, in practice this can be also parallelized by creating a k 2 permutation matrix and performing a single matrix multiplication in CUDA.

Original: Overall, this doesn’t add as much cost over parent composition.
Revised: Overall, this doesn’t add as much cost over parent composition.

Original: As we a priori suspected, empirically, we also verified the increased time/memory cost of BT-GRC in different sequence length to match the effect of increasing the batch size of GumbelTreeGRC by k .
Revised: As we a priori suspected, empirically, we also verified the increased time/memory cost of BT-GRC in different sequence length to match the effect of increasing the batch size of GumbelTreeGRC by k .

Original: Even though, ultimately, k is a constant, in practice, this can still lead to a significant expense.
Revised: Even though, ultimately, k is a constant, in practice, this can still lead to a significant expense.

Original: This is where small k (example beam 2 ) can be valuable.
Revised: This is where small k (example beam 2 ) can be valuable.

Original: As we can see because most computation through k is parallelized the time is not changed as much in changing from beam size ( k ) 2 to 5 .
Revised: As we can see because most computation through k is parallelized the time is not changed as much in changing from beam size ( k ) 2 to 5 .

Original: But the memory consumption can be significantly decreased with lower beam ( k = 2 ).
Revised: But the memory consumption can be significantly decreased with lower beam ( k = 2 ).

Original: Thus, BT-Cell with beam size 2 can be an attractive choice here particularly when it can still perform relatively on par with bigger beam models on synthetic logical inference and natural language tasks.
Revised: Thus, BT-Cell with beam size 2 can be an attractive choice here particularly when it can still perform relatively on par with bigger beam models on synthetic logical inference and natural language tasks.

Original: Also with softpath and beam size 2, listops performance is still decent.
Revised: Also with softpath and beam size 2, listops performance is still decent.

Original: Another interesting point to note is that BT-GRC does not rely on any n 2 matrix as CRvNN.
Revised: Another interesting point to note is that BT-GRC does not rely on any n 2 matrix as CRvNN.

Original: Thus, we can see that its memory consumption scales better with increasing length than CRvNN.
Revised: Thus, we can see that its memory consumption scales better with increasing length than CRvNN.

Original: For example, in sequence length 200 - 250 , CRvNN took slightly less memory than BT-GRC, but in sequence length 900 - 1000 , CRvNN takes nearly twice as much memory compared to BT-GRC.
Revised: For example, in sequence length 200 - 250 , CRvNN took slightly less memory than BT-GRC, but in sequence length 900 - 1000 , CRvNN takes nearly twice as much memory compared to BT-GRC.

Original: However, we wouldn’t claim that CRvNN is strictly worse than BT-GRC in efficiency departments because CRvNN can be made more efficient by bounding its outer sequential loop and dynamic halting (but these factors are more tricky to fairly analyze).
Revised: However, we wouldn’t claim that CRvNN is strictly worse than BT-GRC in efficiency departments because CRvNN can be made more efficient by bounding its outer sequential loop and dynamic halting (but these factors are more tricky to fairly analyze).

Original: BT-GRC + Softpath:
Revised: BT-GRC + Softpath:

Original: Although the forward propagation complexity should be nearly the same for
Revised: Although the forward propagation complexity should be nearly the same for

Original: Softpath, in practice we find that adding Softpath increases both the memory and time significantly compared to base BT-GRC.
Revised: Softpath, in practice we find that adding Softpath increases both the memory and time significantly compared to base BT-GRC.

Original: We find that this is because of added backpropagation expenses because of more complicated gradient propagation.
Revised: We find that this is because of added backpropagation expenses because of more complicated gradient propagation.

Original: We verified this by keep the forward network of Softpath variant the same and using Pytorch’s detach () function to cut the gradient from Top-K Softpath selection.
Revised: We verified this by keep the forward network of Softpath variant the same and using Pytorch’s detach () function to cut the gradient from Top-K Softpath selection.

Original: This change leads to similar empirical efficiency to base BT-GRC.
Revised: This change leads to similar empirical efficiency to base BT-GRC.

Original: Nevertheless, despite the added costs, Softpath is still comparable to CRvNN and much faster than OM, CYk-GRC, SOFT top-k, and BSRP-GRC.
Revised: Nevertheless, despite the added costs, Softpath is still comparable to CRvNN and much faster than OM, CYk-GRC, SOFT top-k, and BSRP-GRC.

Original: Moreover, Softpath with beam size 2 still remains an attractive option with further lowered memory consumption.
Revised: Moreover, Softpath with beam size 2 still remains an attractive option with further lowered memory consumption.

Original: BT-GRC + SOFT:
Revised: BT-GRC + SOFT:

Original: As we already claimed before using differentiable sorting algorithm (SOFT
Revised: As we already claimed before using differentiable sorting algorithm (SOFT

Original: Top-k) (Xie et al., 2020) in a recursive loop can bring significant overhead and slowdown.
Revised: Top-k) (Xie et al., 2020) in a recursive loop can bring significant overhead and slowdown.

Original: We show it empirically in Table 9.
Revised: We show it empirically in Table 9.

Original: Replacing Softpath with SOFT Top-k can increase the time taken by around 3 × compared to BT-GRC+Softpath.
Revised: Replacing Softpath with SOFT Top-k can increase the time taken by around 3 × compared to BT-GRC+Softpath.

Original: E. P ARSE T REE A NALYSIS
Revised: E. P ARSE T REE A NALYSIS

Original: In this section, we analyze the induced structures of BT-Cell models.
Revised: In this section, we analyze the induced structures of BT-Cell models.

Original: Note, however, although induced structures can provide some insights to the model, we can draw limited conclusions from them.
Revised: Note, however, although induced structures can provide some insights to the model, we can draw limited conclusions from them.

Original: First, if we take a stance similar to Choi et al.
Revised: First, if we take a stance similar to Choi et al.

Original: in considering it suitable to allow different kinds of structures to be induced as appropriate for a specific task then it’s not clear how structures should be evaluated by themselves (besides just the donwstream task evaluations).
Revised: in considering it suitable to allow different kinds of structures to be induced as appropriate for a specific task then it’s not clear how structures should be evaluated by themselves (besides just the donwstream task evaluations).

Original: Second, the extracted structures may not completely reflect what the models may implicitly induce because the recursive cell can override some of the parser decisions (given how there is evidence that even simple RNNs Bowman et al.
Revised: Second, the extracted structures may not completely reflect what the models may implicitly induce because the recursive cell can override some of the parser decisions (given how there is evidence that even simple RNNs Bowman et al.

Original: (2015b) can implicitly model different tree structures within its hidden states to an extent even when its explicit structure always conform to the left-to-right order of composition).
Revised: (2015b) can implicitly model different tree structures within its hidden states to an extent even when its explicit structure always conform to the left-to-right order of composition).

Original: Third, even if the extracted structure perfectly reflects what the model induces, another side of the story is the recursive cell itself and how it utilizes the structure for language understanding.
Revised: Third, even if the extracted structure perfectly reflects what the model induces, another side of the story is the recursive cell itself and how it utilizes the structure for language understanding.

Original: This part of the story can still remain unclear because of the blackbox-nature of neural nets.
Revised: This part of the story can still remain unclear because of the blackbox-nature of neural nets.

Original: Nevertheless, extractive structures may still provide some rough idea of the inner workings of
Revised: Nevertheless, extractive structures may still provide some rough idea of the inner workings of

Original: BT-Cell variants.
Revised: BT-Cell variants.

Original: [Table]
Revised: [Table]

Original: In Table 10, we show the parsed structures of some iconic sentences by BT-GRC after it is trained on MNLI.
Revised: In Table 10, we show the parsed structures of some iconic sentences by BT-GRC after it is trained on MNLI.

Original: We report all beams and their corresponding scores.
Revised: We report all beams and their corresponding scores.

Original: Note, although beam search ensures that the sequence of parsing actions for each beam is unique, different sequences of parsing action can still lead to the same structure.
Revised: Note, although beam search ensures that the sequence of parsing actions for each beam is unique, different sequences of parsing action can still lead to the same structure.

Original: Thus, some beams end up being duplicates.
Revised: Thus, some beams end up being duplicates.

Original: In such cases, for the sake of more concise presentation, we collapse the duplicates into a single beam and add up their corresponding scores.
Revised: In such cases, for the sake of more concise presentation, we collapse the duplicates into a single beam and add up their corresponding scores.

Original: This is why we can note in Table 10 that we sometimes have fewer induced structures than the beam size.
Revised: This is why we can note in Table 10 that we sometimes have fewer induced structures than the beam size.

Original: At a rough glance, we can see that the different induced structures roughly correspond to human intuitions.
Revised: At a rough glance, we can see that the different induced structures roughly correspond to human intuitions.

Original: One interesting appeal for beam search is that it can more explicitly account for ambiguous interpretations corresponding to ambiguous structures.
Revised: One interesting appeal for beam search is that it can more explicitly account for ambiguous interpretations corresponding to ambiguous structures.

Original: For example, “i shot an elephant in my pajamas” is ambiguous with respect to whether it is the elephant who is in the shooter’s pajamas, or if it is the shooter who is in the pajamas.
Revised: For example, “i shot an elephant in my pajamas” is ambiguous with respect to whether it is the elephant who is in the shooter’s pajamas, or if it is the shooter who is in the pajamas.

Original: The induced structure (beam size 5 model in Table 10) (((i shot) (an elephant))
Revised: The induced structure (beam size 5 model in Table 10) (((i shot) (an elephant))

Original: ((in my) pajamas)) corresponds better to the latter interpretation whereas ((i shot)
Revised: ((in my) pajamas)) corresponds better to the latter interpretation whereas ((i shot)

Original: ((an elephant)
Revised: ((an elephant)

Original: ((in my) pajamas))) corresponds better to the former interpretation (because “an elephant” is first composed with “in my pajamas”).
Revised: ((in my) pajamas))) corresponds better to the former interpretation (because “an elephant” is first composed with “in my pajamas”).

Original: Similar to above, “john saw a man with binoculars” is also ambiguous.
Revised: Similar to above, “john saw a man with binoculars” is also ambiguous.

Original: Its interpretation is ambiguous with respect to whether it is John who is seeing through binoculars, or whether it is the man who just possesses the binoculars.
Revised: Its interpretation is ambiguous with respect to whether it is John who is seeing through binoculars, or whether it is the man who just possesses the binoculars.

Original: Here, again, we can find (beam size 5 model in Table 10) that the induced structure (((john saw) (a man))
Revised: Here, again, we can find (beam size 5 model in Table 10) that the induced structure (((john saw) (a man))

Original: (with binoculars) corresponds better to the former interpretation whereas ((john saw) ((a man) (with binoculars))) corresponds better to the latter.
Revised: (with binoculars) corresponds better to the former interpretation whereas ((john saw) ((a man) (with binoculars))) corresponds better to the latter.

Original: Generally, we find the score distributions to have a high entropy.
Revised: Generally, we find the score distributions to have a high entropy.

Original: A future consideration would be whether we should add an auxiliary objective to minimize entropy.
Revised: A future consideration would be whether we should add an auxiliary objective to minimize entropy.

Original: In Table 11, we show the parsed structures of the same sentences by BT-GRC+Softpath after it is trained on MNLI, and in Table 12, we show the same for BT-GRC+Gumbelpath.
Revised: In Table 11, we show the parsed structures of the same sentences by BT-GRC+Softpath after it is trained on MNLI, and in Table 12, we show the same for BT-GRC+Gumbelpath.

Original: Most of the points above applies here for Softpath and Gumbelpath as well.
Revised: Most of the points above applies here for Softpath and Gumbelpath as well.

Original: Interestingly, Softpath and Gumbelpath seemed to have a relatively lower entropy distribution - that is most evident in beam size 2 .
Revised: Interestingly, Softpath and Gumbelpath seemed to have a relatively lower entropy distribution - that is most evident in beam size 2 .

Original: We also note that Gumbelpath structures are of a similar quality despite having much lower empirical performance in MNLI.
Revised: We also note that Gumbelpath structures are of a similar quality despite having much lower empirical performance in MNLI.

Original: [Table]
Revised: [Table]

Original: We found the structures induced by BT-Cell variants after training on SST5 or IMDB to be more ill-formed.
Revised: We found the structures induced by BT-Cell variants after training on SST5 or IMDB to be more ill-formed.

Original: This may indicate that sentiment classification does not provide a strong enough signal for parsing or rather, exact induction of structures are not as necessary (Iyyer et al., 2015).
Revised: This may indicate that sentiment classification does not provide a strong enough signal for parsing or rather, exact induction of structures are not as necessary (Iyyer et al., 2015).

Original: We show the parsings of these models after training on IMDB and SST datasets in a text file included in the supplementary.
Revised: We show the parsings of these models after training on IMDB and SST datasets in a text file included in the supplementary.

Original: F E XTENDED R ELATED W ORKS
Revised: F E XTENDED R ELATED W ORKS

Original: Initially RvNN Pollack (1990); Socher et al.
Revised: Initially RvNN Pollack (1990); Socher et al.

Original: (2010) was used with user-annotated tree-structured data.
Revised: (2010) was used with user-annotated tree-structured data.

Original: Some explored use of heuristic trees such as balanced trees for RvNN-like settings (Munkhdalai & Yu, 2017; Shi et al., 2018).
Revised: Some explored use of heuristic trees such as balanced trees for RvNN-like settings (Munkhdalai & Yu, 2017; Shi et al., 2018).

Original: In due time, several approaches were introduced for dynamically inducing structures from data for RvNN-style processing.
Revised: In due time, several approaches were introduced for dynamically inducing structures from data for RvNN-style processing.

Original: This includes the greedy easy-first framework using children-reconstruction loss (Socher et al., 2011) or gumbel softmax (Choi et al., 2018), RL-based frameworks (Havrylov et al., 2019), CYK-based framework (Le &
Revised: This includes the greedy easy-first framework using children-reconstruction loss (Socher et al., 2011) or gumbel softmax (Choi et al., 2018), RL-based frameworks (Havrylov et al., 2019), CYK-based framework (Le &

Original: Zuidema, 2015; Maillard et al., 2019; Drozdov et al., 2019; Hu et al., 2021), shift-reduce parsing or memory-augmented or stack-augmented RNN frameworks (Grefenstette et al., 2015; Bowman et al., 2016;
Revised: Zuidema, 2015; Maillard et al., 2019; Drozdov et al., 2019; Hu et al., 2021), shift-reduce parsing or memory-augmented or stack-augmented RNN frameworks (Grefenstette et al., 2015; Bowman et al., 2016;

Original: Yogatama et al., 2017; Maillard & Clark, 2018; Shen et al., 2019a; DuSell & Chiang, 2020; 2022), and soft-recursion-based frameworks (Chowdhury & Caragea, 2021; Zhang et al., 2021).
Revised: Yogatama et al., 2017; Maillard & Clark, 2018; Shen et al., 2019a; DuSell & Chiang, 2020; 2022), and soft-recursion-based frameworks (Chowdhury & Caragea, 2021; Zhang et al., 2021).

Original: Besides RvNNs, other approaches range from adding information-ordering biases to hidden states in RNNs (Shen et al., 2019b) or even adding additional structural or recursive constraints to
Revised: Besides RvNNs, other approaches range from adding information-ordering biases to hidden states in RNNs (Shen et al., 2019b) or even adding additional structural or recursive constraints to

Original: Transformers (Wang et al., 2019; Nguyen et al., 2020; Fei et al., 2020; Shen et al., 2021; Csord´as et al., 2022).
Revised: Transformers (Wang et al., 2019; Nguyen et al., 2020; Fei et al., 2020; Shen et al., 2021; Csord´as et al., 2022).

Original: [Table]
Revised: [Table]

Original: G L IMITATIONS AND F UTURE W ORKS
Revised: G L IMITATIONS AND F UTURE W ORKS

Original: The ideal future direction would be to extend to methods which generalize better in all aspects while maintaining computational efficiency and at the same time having a more flexible architecture for handling more free structures like non-projective trees or directed acyclic graphs and also richer classes of languages (DuSell & Chiang, 2022; Del’etang et al., 2022).
Revised: The ideal future direction would be to extend to methods which generalize better in all aspects while maintaining computational efficiency and at the same time having a more flexible architecture for handling more free structures like non-projective trees or directed acyclic graphs and also richer classes of languages (DuSell & Chiang, 2022; Del’etang et al., 2022).

Original: Another direction to explore would be to linearize the recursion particularly taking inspiration from state space models (Gu et al., 2022) to make these models more scalable.
Revised: Another direction to explore would be to linearize the recursion particularly taking inspiration from state space models (Gu et al., 2022) to make these models more scalable.

Original: H H YPERPARAMETERS
Revised: H H YPERPARAMETERS

Original: For all recursive/recurrent models, we use a linear layer followed by layer normalization for initial leaf transformation before starting the recursive loop (similar to Shen et al. (2019a); Chowdhury &
Revised: For all recursive/recurrent models, we use a linear layer followed by layer normalization for initial leaf transformation before starting the recursive loop (similar to Shen et al. (2019a); Chowdhury &

Original: Caragea (2021)).
Revised: Caragea (2021)).

Original: Overall we use the same boilerplate classifier architecture for classification and the same boilerplate sentnece-pair siamese architecture for logical inference as Chowdhury & Caragea (2021) over our different encoders.
Revised: Overall we use the same boilerplate classifier architecture for classification and the same boilerplate sentnece-pair siamese architecture for logical inference as Chowdhury & Caragea (2021) over our different encoders.

Original: In practice, for BT-Cell, we use a stochastic top-k through gumbel perturbation similar to Kool et al.
Revised: In practice, for BT-Cell, we use a stochastic top-k through gumbel perturbation similar to Kool et al.

Original: However, we find deterministic selection to work similarly.
Revised: However, we find deterministic selection to work similarly.

Original: In terms of the optimizer, hidden size, and other hyperparameters besides dropout, we use the same ones as used by (Chowdhury & Caragea, 2021) for all models for corresponding datasets; for number of memory slots and other ordered memory specific parameters we use the same ones as used by (Shen et al., 2019a).
Revised: In terms of the optimizer, hidden size, and other hyperparameters besides dropout, we use the same ones as used by (Chowdhury & Caragea, 2021) for all models for corresponding datasets; for number of memory slots and other ordered memory specific parameters we use the same ones as used by (Shen et al., 2019a).

Original: For BSRP-Cell we use a beam size of 8 (we also tried with 5 but results were similar or slightly worse).
Revised: For BSRP-Cell we use a beam size of 8 (we also tried with 5 but results were similar or slightly worse).

Original: We use a dropout rate of 0 . 1 for logical inference for all models (tuned on the validation set using grid search among [0 . 1 , 0 . 2 , 0 . 3 , 0 . 4] with 5 epochs per run using
Revised: We use a dropout rate of 0 . 1 for logical inference for all models (tuned on the validation set using grid search among [0 . 1 , 0 . 2 , 0 . 3 , 0 . 4] with 5 epochs per run using

Original: BalancedTreeCell for GRC-based models and GumbelTreeLSTM for LSTM based models).
Revised: BalancedTreeCell for GRC-based models and GumbelTreeLSTM for LSTM based models).

Original: We use dropouts in the same places as used in (Chowdhury & Caragea, 2021).
Revised: We use dropouts in the same places as used in (Chowdhury & Caragea, 2021).

Original: We then use the same chosen dropouts for ListOps.
Revised: We then use the same chosen dropouts for ListOps.

Original: We tune the dropouts for SST in the same way (but with a maximum epoch of 20 per trial) on SST5 using RecurrentGRC for GRC-models, and Gumbel-Tree-LSTM for
Revised: We tune the dropouts for SST in the same way (but with a maximum epoch of 20 per trial) on SST5 using RecurrentGRC for GRC-models, and Gumbel-Tree-LSTM for

Original: LSTM models.
Revised: LSTM models.

Original: After tuning, for GRC-based models in SST5, we found a dropout rate of 0 . 4 for input/output dropout layers, and 0 .
Revised: After tuning, for GRC-based models in SST5, we found a dropout rate of 0 . 4 for input/output dropout layers, and 0 .

Original: 2 for the dropout layer in the cell function.
Revised: 2 for the dropout layer in the cell function.

Original: We found a dropout of 0 .
Revised: We found a dropout of 0 .

Original: 3 for LSTM-based models in SST5.
Revised: 3 for LSTM-based models in SST5.

Original: and We share the hyperparameters of SST5 with SST2 and
Revised: and We share the hyperparameters of SST5 with SST2 and

Original: IMDB.
Revised: IMDB.

Original: For MNLI, we used similar settings as Chowdhury & Caragea (2021).
Revised: For MNLI, we used similar settings as Chowdhury & Caragea (2021).

Original: For NDR experiments, we use the same hyperparameters as used for ListOps by Csord´as et al.
Revised: For NDR experiments, we use the same hyperparameters as used for ListOps by Csord´as et al.

Original: The hyperparameters will also be available in code.
Revised: The hyperparameters will also be available in code.

Original: All codes are run in a single RTX A6000 GPU.
Revised: All codes are run in a single RTX A6000 GPU.