The structure-building system

In language, sentences are associated with particular meanings (i.e., sentences are pairings of form and meaning). For example, in the sentence (i) “Emily will visit John,” “Emily” is the one doing the visiting and “John” is the one being visited. Their roles are not understood the other way around. Linguists usually assume that such form-meaning pairs are established because our brains possess a computational system (structure-building system) that generates hierarchical structures pairing form and meaning. In hierarchical structures, some elements are positioned higher or lower than others (this will be explained in more detail). There are several reasons for assuming the existence of hierarchical structures. Some of the reasons are that form does not seem to map directly to meaning and that hierarchical structure allows us to derive meaning systematically from form. For example, in the sentence (ii) “The man behind Emily will visit John,” “The man…” is the visitor and “John” is the visitee. “Emily” is not understood as the visitor despite the fact that it is closer to “visit” than “The man” in the surface order and that the part (<…>) of (ii) “The man behind <Emily will visit John>” has exactly the same form as (i) where “Emily” is understood as the visitor. The form-meaning pair in (ii) can be established in such a way that, in the corresponding hierarchical structure, “The man…” and “visit John” are related in the same way as “Emily” and “visit John” in (i), enabling a systematic derivation of meaning.

It is generally assumed that the structure-building system is distinct from the processor that computes syntactic structures (i.e., the parsing system).Footnote ¹ The structure-building system generates syntactic structures in an unbounded way, following a set of rules, and these structures pair form and meaning. The processor computes syntactic structures in real time (using the structure-building system) as it receives strings or sounds, in order to derive meaning. Assuming that the structure-building system and the L1 processor output the same or similar syntactic expressions, we will formally model the syntactic structures computed during real-time sentence processing based on the structure-building system. If the L1 and L2 processors compute different syntactic structures, the L2 syntactic structures may not adhere to the constraints followed by the L1 syntactic structures.

This paper adopts the structure-building system assumed within the framework of principles and parameters (Chomsky, Reference Chomsky1981; Haegeman, Reference Haegeman1994; Hornstein, Nunes & Grohmann, Reference Hornstein, Nunes and Grohmann2005; van Riemsdijk & Williams, Reference van Riemsdijk and Williams1986). In this framework, syntactic structures take the form of rooted binary trees, as shown in Figure 1, where the top node (X1) is the root. Trees are mathematical objects consisting of a set of nodes carrying specific information (e.g., X1–X7 in Figure 1) and a set of edges connecting these nodes (e.g., the path connecting X1 and X2 in Figure 1). A tree is a rooted binary tree if each node has an outdegree of at most two (i.e., if each node has at most two children; see Footnote footnote 2 for the definition of children in the context of trees) and all nodes other than the root are directed away from the root. The structure of a rooted binary tree is hierarchical, with the root in the highest position and other nodes considered to be lower in position as they move away from the root (i.e., the more edges you traverse from the root to a node, the lower that node is positioned). For example, in the syntactic structure in Figure 1, X2 is in a higher position than X4 because only one edge needs to be traversed from X1 to X2, whereas two edges need to be traversed from X1 to X4.

Figure 1.

Mappings from form to syntactic structure and from syntactic structure to meaning.

Within the framework of principles and parameters, syntactic structures are constructed as each head node—a grammatical category mapped from a word (e.g., a V node mapped from the verb “bake”)—combines with other nodes. This structure building follows the X-bar schema (Chomsky, Reference Chomsky1981; Kornai & Pullum, Reference Kornai and Pullum1990; Stowell, Reference Stowell1981). The X-bar schema can be expressed as a set of production rules, where each rule serves as a conditional statement connecting nodes. These rules follow the format X → Y, where X and Y are nodes and the arrow represents a directed edge from X to Y.Footnote ² The set of production rules is shown in (1) below, and the corresponding syntactic structure is shown in Figure 2.

Figure 2.

The X-bar schema.

In (1), W, X, Y, and Z are variables. In the X-bar schema, there are generally three levels of projection. X represents a minimal projection, a head node (i.e., a grammatical category mapped from a word). A projection is defined as a structural unit containing this head node. The prime symbol (′) denotes an intermediate projection (second level of projection), and P denotes a maximal projection (third level of projection). W, Y, and Z are optional nodes, each of which is a maximal projection (but not a projection of X). These nodes are called the complement (COMP) of X, an adjunct of XP, and the specifier (SPEC) of XP, respectively. Explicit rules for generating the syntactic structure of the sentence “Emily will visit John” are given below as an example.

In (2), the parentheses indicate positions without nodes. N stands for noun (“Emily,” “John”), V for verb (“visit”), and T for tense (“will”). Figure 3 shows the computation of the subject NP structure, where (2b) is applied first and then (2c). Figure 4 shows the whole sentence structure, together with the syntactic structure of the sentence “The man behind Emily will visit John.”

Figure 3.

The computation of the subject NP. In this example, the computation runs top down.

Figure 4.

The syntactic structures of the sentences “Emily will visit John” and “The man behind Emily will visit John.” [_NP Emily] in the left tree and [_NP The man…] in the right tree are related to [_VP visit John] in the same way: [_VP visit John] is dominated by the TP node that immediately dominates [_NP Emily]/[_NP The man…]. In the right tree, there is no such relation between [_NP Emily] and [_VP visit John].Footnote ^3, Footnote ⁴

Memory retrieval

Memory retrieval is the process of bringing back information stored in memory. This process is often assumed to play an important role in the interpretation of nodes in relation to other nodes to which they are grammatically related during real-time sentence processing (e.g., Dillon, Mishler, Sloggett & Phillips, Reference Dillon, Mishler, Sloggett and Phillips2013; Fujita, Reference Fujita2025; González Alonso, Cunnings, Fujita, Miller & Rothman, Reference González Alonso, Cunnings, Fujita, Miller and Rothman2021; Jäger, Mertzen, Van Dyke & Vasishth, Reference Jäger, Mertzen, Van Dyke and Vasishth2020; Wagers, Lau & Phillips, Reference Wagers, Lau and Phillips2009). Such grammatical relations are often called dependency relations (e.g., Chomsky, Reference Chomsky1956; J. D. Fodor, Reference Fodor1978). For example, in (3) below, the reflexive NP [_NP herself] is referentially related to the subject NP of the embedded clause [_NP the girl].Footnote ⁵

It is often assumed that during real-time sentence processing, the reflexive NP is interpreted by retrieving information about the embedded subject NP from memory and associating this information with [_NP herself] (Dillon et al., Reference Dillon, Mishler, Sloggett and Phillips2013; Fujita & Yoshida, Reference Fujita and Yoshida2024; Jäger et al., Reference Jäger, Mertzen, Van Dyke and Vasishth2020). Therefore, memory retrieval is often considered to be part of, or to subserve, the computational processes involved in real-time sentence interpretation.

To formally model memory retrieval, we will use the activation-based model of memory retrieval (activation model; Fujita, Reference Fujita2024a; Lewis & Vasishth, Reference Lewis and Vasishth2005; Vasishth & Engelmann, Reference Vasishth and Engelmann2021). This model is based on the Adaptive Control of Thought–Rational (ACT-R) architecture (Anderson, Reference Anderson2007) and makes several assumptions about sentence processing. These assumptions are listed in Table 1 (adapted in part from Lewis & Vasishth, Reference Lewis and Vasishth2005).

Table 1.

Key assumptions about sentence processing in the activation model

Of these assumptions, A5 can be better understood through an example. Thus, let us consider memory retrieval at “herself” in (3) again. Focusing on lexical information, the critical features associated with this reflexive are grammatical category (N), number (singular), and gender (feminine). Roughly speaking, a feature is a fundamental building block of a syntactic object (e.g., the features “N,” “singular,” and “feminine” are constituents of the element mapped from “herself”).Footnote ⁶ Suppose that the grammatical category, number, and gender features are used as retrieval cues. In (3), only [_NP the girl] matches all of these cues.Footnote ⁷ Consequently, the activation model predicts that [_NP the girl] receives the highest activation during the antecedent retrieval if we only consider matches with these retrieval cues. During memory retrieval, the element (node) with the highest activation that reaches a retrieval threshold is retrieved, with higher activation leading to shorter retrieval times. The calculation of activation values and retrieval times follows the equations summarised in Table 2.

Table 2.

Equations for the calculation of activation values and retrieval times in the activation model

Note: $ \mathrm{i} $ = element, $ \mathrm{j} $ = cue.

In the equations, many letters serve as symbolic representations of numerical values, just as numbers do. Some symbols are constants, meaning their values are fixed (e.g., $ \pi \approx 3.141593 $ ). Many other symbols are variables, meaning their values are not fixed. The values of these variables are determined in different ways. For some variables, the values are determined by some equations. For others, the values depend on the underlying assumptions. Input values are also sometimes estimated from the data that the model is used to predict, by fitting it to the data with different values and finding the values that fit best. While this data-driven estimation is useful when there is no clear basis for determining input values, it does not allow the model to fully fulfil its role (i.e., to facilitate our understanding of the object of interest). Therefore, although the model under development may rely on data-driven estimation, there should ultimately be a basis for each input value. The choice of input values affects the output of the model. The bullet points below provide detailed descriptions of the equations and explain how different input values affect the model output.

• • Total activation is calculated by summing base-level activation, spreading activation, mismatch penalty, and noise. Retrieval times are calculated using this total activation.

• • Base-level activation is calculated by summing $ n $ retrievals of the element. In the equation, $ t $ represents the time elapsed since the $ k $ th retrieval of the element and is raised to the power of the negated decay rate $ d $ . The parameter $ b $ represents a resting level of activation. The power function reflects the assumption that forgetting is initially fast but slows down over time (power law of forgetting; Wickelgren, Reference Wickelgren1974). Thus, the activation of each element in memory undergoes exponential decay. The decay rate $ d $ controls the rate of forgetting. Figure 5 illustrates the fluctuations in the base-level activation of [_NP the girl] in (3) over time.Footnote ⁸

• • Spreading activation is calculated by summing the products of weights and associative strengths between retrieval cues and elements. Weights refer to the relative influence of cues; a cue with a higher weight has a greater impact on activation. Weights are calculated using the equation $ G/n $ , where $ G $ is the amount of activation divided by the number of cues. By default, $ G $ is set to $ 1 $ , and all cues are given the same weight. For example, if there are three cues, $ A $ , $ B $ , and $ C $ , each cue will have a weight of $ 1/3 $ . If one of the cues (e.g., $ A $ ) is deemed more influential, it can be given a greater weight (e.g., $ A=3/5 $ , $ B=1/5 $ , $ C=1/5 $ ).

• • Associative strength indicates the degree of association between a cue and an element, reflecting the reliability of the cue in retrieving the element from memory. As the number of elements in memory that match a given cue increases, the degree of association between the cue and each element decreases. This is known as the fan effect (Anderson, Reference Anderson1974). The strength of association is expressed as the conditional probability of the occurrence of a particular element $ i $ given the presence of a particular cue $ j $ . The standard assumption in sentence processing research is that all elements associated with a cue are equally likely when the cue is present. Under this assumption, $ P\left(i|j\right) $ is the reciprocal of the number of elements in memory that match the cue. For example, considering the number cue at the reflexive in (3), both [_NP the girl] (target) and [_NP John] (a distractor) match this cue (i.e., they are both singular).Footnote ⁹ Therefore, for $ {S}_{number, target} $ , $ P\left(i|j\right)=1/2 $ , resulting in a reduced associative strength compared to when the distractor does not match the number cue (in which case $ P\left(i|j\right)=1 $ ). The associative strength is calculated by summing this value and the maximum associative strength (maximum activation that an element could have). The fan effect is illustrated in Figure 6.

• • Mismatch penalty penalises elements that mismatch a set of retrieval cues. By default, the similarity ( $ {M}_{ji} $ ) ranges from $ 0 $ (identity) to $ -1 $ (maximum difference). For example, if the gender cue is used for antecedent retrieval at “herself” in (3), [_NP John] incurs a mismatch penalty because its conventionally assigned gender (masculine) does not match the gender of the reflexive (feminine). The parameter $ p $ is used to scale the mismatch penalty. Scaling is a way of adjusting the output of the model. For example, increasing the value assigned to $ p $ results in a larger mismatch penalty.

• • Noise is included in the activation model to consider the variability of human behaviour. Human performance is not perfectly accurate and can be affected by factors such as distraction and background noise. The noise function is used to reflect this variability. It generates random values within a certain range, with $ 0 $ being the most probable value and the probability decreasing as the value moves away from $ 0 $ . The exact range depends on the scaling parameter $ {x}^2 $ . This probability distribution (normal distribution) is shown in Figure 7.

• • Retrieval times are calculated as the product of a scaling parameter and a negative exponential function, where the exponent is determined by the scaled total activation. Because of this negative exponential function, higher activation leads to shorter retrieval times, as illustrated in Figure 8.

Figure 5.

Fluctuation of the base-level activation of [_NP the girl] in (3) over time (see Footnote footnote 8). Two peaks correspond to retrievals at “girl” (from long-term memory) and “herself” (from short-term memory).

Note: b = 0, d = .5.

Figure 6.

The fan effect.

Figure 7.

Stochastic noise.

Note: x = .2.

Figure 8.

The retrieval time function.

Note: F = .2, f = .1.

In this section, we have reviewed the structure-building system and the activation model. In the following sections, we will use these to formalise two hypotheses about L2 sentence processing: the shallow structure hypothesis (SSH; Clahsen & Felser, Reference Clahsen and Felser2006b) and the interference-based hypothesis (IBH; Cunnings, Reference Cunnings2017b). These hypotheses have been proposed to explain the differences observed in previous studies between L1 and L2 processors (L1/L2 differences). The SSH proposes that L1/L2 differences arise because the L1 and L2 processors compute different syntactic structures in certain contexts and rely on non-structural information differently. The IBH claims that L1/L2 differences arise because the L1 and L2 processors weight retrieval cues differently when retrieving an element from memory during sentence processing. The SSH and the IBH can be seen as competing hypotheses because they attempt to explain L1/L2 differences in different ways. However, they can also be considered complementary if the source of L1/L2 differences relates to both parsing and memory retrieval. For each hypothesis, we will first model the syntactic structures computed by the processor and then the memory retrieval processes. We will start with the formalisation of the SSH.

Verbal descriptions of the SSH

The SSH proposes that divergent processing patterns emerge between the L1 and L2 processors because, under certain circumstances, they compute different syntactic structures during real-time processing. This proposition is consistently expressed in the papers dedicated to the SSH:

The SSH also claims that L2 sentence processing is strongly influenced by non-structural information:

However, the SSH argues that the L2 processor does compute hierarchical syntactic structures during real-time processing:

In summary, the SSH claims that hierarchical syntactic structures are computed during real-time L2 sentence processing. However, these structures lack certain properties, such as movement traces (to be illustrated briefly), that are present in the syntactic structures computed by the L1 processor. Consequently, the L2 processor relies heavily on non-structural information for sentence interpretation.

The verbal descriptions above effectively convey the claims of the SSH. However, the specific syntactic structures computed by the L2 processor are unclear. This lack of clarity may have led to misunderstandings of the SSH in previous research. For example, Omaki and Schulz (Reference Omaki and Schulz2011) interpret the SSH as predicting that “they [L2 learners] should not respect the RC [relative clause] island constraint [a structure-relevant constraint] because there is no RC representation in their analysis” (Omaki & Schulz, Reference Omaki and Schulz2011, p. 570). Clahsen and Felser (Reference Clahsen and Felser2018) argue that the SSH does not make such a claim. However, Omaki and Schulz’s interpretation does not appear to be entirely inconsistent with some of the descriptions above. This misinterpretation could have been avoided if the SSH had presented the specific syntactic structures computed by the L2 processor.

In the following subsections, we will first formally model the syntactic structures computed by the L2 processor based on the claims of the SSH. We will then model the L2 memory retrieval processes, calculate the processing times, and compare them with the actual data used to support the SSH.

The SSH: Formal modelling of syntactic structures

For the formal modelling of syntactic structures, we consider the relative clauses in (4a/b) below.

In (4a/b), “who,” which marks the beginning of the relative clause, is locally ambiguous because it can be analysed locally as modifying either the plural nominal [fans] (NP1 modification) or the singular nominal [actress] (NP2 modification). In (4a), only the NP1 modification becomes grammatical at “were” because [fans], but not [actress], matches this verb in number. In (4b), on the other hand, only the NP2 modification becomes grammatical at “was” because this verb forms a dependency relation with a singular NP. The following production rules generate the relative clause structures computed by the L1 processor (the vertical bar “|” denotes alternatives)Footnote ¹⁰:

In (5), D stands for determiner (“the”), the category “P” for preposition (“of”), and C for complementiser. To formally model the relative clause structures, we use the Natural Language Toolkit (NLTK) Python package (for installation instructions, visit https://www.nltk.org/install.html). Python is a programming language and can be downloaded from https://www.python.org/downloads/. Although NLTK is a Python package, this paper uses it in the R environment, given its widespread use in L2 research. All the code used in this paper can be found on the Open Science Framework (OSF) website (https://doi.org/10.17605/OSF.IO/9VCX7) and in the R notebook on Colab (https://colab.research.google.com/drive/1zjl1Mc7Sn8d-IfeeB340bErt_fXJ-lJH?usp=sharing). Python code can be executed in R by loading the reticulate package into RFootnote ^11, Footnote ¹²:

The reticulate package provides an interface between R and Python. In the NLTK package, the nltk.Tree module with its .fromstring() method allows us to compute tree structures. For example, the tree structure of the production rule (5a) can be computed as “[NP DP N′]”:

The import nltk code imports the NLTK library. The nltk.Tree.fromstring() function outputs a tree structure from [NP DP N′]. The argument brackets = “[]” tells Python that square brackets are used to specify the tree structure. Python is an object-oriented programming language, where an object needs to be created to store a tree. In the code above, the equals sign “=” directs Python to assign the tree to the object T1.

In the bracketing rule used, the parent node (i.e., NP) appears first, followed by the two children (i.e., DP and N′), which are enclosed in the same bracket (see Footnote footnote 2 for definitions of parent and child in the context of trees). The left child (DP) precedes the right child (N′) according to the production rule (5a). The content of the object can be checked by typing in the name of the object:

In R (and Python), anything written after a hash symbol on the same line is ignored when the code is executed. The double hashes above indicate the code’s output. The following code prints a visually formatted treeFootnote ¹³:

In this code, the object to be visualised is specified at the beginning, and the pretty_print() function is called on it to print a visually formatted tree. The following is another example where an NP structure is displayed:

Although the bracket structure in this code may look complicated, it follows the same pattern as the previous example. The ε symbols denote empty strings. To improve clarity and ease of visualisation, empty strings and positions not occupied by nodes will be omitted where possible. For the same reason, minimal and intermediate projections will also be omitted where possible. We now formally model the syntactic structures for the NP1 and NP2 modifications, which are assumed to be computed by the L1 processor (see Footnote footnote 10).

NP1 modification:

NP2 modification:

In these syntactic structures, the relative clause [_CP who was/were…] adjoins to either the projection of the higher nominal (NP1 modification) or the projection of the lower nominal (NP2 modification). Differences in modification are thus expressed by different positions to which the relative clause adjoints. The symbol t (t1), called a trace, denotes an unpronounced copy of an element in the syntactic structure. Within the framework of principles and parameters, traces are used to explain the phenomenon that expressions are interpreted as if they were in different positions from where they overtly appear.Footnote ¹⁴ Traces are generated when elements move during structure building. For example, in the relative clause structures above, [_NP1 who] moves from the specifier of the TP to the specifier of the CP, and a trace is left in the former position. [_NP who] and the trace are co-indexed by 1 to identify the trace. These elements are referentially related to either [fans] (NP1 modification) or [actress] (NP2 modification).

Felser et al. (Reference Felser, Roberts, Marinis and Gross2003) used self-paced reading tasks to investigate whether L1 and L2 speakers prefer the NP1 or NP2 modifications at the point of local ambiguity. In (4a/b), if there is a preference for the NP1 modification, the processing time at the auxiliary verb is expected to be longer in (4b) than in (4a) due to the number mismatch between [fans] and [was] (mismatch effects; Dillon et al., Reference Dillon, Mishler, Sloggett and Phillips2013; Fujita & Cunnings, Reference Fujita and Cunnings2023; Wagers et al., Reference Wagers, Lau and Phillips2009). In contrast, preferences for the NP2 modification are expected to lead to mismatch effects in (4a). For L1 participants, Felser et al. observed mismatch effects in (4a), suggesting that L1 speakers locally prefer the NP2 modification. However, L2 participants showed similar processing times between (4a) and (4b), suggesting a lack of specific preferences. These different processing patterns are illustrated in Figure 9.

Figure 9.

Processing times at the auxiliary verb in (4a/b) as reported in Felser et al. (Reference Felser, Roberts, Marinis and Gross2003). The L2 data are based on Experiment 2. Error bars are approximate standard errors.

The SSH interprets these findings as follows: The L1 processor employs a parsing strategy whereby it analyses incoming material (e.g., “who”) as related to the structure of the most recently encountered word (e.g., the projection of the lower nominal; see Frazier, Reference Frazier1979; Fujita, Reference Fujita2021, Reference Fujita2024b; Kimball, Reference Kimball1973; Phillips & Gibson, Reference Phillips and Gibson1997). In contrast, the L2 processor does not employ such a strategy due to the absence of fully detailed syntactic structures:

In this quotation, the term “chunk” introduces an ambiguity that allows for different interpretations. One possible syntactic structure computed by the L2 processor, which is not endorsed by the SSH but aligns with its verbal descriptions, is shown below:

In (6), the symbol X is an arbitrary node. The syntactic structure of T5 is hierarchical, as claimed by the SSH. However, the relative clause does not adjoin to either the higher or the lower nominal, and there is no trace. Regarding the parsing process, we can assume the following: “the fans of the actress” is first computed as a ternary tree, such as [_XP [_NP the fans] [_PP of] [_NP the actress]], forming a single chunk, as claimed by the SSH. When “who” appears, the relative clause structure is analysed as another child of XP, resulting in the quaternary tree.Footnote ¹⁵ As noted above, this structure is not necessarily what the SSH claims the L2 processor computes. It is presented here as a hypothetical structure to demonstrate formal modelling, following the descriptions of the SSH. In the following subsection, we will model L2 memory retrieval processes, assuming that T5 is the relative clause structure computed by the L2 processor within the SSH framework.

The SSH: Formal modelling of memory retrieval processes

We formally model L2 memory retrieval processes at the auxiliary verb in (4a/b) using the activation model. Recall that this model assumes that lexical and structural information are used as retrieval cues. In (4a/b), we can assume that the auxiliary verb triggers the memory retrieval of the subject NP, given that these elements are grammatically related.Footnote ¹⁶

In this memory retrieval process, we focus on two cues: the number cue and the (grammatical) category cue. The number cue is based on the fact that the verb agrees with the subject NP in number. In (4a/b), the auxiliary verbs “was” and “were” are marked as singular and plural, respectively. We assume that this number feature is used as a retrieval cue (Wagers et al., Reference Wagers, Lau and Phillips2009). The grammatical category is a possible cue, given that an auxiliary verb often forms a subject-verb dependency with an NP. Note that a subject-verb dependency is established within a local configuration in the syntactic structure. While this structural information is crucial for the L1 processor, within the SSH framework, we can hypothesise that it is not important for the L2 processor in relative clauses such as those in (4a/b). Therefore, we do not consider the structure-based cue for L2 memory retrieval.

In the activation model, each element has an activation value, determined by base-level activation, spreading activation, mismatch penalty, and noise. To simplify the calculation of activation values, we make two assumptions. Firstly, each word in long-term memory has an activation value of 0 prior to the first retrieval. Secondly, the L2 processor takes 300 ms to process each word up to the auxiliary verb. Thus, in (4a/b), we assume that the L2 processor takes 1200 ms to reach the auxiliary verb from “fans” and 300 ms from “actress.”

With these assumptions, we first calculate the base-level activation. Recall that base-level activation is related to previous retrievals and time-dependent decay and is expressed by the equation $ {b}_i+\mathit{\ln}\left(\sum \limits_{k=1}^n{t_k}^{-d}\right) $ . For our modelling, the decay rate ( $ d $ ) is set to the default value of $ .5 $ . The default value is used because we know little about how quickly information about encountered words decays during real-time sentence processing.Footnote ¹⁷ The parameter $ t $ , representing the time elapsed since the $ k $ th retrieval of the element, is set to $ 1.2 $ for NP1 and $ .3 $ for NP2 (see Footnote footnote 8). The resting level of activation $ b $ is set to $ 0 $ . With these values, the base-level activations of NP1 and NP2 can be calculated in R as followsFootnote ¹⁸:

Like Python, R is an object-oriented programming language. In the above code, the arrow operator <- assigns a value (e.g., 0) on the right-hand side to the variable on the left-hand side (e.g., b). The sum() function sums the values of all retrievals for each NP. The input to this function is the time elapsed since the $ k $ th retrieval of the element, raised to the power of the decay rate. There is only one input value because there is only one retrieval before the auxiliary verb appears. The output of the sum() function is then passed to the log() function to obtain its natural logarithm. Recall that in R, anything written after a hash symbol on the same line is ignored when the code is executed. In this paper, a single hash is used to provide a brief description of code.

Next, we calculate the associative strength. The associative strength is influenced by whether the element matches the cue, and by how many matching elements there are. Cue matches and mismatches with NP1 and NP2 are summarised in Table 3.

Table 3.

Cue matches and mismatches with NP1 and NP2 in L2 sentence processing

In our model, a match is assigned $ 1 $ , and a mismatch is assigned $ 0 $ . The fan effect occurs for the category cue because NP1 and NP2 belong to the same grammatical category. For (4a), the following code encodes this cue match and mismatch information:

Here, the values 1, 0, 1, 1, representing either a cue match or a cue mismatch, are combined into a vector using c() to create a matrix. The argument ncol = 2 specifies that the matrix should have two columns. These matrix values are then used to quantify the fan effect and compute the associative strength ( $ \mathit{\ln}\left(P\left(i|j\right)\right) $ ) for (4a):

The code Cue_Mx_4a[1,] indicates the first row of the matrix (NP1’s values; $ 1 $ $ 1 $ ), while Cue_Mx_4a[2,] indicates the second row (NP2’s values; $ 0 $ $ 1 $ ). The / symbol represents a division. The code in the log() functions therefore calculates the proportion of the values in either the first or second row in relation to the sum of the values in both rows. The fan effect occurs when both NP1 and NP2 are $ 1 $ . A small value (0.0001) is added to avoid taking the logarithm of zero ( $ \mathit{\log}(x) $ is only defined for $ x>0 $ ). The resulting values are then combined with the maximum associative strength ( $ m+\mathrm{ln}(P(i|j)) $ ):

The maximum associative strength is set to a high value, as NP1 and NP2 potentially match other cues, which are not used in this modelling for expository reasons. Next, we calculate the spreading activation ( $ {\sum \limits}_{j=1}^n{W}_j{S}_{ji} $ ):

Here, the amount of activation (G) and the distribution ratio (0.5, 0.5) are first set. The length() function is then used to return the number of elements in the CueWeight vector to set the number of cues. In the first matrix() function, the amount of activation is multiplied by each element in the CueWeight vector to set the value of $ W $ . The rowSums() functions calculate the sum of the element-wise product of the cue weight and the associative strength. We then calculate the mismatch penalty (i.e., $ {\sum \limits}_{j=1}^np{M}_{ji} $ ):

In this calculation, matched combinations are assigned $ 0 $ , and mismatched combinations are assigned $ -1 $ . This is done by subtracting $ 1 $ from the values in the matrix representing the cue matches ( $ 1 $ ) or mismatches ( $ 0 $ ). We now combine the base-level activation, the spreading activation, and the mismatch penalty to calculate the total activation without noise:

The noise component is a normally distributed random variable (i.e., $ Normal\left(0,\sqrt{\frac{\pi^2}{3}{x}^2}\right) $ ) that randomly affects the total activation. If one wants to look at the fixed output of the model, the total activation without noise can be used. We can also approximate this by generating many data points from the noise function and calculating the mean retrieval time. This approach allows us to consider variability in human behaviour. In R, the rnorm() function can be used to generate random numbers from a normal distribution:

In the rnorm() functions, 5000 is the number of data points to generate, 0 is the mean of the distribution, and sqrt(pi^2 / 3 * x^2) is the standard deviation of the distribution. The head() functions display the first six data points. The data points for NP1 and NP2 differ because the rnorm() function generates random numbers. The following code combines the total activations with each data point from the rnorm() functions:

We now have 5,000 activation values for each of NP1 and NP2 in (4a). Let us first check which NP has higher activation values:

The first line of this code calculates the number of times TA_NP1_4aNoise is greater than (>) TA_NP2_4aNoise, and the second line calculates the number of times they are equal (==). The third line uses the length() function to get the total number of trials (i.e., 5,000). The cat() functions tell us how many times TA_NP1_4aNoise is greater than or equal to TA_NP2_4aNoise. Since these functions show that NP1 always has a higher activation than NP2, we focus on NP1.

Next, we examine the retrieval status of NP1. Recall that in the activation model, successful retrieval only occurs when the element with the highest activation reaches a retrieval threshold. The following code checks the retrieval status of NP1:

The retrieval threshold is set to the default value of – $ 1.5 $ . The default value is used because little is known about what threshold is appropriate for memory retrieval during sentence processing. The pmax() function compares the two input vectors (i.e., TA_NP1_4aNoise and TA_NP2_4aNoise), each containing 5,000 activation values of either NP1 or NP2 in (4a), and returns the maximum value at each position. As NP1 always has a higher activation value, the output of this function only contains the activation values of NP1. In the sum() function, the >= operator is used to check whether each activation value in TA_NP1_4aNoise is greater than or equal to the retrieval threshold. The cat() function shows that NP1 is always retrieved (i.e., its activation value is always greater than or equal to the retrieval threshold). Finally, we calculate the retrieval times of the 5,000 trials using the equation $ F{e}^{-\left(f\bullet {TA}_i\right)} $ :

The exp() function calculates the value of e raised to the power of (-le * TA_4aNoise). The resulting value is multiplied by 1000 for interpretive purposes. The mean() function shows that the average retrieval time at the auxiliary verb in (4a) is approximately 140 ms.

We have formally modelled L2 memory retrieval processes in (4a). The next step is to do the same for (4b) and for L1 memory retrieval processes. The code for (4b) is identical except for cue matches and mismatches (see Table 3). The formal modelling of L1 memory retrieval processes needs to take into account the following factors: a preference for the NP2 modification, the presence of the trace, and the structure-based cue. The details are omitted here for space reasons, but the code is available on the OSF website and in the R notebook on Colab.

In this subsection, we have focused on memory retrieval processes. However, as mentioned earlier in this paper, sentence processing potentially involves several other processes. To take these processes into account without actually modelling them, we simply assume the time taken by them. The activation model assumes that L1 sentence interpretation processes other than memory retrieval, such as parsing and attending to a word, take approximately 150 ms. Since L2 sentence processing usually takes longer than L1 sentence processing, we add 50 ms to this processing time for L2 sentence processing:

The final processing times are shown in Figure 10, juxtaposed with the data from Felser et al. (Reference Felser, Roberts, Marinis and Gross2003) and the results of the formal modelling of L1 memory retrieval processes.

Figure 10.

The data from Felser et al. (Reference Felser, Roberts, Marinis and Gross2003) and the model outputs. Error bars are standard errors.

Overall, our model shows shorter processing times than the original data. It also shows longer processing times for the L2 group than for the L1 group, but this is a common finding in L2 sentence processing research. Importantly, our model shows the processing patterns that are largely consistent with the original data in terms of the differences between (4a) and (4b) for each language group.

In this section, we have formally modelled the relative clause structures and the memory retrieval processes in order to formalise the SSH and to demonstrate how formal modelling can be incorporated into L2 sentence processing research. In the following section, we will formalise the IBH, another hypothesis about L2 sentence processing.

Verbal descriptions of the IBH

The IBH argues that the source of L1/L2 differences processing lies in memory retrieval processes:

According to the IBH, the L2 processor is more susceptible to interference (e.g., the fan effect) than the L1 processor during memory retrieval:

The IBH claims that the L2 processor relies heavily on discourse-based information during memory retrieval:

Unlike the SSH, the IBH argues that the L2 processor computes fully detailed hierarchical structures:

However, the IBH claims that the L2 processor may be less reliant on the structure-based cue during memory retrieval than the L1 processor:

In summary, the IBH claims that the L2 processor computes fully detailed syntactic structures as does the L1 processor during real-time processing. However, the L2 processor is more susceptible to interference during memory retrieval than the L1 processor. This increased susceptibility to interference arises because the L2 processor relies heavily on discourse-based information and underweights structure-based information during memory retrieval compared to the L1 processor. This claim can be formalised using the activation model. There are, however, two approaches to incorporating the heavy weighting of discourse-based information into the activation model. The first approach, proposed by Cunnings (Reference Cunnings2017b), is to assume the existence of a retrieval cue derived from topic information on which the L2 processor relies heavily (Cunnings, Reference Cunnings2017b, p. 670).Footnote ¹⁹ The second approach is to assume that information about discourse prominent elements fades slowly from memory, or that such elements have a constant activation value. The former can be expressed by using cue weights, whereas the latter can be expressed by using the base-level activation equation. There are several issues with the former approach (Dillon, Reference Dillon2017; Jacob, Lago & Patterson, Reference Jacob, Lago and Patterson2017). For example, an element does not necessarily become a topic when it is first encoded, and although discourse-based information may influence sentence processing, it does not necessarily constrain dependency relations. Despite these issues, we adopt the former approach to properly formalise the IBH by making the following assumptions:

1. (a) The L2 processor analyses the first NP it encounters as a topic, encodes this information as a feature alongside other information about the NP, and updates this topic feature in some way as needed during real-time processing.

2. (b) The L2 processor always uses topic as a retrieval cue.Footnote ²⁰

While these assumptions are not endorsed by the IBH, they are not inconsistent with its claims and help to address the issues raised.

Cunnings (Reference Cunnings2017b) discusses various studies to support the IBH. Among these is Felser, Sato and Bertenshaw (Reference Felser, Sato and Bertenshaw2009), who conducted an experiment to investigate real-time reflexive resolution using sentences such as the following:

In principle, a reflexive corefers with an NP at a specific position in the syntactic structure (Chomsky, Reference Chomsky1981). Due to this structural constraint, in (7a/b), only NP2 is structurally accessible for coreference with the reflexive. Therefore, NP2 is the target for antecedent retrieval at the reflexive, and NP1 is a distractor (see Footnote footnote 9 for definitions of target and distractor in the context of memory retrieval). The conventionally assigned gender of NP1 either matches (“John”) or mismatches (“Jane”) the gender of the reflexive. In an eye-movement-during-reading task, Felser et al. (Reference Felser, Sato and Bertenshaw2009) observed longer first-pass times at the reflexive in (7a) than in (7b) for L2 speakers, but not for L1 speakers. These processing patterns are shown in Figure 11.

Figure 11.

First-pass times at the reflexive in (7a/b) reported in Felser et al. (Reference Felser, Sato and Bertenshaw2009). Error bars are approximate standard errors.

Cunnings (Reference Cunnings2017b) interprets these findings as indicating an increased susceptibility of the L2 processor to interference from the gender-matching discourse prominent NP1 (assuming that NP1 is a topic).

The IBH: Formal modelling of syntactic structures

We now formalise the IBH, focusing on the reflexive resolution in (7a/b). As in the case of the SSH, we first model syntactic structures and then memory retrieval processes. In (7a/b), there are two finite clauses, with one embedded within the other:

Since the IBH claims that the L2 processor computes fully detailed syntactic structures like the L1 processor, we assume that the L2 processor computes T6 when given the sentences (up to the reflexive) in (7a/b).

The IBH: Formal modelling of memory retrieval processes

Assuming T6, we formally model L2 memory retrieval processes at the reflexive. The first step is to calculate the base-level activation. As in the case of the SSH, we make the following assumptions about sentence processing: Each word in long-term memory has an activation value of $ 0 $ , and each word up to the reflexive takes 300 ms to process. Therefore, our L2 processor spends 1,500 ms between “John/Jane” and “himself” and 600 ms between “Richard” and “himself.” We also assume that a finite verb does not trigger the retrieval of the corresponding subject NP for expository purposes. The decay rate is identical to that used for the SSH:

Next, we calculate the associative strength. To formalise the IBH, we need to consider three retrieval cues: structure, gender, and topic cues. According to the IBH, the L2 processor relies heavily on the topic cue and does not give the same weight to the structure cue as the L1 processor. There is ambiguity here about the specific weighting of these cues. In our model, we assume a weighting distribution of structure cue = $ 2/10 $ , gender cue = $ 3/10 $ , and topic cue = $ 5/10 $ .Footnote ²¹ Table 4 summarises matches and mismatches of the cues with NP1 and NP2 as well as the cue weights.

Table 4.

Cue matches and mismatches with NP1 and NP2 in L2 sentence processing

Note: Values in parentheses are cue weights.

As in the case of the SSH, we assign $ 1 $ to a match and 0 to a mismatch.

These values are then used to calculate the associative strength:

The resulting values are aggregated with the maximum associative strength to complete the calculation of the associative strength:

Next, we calculate the weighted spreading activation. As summarised in Table 4, in our model, the topic cue is heavily weighted, while the contribution of the structure cue is reduced, as claimed by the IBH:

The mismatch penalty is then calculated to penalise the mismatched combinations:

We now combine the base-level activation, the spreading activation and the mismatch penalty to calculate the total activation without noise.

For the noise component, we generate random numbers from a normal distribution:

In this code, we first set the scaling parameter and then create a vector containing four variables. These variables are used in the for loop. In the for loop, the assign() function assigns 5,000 random numbers, generated by the rnorm() function, to each variable. These random numbers are then combined with the corresponding total activations:

Let us now examine the outputs of the model. First, we check which NP has higher activation values in (7a) and (7b):

In (7a), NP1 always has a higher activation, while in (7b), NP2 almost always has a higher activation ( $ \frac{\left(5000-503\right)}{5000}\approx 90\% $ ). This variation in retrieval in (7b) is due to the noise function. Next, we check the retrieval status. For (7a), we focus on NP1, as its activation is consistently higher. For (7b), we examine the trials with higher activation.

Recall that the pmax() function compares the input vectors and returns the maximum value at each position. In (7a), memory retrieval is always successful, whereas in (7b), it is almost always successful (99%). The few retrieval failures in (7b) are due to the noise function. We now calculate the retrieval times of the 5,000 trials in (7a) and (7b) and add 200 ms to these retrieval times to take into account the processes of L2 sentence processing other than memory retrieval:

The results are shown in Figure 12, alongside the L2 data from Felser et al. (Reference Felser, Sato and Bertenshaw2009).

Figure 12.

The data from Felser et al. (Reference Felser, Sato and Bertenshaw2009) and the model outputs.

Although we have formalised the IBH based on its verbal descriptions, the results show different processing patterns between the data and the model outputs. Specifically, while the data show longer reading times in (7a) than in (7b), the model shows longer reading times in (7b) than in (7a).

Discrepancies between data and model output

In the previous subsection, we formalised the IBH, but the model did not produce retrieval times that were consistent with the data used to support the IBH. What accounts for this discrepancy? Looking at the unweighted spreading activations of the elements that were (almost) always retrieved, specifically NP1 in (7a) and NP2 in (7b), we can see that the former has a lower activation than the latter:

However, with the cue weights assumed by the IBH, this pattern is reversed:

This is because the heavily weighted topic cue causes the activation of NP1 from this cue to remain high in (7a) and causes the activation of NP2 from this cue to remain low in (7b). Additionally, the underweighted structure cue substantially increases the activation of NP1 in (7a), while in (7b), NP2, which matches this cue, experiences a substantial reduction in activation.Footnote ²²

Cunnings’s (Reference Cunnings2017b) interpretation of the Felser et al. (Reference Felser, Sato and Bertenshaw2009) data did not lead the model to produce the observed processing patterns. This incompatibility could have been detected if the IBH had been proposed in conjunction with formal modelling. A discrepancy between data and model output can occur for several reasons: (a) the data do not represent the object of interest (i.e., the data are unreliable), (b) the model is not properly built (e.g., the hypothesis is not properly implemented or is oversimplified), (c) the fit between the data and the model output is not properly evaluated, and (d) the hypothesis implemented by the model is incorrect. The reliability of the data can be assessed by conducting replication experiments and examining whether the results can be replicated. The model fit can be evaluated by using certain methods (some of which are discussed in the general discussion). In our case, (c) does not seem to be an issue, given that Figure 12 clearly shows different patterns between the data and the model outputs. Assuming that Felser et al.’s results are reliable and that we have properly formalised the IBH, if we wish to defend the IBH, we need to make an additional assumption about L2 sentence processing that is compatible with its claims and revise the model of syntactic structure or the model of memory retrieval accordingly. Alternatively, we could formalise the IBH in some other way. Let us consider whether revising the model of memory retrieval works. When revising a model to address a discrepancy with data, it is important to make the revision on reasonable grounds. That is, a revision should not merely be made to enable the model to predict the data better; it should be made because there is a reasonable new hypothesis about the object of interest, and the model implementing that hypothesis may explain the data (recall that the purpose of formal computational modelling is to better understand the object of interest by expressing a hypothesis about it in mathematical form). One aspect to consider about the model of memory retrieval is what occurs after the retrieval of NP1 in (7a). Since NP1 is not the target, for successful sentence interpretation, this memory retrieval must be discarded and another memory retrieval (re-retrieval) must be initiated to search for the target (Fujita, Reference Fujita2024a).Footnote ²³ As re-retrieval is an additional cognitive process, it increases processing times, which may resolve the incompatibility between the data and the model.

Before formalising this re-retrieval process, we make two assumptions about it. Firstly, when the L2 processor searches for the grammatical antecedent during re-retrieval in (7a), the topic cue is no longer used. This assumption is reasonable because the initial retrieval, in which this cue is heavily weighted, does not lead to the grammatical antecedent and because topic does not constrain the interpretation of the reflexive in (7a). Thus, in our model, re-retrieval only involves the structure and gender cues. Secondly, we assume that these cues are equally weighted during re-retrieval. This assumption is made in order to adopt a neutral stance on cue weights based on the fact that we know little about re-retrieval. Table 5 summarises these assumptions.

Table 5.

A summary of cue matches and mismatches in L2 re-retrieval processes

Note: Values in parentheses are weights.

We now need to formally model the re-retrieval process and combine the processing times of the initial memory retrieval and the re-retrieval. As the calculation process is largely the same as that for the initial retrieval, the code is omitted here for space reasons, but it can be found on the OSF website and in the R notebook on Colab. The results are shown in Figure 13.

Figure 13.

The data from Felser et al. (Reference Felser, Sato and Bertenshaw2009) and the outputs of the revised model.

Our revised model, which incorporates the re-retrieval process, shows processing patterns compatible with the Felser et al. (Reference Felser, Sato and Bertenshaw2009) data. This suggests that the IBH may require an additional assumption, such as re-retrieval, to account for Felser et al.’s observations.