At the heart of Nanosyntax lie three ontological categories: a universal sequence of functional features (or functional sequence, in line with the Cartographic approach; Rizzi 1997; Cinque 1999; Cinque & Rizzi 2010), the language-specific Lexical Items (LIs) by which the functional sequence can be lexicalised, and the Lexicalisation Algorithm dictating how the functional sequence and the language-specific LIs interact.

Since the functional sequence (fseq) is assumed to be universal, no crosslinguistic variation is encoded within this domain. Concrete syntactic derivations employ features drawn from the universal fseq, depending on the functional semantics the speaker wants to express. Each derivation must be however compliant with the universal ordering of the fseq, in that the features it combines must be merged to the structure in the order dictated by the hierarchical relations stated in the fseq.

The set of language-specific LIs form the language-specific lexicon, the locus of crosslinguistic variation. Each LI is a device that can store externalisation information (whether phonological, as often in verbal languages, or in a different format), syntactic information (a lexically stored syntactic constituent or L-tree), and semantic-conceptual information falling outside the set of functional grammatical features. This is schematized in (6).

The Lexicalisation Algorithm is a universal set of operations guiding the lexicalisation of any given structure resulting from binary Merge of syntactic-semantic features drawn from the fseq. It is cyclically activated at each application of Merge. As customary in Nanosyntax, we assume Merge to be a binary operation that assembles categories drawn from the fseq into syntactic trees. Specifically, it combines an already existing syntactic object with a new object that projects the next functional category in the active derivation.3 The new object can be a feature (Merge f), which we discuss here, or a phrase, which we address in detail later in this section and in Section 3.2. The goal of the Lexicalisation Algorithm is to provide the new syntactic object with a lexicalisation via the language-specific lexicon. The next object is not merged until a lexicalisation is found.

The currently most updated version of the algorithm is in (7) (Caha 2019; Caha et al. 2024).4

Each step is activated only if the previous one fails to provide a lexicalisation, and starts from the initial syntactic object resulting from Merge f (i.e. it does not build on the output of the previous steps). Let us illustrate this by deriving a plural NP, assuming the minimal lexicon in (8).

We start from the derivational step in (9).

When (9) is derived, step a. of the Lexicalisation Algorithm is activated, and an LI matching it is searched in the lexicon. The matching operation looks at the syntactic information stored in the LIs in (8) – the lexically stored constituents, or L-trees – and checks if it fulfils the Matching Condition in (10) with respect to the syntactic phrase subject to lexicalisation (S-tree), here (9).5

As any subconstituent of a lexically stored constituent is itself lexically stored (Caha et al. 2024), matching is satisfied also when an L-tree contains the S-tree as one of its subconstituents. Concretely, the matching process top-down evaluates the nodes of the S-tree for identity with an L-tree. When many L-trees match an S-tree, the L-tree with fewer unused features wins (an instance of Kiparsky’s 1973 Elsewhere Condition, also known in Nanosyntax as minimise junk, Starke 2009: 4). In the case of (9), the lexicon in (8) is searched for an L-tree matching NP. Since (8a) contains it, (9) is matched and lexicalised. This is shown in (11), where the circle indicates that the S-tree is paired with the LI reported below.

Merging the next functional feature pl yields (12).

This again activates the Lexicalisation Algorithm, which searches for (12) in the lexicon. Only (8b) has an L-tree that contains the S-tree’s root node (plP), but the L-tree’s node does not directly dominate an NP. Hence, (12) is not matched and step b. of the algorithm is activated (Lexicalisation-driven movement I), targeting the closest labelled non-remnant constituent. Following Caha et al. (2024), a non-remnant constituent is defined as a constituent out of which nothing has moved.6 By this definition, the closest labelled non-remnant constituent within (12) is NP, which is therefore moved to the left of plP. As this operation is lexicalisation-driven and does not add any functional semantics, plP and NP are joined by an unlabelled root node, yielding (13). Since lexicalisation-driven movements are assumed not to leave traces (Caha 2009), plP is a unary-branching node that only dominates the feature pl.7

After movement applies, the lexicon is searched again for a match (i.e. step a. of the algorithm is attempted again). This time, the search is successful: the L-tree in (8a) matches the structure under the left node, while the L-tree in (8b) matches the structure under the right node (14). The root node is not matched, but this is not problematic: lexicalisation is successful as soon as all features are contained in a matched node, which is the case in (14).

As a next step in our example derivation, the merger of the new feature – def – yields defP (15).

As at each syntactic cycle, the lexicon in (8) is searched to lexicalise the new S-tree (step a.). Since no match is found for (15), the subsequent steps of the Lexicalisation Algorithm are activated. In this case, however, lexicalisation-driven movements cannot yield a structure where def is lexicalised. This is because the only L-tree containing def is in (8c), and it has two bottom features, def and x (binary “foot”).8 To see why this is problematic, consider the mutual implication between lexicalisation-driven movements and unary nodes. Since lexicalisation-driven movements are assumed not to leave traces, they always leave a unary node on their right, (see (13)). On the other hand, unary nodes can only be created by lexicalisation-driven movements, since the only other operation that can alter the structure is internal/external merge, which is binary. This entails that only L-trees with a single bottom feature (unary “foot”; e.g. (8b)) can match a structure resulting from the application of lexicalisation-driven movements after Merge f, unlike LIs that only contain binary nodes, like (8c). As a consequence, each step of the algorithm necessarily fails to lexicalise def, until step e.9

Step e. (Complex Left Branch) implicates two operations, (i) building a new “auxiliary” XP containing the relevant feature (here, def), (ii) merging the XP with the main derivation, projecting defP. Operation (i) requires a parallel workspace, additional to the one of the main derivation, where the new “auxiliary” XP is derived. We take each workspace to minimally contain the syntactic structure that has been derived and lexicalised in previous cycles (if present), as well as the LIs lexicalising it. This structural information is only updated once a successful lexicalisation is found for the S-tree derived within the workspace.

With this in place, let us go back to our example derivation. Prior to operation (ii) we have two distinct lexicalised trees in two separate workspaces, encased in squares in (16). One is the output of the previous lexicalisation cycle in the main workspace, call it WSp_main (cf. (14)). The other is the defP built in the auxiliary workspace, call it WSp_def.

Merging the two S-trees from the workspaces in (16) yields (17).10

The root node of (17) is not matched, parallel to (14). This is again not problematic, as all features are nonetheless contained in a matched node. Auxiliary XPs are also known in the Nanosyntactic literature as Complex Left Branches (CLBs), indicating a left constituent terminating with a binary “foot”. In the system described so far, the complexity of the “foot” of the L-tree predicts the position of the LI with respect to the lexical core of the derivation: LIs whose L-tree has a unary “foot” are necessarily to the right (“post-elements”), LIs whose L-tree has a binary “foot” – auxiliary XPs/CLBs – are necessarily to the left (“pre-elements”). This has been proposed in Starke (2018) and adopted in Caha (2019); Pinzin (2024); Gök & Demirok (In press), among others. To the best of our knowledge, this represents the state of the art of the Nanosyntactic computation.

This brings us to the focal point of our discussion. In the current formalisation, CLBs are the last step of the Lexicalisation Algorithm (cf. (7)), and are always successfully merged to the left of the lexical core of the derivation. Since both black and nero are complex modifiers and hence merged as CLBs (both are not strictly adjacent to the N and can be modified, e.g. very black/molto nero), it is impossible to model word-order alternations as in (18) (repeated from (1)) in terms of lexicalisation-driven movements. Such movements can only apply (and fail) before deriving and merging a CLB like black/nero. After merger of the adjectival CLB on top of the noun, the algorithm defines no further operation. As such, the alternation in (18) must rather be modelled in terms of either a featural dependency driving movement of the noun across the adjective in (18b) or linearisation statements encoding their relative order.

In other words, any attempt to capture word-order alternations in the current system must be in line with the models already available in the literature and inherit their tensions (see Section 2). As already claimed in Section 1 and 2, we contend that a single revision allows an alternative way to model word-order patterns in terms of lexicalisation-driven movements. Specifically, the key to unlock this line of analysis amounts to a modification of the lexicalisation condition. Current Nanosyntax considers a syntactic node to be lexicalised as soon as all its features are contained in a node matched by an LI. This is expressed in (19).

Following (19), the root nodes in (14) and (17) are lexicalised. We propose to replace (19) with (20).

Compared to (19), (20) shifts the target of lexicalisation from features to labelled nodes. The intuition behind this is the following: the addition of new functional material to the structure results in the projection of a new label on the main spine, and each such new object must be licensed by being matched by an LI.

Note that the two formulations are equivalent in each configuration derivable via Merge f only. This is because matching only targets phrasal constituents, and not single features (see the Matching Condition in (10)). This means that the lexicalisation of each feature implies matching of its labelled mother node, or of a constituent containing it. Since new labelled nodes in these derivations are only created by merging in a new individual feature, a labelled node cannot remain unmatched (violating (20)) without also leaving a feature without lexicalisation (violating (19)).11

However, the equivalence does not hold when we consider the operation of adding f to the S-tree of the main workspace via a CLB derived in a parallel workspace, as in (17). In such cases, (20) requires both the labelled root node of the CLB and the labelled root node of the full structure to be matched by an LI, while (19) only requires the node dominating f to be matched by an LI, i.e. the root node of the CLB. Concretely, (17) is fully lexicalised under (19), but not under (20). By the latter, the unmatched labelled root-node defP blocks any further merge operation.

From a different perspective, adopting (20) results in parallel lexicalisation requirements for both the case in which a new feature is added to the S-tree of the main workspace directly (Merge f) and as a part of an XP derived in a parallel workspace. Both in (21a) and (21b), the root node of the structure must be matched by an LI.

This parallelism further implies a reconceptualisation of the Lexicalisation Algorithm, by which the operation that adds a new branch to the structure, call it Merge FP, is parallel to Merge f. In this new version, spelled out in (22), Merge FP substitutes the CLB step in (7). Like the CLB step, it only applies if the whole set of lexicalisation-driven movements after Merge f apply and fail. Unlike in the previous version, however, Merge FP is followed by the same lexicalisation steps that follow Merge f: lexicalisation of the root FP node (a.), the two types of lexicalisation-driven movement (b. and c.), backtracking (d.).12

Note that our reasoning applies to any configuration in which a new phrase is added to the structure and projects a feature, regardless of the mechanism deriving this phrase (see fn. 10). In what follows, we abstract away from this issue.

What is crucial is that following this reconceptualisation, lexicalisation-driven movements can be triggered after Merge FP, allowing the LIs present in the language-specific lexicon to influence the position of a new branch with respect to the rest of the derivation via lexicalisation-driven movements.

Let us take a further step. In a structure resulting from Merge FP as (21b), which kind of LIs match the root FP node? In line with Nanosyntax, we assume that any new externalisation/conceptual information carried by the LI matching a node N necessarily overwrites any previous information provided by the LIs matching the nodes contained within N. If the LI does not contain externalisation/conceptual information, we take the previous information to be inherited. If the LI matching the root FP node in (21b) were to carry externalisation/conceptual information, such information would overwrite the information already present in the two branches dominated by FP, i.e. the main branch requiring f (XP) and the branch providing f (the lower instance of FP). Since on the contrary Merge FP adds a new FP branch to the main derivation and does not overwrite (in standard cases) any previous externalisation/conceptual information, we conclude that the relevant LIs matching the root FP node lack any externalisation/conceptual information and only contain syntactic information.13 In a sense, these LIs are “ordering instructions” storing – and therefore licensing – a syntactic arrangement of the two branches involved in a Merge FP operation. As these LIs order the lexicalisation output of previous derivational steps, we refer to them as second-order LIs.

In concrete terms, a second-order LI storing and licensing the order FP – main branch can be schematised as in (23).

No externalisation or conceptual information is present, as discussed above. The syntactic information requires instead further clarifications. Both branches of the L-tree in (23) are pointers, as signalled by their arrow-shaped edge. Pointers are standardly used in Nanosyntax to allow reference to specific LIs within an L-tree (Starke 2014; Caha et al. 2019; Caha 2019). An L-tree containing a pointer to an LI can only match a structure in which the node that is pointed to is lexicalised by the specified LI (see Caha 2019: §4.6). This models cases where the insertion of a given LI is contingent on the presence of other LIs in the tree, as with root suppletion (where the suppletive form can only target structures containing a given root LI, cf. Caha et al. 2019) or idioms (where idiomatic conceptual content is inserted only in structures containing the relevant LIs, cf. Starke 2014). To exemplify, we can take the singular-plural couple mouse-mice, where the LI for mice (25) points to the LI for mouse (24) in its L-tree.

The L-tree in (25) matches a plP node only if its right node is lexicalised by (24), as in (26).

L-trees containing a pointer to an LI abstract over the different syntactic configurations that can be matched by that LI. To see why, let us consider how matching works in such cases. With respect to the Matching Condition in (10), pointers act as “breakpoints” in the matching procedure. Namely, once the top-down comparison process between an S-tree and an L-tree finds a pointer to some node N, a secondary comparison procedure starts.14 This secondary comparison evaluates whether node N in the S-tree has a successful lexicalisation based on the information stored in the corresponding node N that is pointed to in the L-tree. For example, in (26) it evaluates whether the node NP in the S-tree has a successful lexicalisation based on the information in the corresponding node that is pointed to in the L-tree, i.e. LI₉₀. As the syntactic information in LI₉₀ – its L-tree – contains an identical NP, a match is found. Note that LI₉₁ in (25) is devoid of conceptual content. As previously remarked, this entails that the already available conceptual information is not overwritten, but carried over from the previous cycle.15

From a more general perspective, the node that is pointed to is a variable over possible syntactic trees. In the case of pointers to an LI, it ranges over any tree contained in its L-tree. If the S-tree is identical to one of the possible values of this variable, a match is found. We propose to extend recourse to this device by allowing reference to other entities visible to the derivation, i.e. not only features and LIs, but also workspaces.

The underlying reasoning is the following: the two branches involved in a Merge FP operation are built in two independent derivations. Each derivation runs in a separate workspace, as defined in Section 3.1. From the global perspective of the derivation building e.g. a nominal phrase modified by an adjective, syntax has access to two workspaces, one containing the derivation of the adjectival phrase, one containing the derivation of the nominal phrase below the merge site of the adjective. The two workspaces involved in a Merge FP operation are identified by their role: the main workspace is the one with which the initial feature has been merged (via Merge f), while the other one provides that feature. We refer to the former as WSp_main and to the latter as WSp_F. We take workspaces to be objects visible to syntax, so that L-trees can point to them as much as they can point to LIs.

With this in place, let us look again at (23). Its left branch points to the workspace in which the new branch providing f has been built and lexicalised (WSp_F), while its right branch points to the workspace of the main derivation (WSp_main). The Matching Condition works as specified above for the case of pointers to LIs, and checks if the node in the S-tree has a successful lexicalisation based on the information contained in the pointed node of the L-tree, i.e. the syntactic information present in WSp_F for the left node and in WSp_main for the right node. Thus, (23) matches an FP whose left node matches the content of WSp_F (i.e., the last tree lexicalised in WSp_F) and whose right node matches the content of WSp_main (i.e., the last tree lexicalised in WSp_main). Since the content of each workspace necessarily varies depending on the specific derivation, a pointer to a workspace abstracts over the infinite number of possible derivations that can be performed in it. This level of abstraction is necessary: Merge FP combines recursive structures that cannot be referred to via a static index.16 If (23) is stored in the lexicon of a language, the order in which the new FP branch precedes the rest of the derivation is licensed in that language, irrespective of their content.

To exemplify the role of LIs like (23) in a derivation, we show how this system models the variation in (18). Following the Cartographic literature, we assume that an adjective like black satisfies a functional feature within the nominal functional spine (Cinque 2010, a.o.). We label this feature Adj_X and abstract away from the issue of its exact identification (see Svenonius 2008 and Cinque 2010 for an overview and Manzini Submitted for a recent critical discussion). In this context, we only need this feature to exist, irrespective of its precise definition.

We take the English word-order in (18a) to follow from the lexicon in (27).

Let us start from the derivational step where the NP has already been derived and lexicalised via (27b), following the Nanosyntactic mechanisms seen above. This yields (28).

Now, the functional layer related to Adj_X is added. The algorithm in (22) dictates that Merge Adj_X (= Merge f) is attempted first, and that the merger of an independent branch projecting Adj_X (Merge Adj_XP) is only attempted if all the steps of the algorithm following Merge Adj_X fail. Since the lexicon in (27) contains no L-tree with a unary bottom, this is necessarily the case. Now, the Merge FP operation implies that a new branch providing Adj_X – whose lexicalisation is LI₄₅ (black) – has been independently derived and lexicalised in a separate workspace, yielding (29).

At this point of the derivation, two workspaces are active: WSp_AdjX and WSp_main. This is represented in (30).

The two S-trees in (28) and (29) are now merged, projecting Adj_XP.

This is the crucial point where our proposal differentiates itself from previous Nanosyntactic accounts. (31) contains a labelled node that is not matched by any LI: the root node Adj_XP. Adopting the new lexicalisation condition in (20), (31) is not lexicalised. Hence, the Lexicalisation Algorithm is activated and looks for a match for the root node Adj_XP. Given the presence of (27c) in the lexicon above, the search is successful. The root node of the S-tree in (31) is contained in the L-tree in (27c). Proceeding top-down, the comparison procedure finds pointers in the L-tree for both branches, triggering two secondary comparison procedures. For each of the two branches, such procedure checks if the content of that branch of the S-tree is identical to a tree contained in the workspace pointed to in the corresponding node, i.e. the current instance of WSp_AdjX and WSp_main shown in (30). As this is the case, match is successful, yielding (32).

This derives the English order, where black precedes dog.

Let us now look at Italian, where the opposite is true (18b). As customary in Nanosyntax, crosslinguistic variation reflects a difference in the lexicon of the two languages. More precisely, we derive the opposite order from the lexicon in (33).

The difference between (33) and (27) is the absence in the Italian lexicon of the LI licensing the linearisation of adjectives before the rest of the structure. Let us see how this derives (18b).

All steps are identical until Adj_XP is merged with the main derivation, yielding (34) (cf. (31)).

By (20), (34) is not lexicalised, like (31). This activates the Lexicalisation Algorithm, which attempts to match (34). However, no LI in (33) matches it, contrary to the English derivation. The root node of the S-tree in (34) is only matched by the L-tree in (33a). However, the L-tree in (33a) only contains the adjectival branch, and not the NP. As no other LI is available, matching fails, as signalled in (35) by the three stars.

The movement steps of the Lexicalisation Algorithm are then activated, targeting the closest labelled non-remnant constituent (step b.). Following the definition of non-remnant as a constituent out of which nothing has moved (cf. Section 3.1), both Adj_XP and NP are possible candidates. Now, movement of Adj_XP would be in violation of the empirically necessary restriction identified by Cinque (cf. Section 2), namely that only constituents containing the lexical head can move. Under this formulation, something else must exclude movement of modifiers alone. This follows if closest is defined as the non-reflexive relation closest to the item whose merger has triggered the opening of the lexicalisation procedure (in this case, Adj_XP). The same result is obtained by assuming that lexicalisation-driven movements cannot disrupt labelling dependencies: movement of Adj_XP would leave a unary phrasal node with the same label dominating only NP.

Note that the issue stems from the negative definition of the licit targets of lexicalisation-driven movements provided in the Lexicalisation Algorithm. Following the positive definition in Cinque (2005; 2023), whereby only constituents containing the head of the relevant (sub)hierarchy can move, no additional specification is needed. In (35), only the NP contains the head of the relevant (sub)hierarchy, the nominal one. In Nanosyntactic terms, this can be rephrased as constraint whereby only constituents that contain the lowest feature of the current fseq can move. Contrary to the negative definition we adopted until now, this excludes movement of any constituent merged via Merge FP.

While this formulation correctly captures the required constraints, it remains stipulative. Reasoning in terms of workspaces, however, enables an alternative perspective on the issue of why only XPs containing the lowest feature of the current fseq are proper targets of lexicalisation-driven movements. As discussed in Section 3.1, we take a workspace to be the object that (minimally) stores the output of a complete derivational cycle, i.e. the S-tree built via the application of a Merge operation together with information about how it is lexicalised. Following the logic of the Lexicalisation Algorithm, a new derivational cycle can only start if the previous one is complete, i.e. if the S-tree built up to that point has found a successful lexicalisation. The algorithmic nature of the lexicalisation procedure is such that different syntactic operations may be attempted before reaching the one that enables a successful lexicalisation. Once this is reached, the corresponding S-tree and the information about how it is lexicalised must be stored for them to be the input of further derivational cycles or an externalisation procedure. After each complete derivational cycle, the content of the current workspace must therefore be updated, where current refers to the workspace where the last Merge operation has taken place. Consider now that each update of a workspace necessarily contains the whole S-tree derived up to that point in that workspace, up to its lowest feature. Following this logic, step b. of the algorithm could be rephrased as evacuate the closest labelled constituent that is the output of a previous derivational cycle in the current workspace, as in (36). Intuitively, you can only move trees that have already been successfully lexicalised in the current workspace, starting from the closest labelled one.

Under this formulation, the only proper target of movement in (35) is NP, which is then displaced to the left of Adj_XP and merged with it via an unlabelled root node (37).

The unlabelled root node does not signal addition of new functional material and is therefore exempt from lexicalisation requirements. The NP on the left already has a lexicalisation: LI₁₁. The same is true for the lower instance of Adj_XP, which is already lexicalised by LI₂₁. The only labelled node without a match is the higher Adj_XP node, whose label has been projected by the lower Adj_XP via Merge FP. Since Nanosyntax standardly assumes lexicalisation-driven movements to leave no traces (see Section 3.1 and fn. 7), the higher occurrence of Adj_XP in (37) is a unary-branching node only dominating a lower instance of itself, i.e. a case of “vacuous” recursion. Since by (20) all labelled constituents must be matched, this leaves us with two possible options. The first is to postulate the existence of an LI matching the larger Adj_XP constituent under the right node of the tree. This would establish a symmetry between direct lexicalisation (the case of English; see (32)) and lexicalisation after movement of the whole complement, since both cases would require dedicated LIs to match the resulting structure. While this remains a viable option, we opt for a different implementation, and assume that in such cases of “vacuous” recursion the higher Adj_XP inherits the match of the lower occurrence of the same label. This results in (37) being licensed as it is.17

A first consequence of this choice is that word-orders derived via systematic roll-up need no second-order LIs to license any of the relevant syntactic outputs. In Section 6, we elaborate on how this choice makes further testable predictions. A second consequence is that, if roll-up after Merge FP produces a configuration that is licensed in the absence of any dedicated second-order LIs, it will always produce a licit output. This further entails that the Backtracking step of the Lexicalisation Algorithm cannot be activated after Merge FP, making it irrelevant for the present contribution.

In this section, we have shown that syntactic movements deriving basic word-order can be formalised as a reaction to a lexicalisation problem. These movements are triggered when a syntactically derived constituent is not lexicalised, i.e. when it contains a labelled node that is not matched by any LI of the language-specific lexicon. As these syntactic operations are triggered by an interface condition with the lexicon and not by syntactic dependencies (differently from Cinque 2005; 2023), they are necessarily meaningless. This in turn explains why they follow a different set of constraints than meaningful syntactic operations, which are instead triggered by syntactic dependencies (Abels & Neeleman 2009; 2012). Following this proposal, a universal linearisation procedure can be maintained (in line with Kayne (1994)’s Linear Correspondence Axiom adopted in Cinque 2005; 2023), and crosslinguistic variation in basic word-order as (18) can be modelled in terms of an independently necessary source of variation: the content of the language-specific lexicon. These crucial theoretical advantages are however only valid once we demonstrate that the current proposal can model the empirical constraints on crosslinguistic variation in basic word-order highlighted in the literature (see Section 1, Table 1). In the next section, we see how this is the case.

We start from the derivation of the order that reflects the order of merge of the four relevant items, namely Dem-Num-Adj-N. In this and the following derivations, we abstract over preliminary steps independently needed in all cases. What is relevant for the discussion is what happens after a new branch is merged to the structure, e.g. when NumP is merged to a tree already containing an AdjP and an NP. In light of the Lexicalisation Algorithm discussed in the previous section, this presupposes that a) all steps in the algorithm preceding Merge FP failed, and b) some LI can lexicalise the new branch in the separate workspace in which it was built. Ultimately, any difference in the output order reduces to which second-order LIs (if any) the lexicon contains in addition to those that lexicalise each branch.

In the case of the (many) languages that display Dem-Num-Adj-N, we postulate the lexicon for such a language to also include the following second-order LIs:

Let us see how the derivation proceeds given the LIs above. We start from a situation in which an NP has been derived and the structure is enriched by the merger of an Adj_XP, resulting in the configuration represented on the left in (39). As noted above, this presupposes an intermediate stage (not represented here) in which the adjectival branch is independently built and lexicalised, say via LI₂₁. What is crucial is that after the application of Merge FP a lexicalisation procedure is activated. Step a. of the algorithm looks for a direct match for the entire structure as is. This is found in the case at hand: LI₇₁ in (38a) matches precisely a structure in which a projecting adjectival Adj_XP takes the rest of the structure as a complement. Thus, the entire tree is licensed, yielding the order Adj-N.19

Later stages of the derivation involve exactly the same steps. Thus, merger of NumP produces the configuration on the left in (40), which is directly matched by LI₇₂ (38b).

Finally, merger of DemP with the previously derived NumP produces the configuration on the left in (41), which LI₇₃ (38c) matches directly (42). This licenses the order Dem-Num-Adj-N without the need for lexicalisation-driven movements rearranging the structure.

Let us turn to the exact mirror order, namely N-Adj-Num-Dem. As discussed in Section 3.2, the logic of the proposal has the following consequence: after merger of a new branch, application of roll-up derives a configuration in which the lexicalisation requirements are satisfied without the need for any second-order LI.

To repeat the general reasoning, lexicalisation is triggered whenever an application of merge (Merge f or Merge FP) creates a new labelled constituent, with the aim to find an LI matching this object. Lexicalisation-driven movements, on the other hand, do not contribute anything new, and merely rearrange existing branches. This property can be captured by postulating that they create unlabelled nodes, as is standard in Nanosyntax. It follows that any node created by a lexicalisation-driven movement will not need to find a match in the lexicon.

In the present context, the consequence is that a language that lacks any second-order LIs dedicated for the lexicalisation of DemP, NumP, or (any kind of) AdjP will eventually resort to roll-up to derive a licit configuration whenever any such branch is merged. Consider again the same starting point as for the previous derivation, namely the configuration resulting from the merger of Adj_XP to NP, represented on the left in (43). Since the lexicon does not contain a matching LI, lexicalisation-driven movements are triggered. By step b. of the algorithm, the first (and only) available operation is movement of NP across Adj_XP, as shown on the right.

Roll-up of NP creates a configuration in which the right branch of the tree involves what we termed “vacuous” recursion, i.e. a unary-branching node dominating a node with the same label. In Section 3.2, we proposed that in such cases the higher instance of the node inherits the lexical match of its daughter. This has the effect that the order N-Adj is licensed without a dedicated second-order LI, as shown on the right in (43).

The next step in the derivation involves merger of NumP. As in the previous cycle, no direct match is found for this configuration (44).

This triggers lexicalisation-driven movements, which (again by step b. of the algorithm) first attempt movement of the NP alone. This movement leaves a NumP that has to be matched under the left node. As by hypothesis no second-order LI is present in the lexicon of this language, no match is found (45).20

Now, let us recall that the steps of the Lexicalisation Algorithm do not build on top of each other but always start from the initial configuration that triggered the lexicalisation procedure. In this context, this means that step c. of the Lexicalisation Algorithm takes as an input the original structure derived via Merge FP (44) and tries to move the node immediately dominating the one whose movement was attempted at the previous step, i.e. the node immediately dominating NP. The result is shown in (46). In this derived configuration, the reasoning illustrated above about lexicalisation in case of “vacuous” recursive nodes can be replicated. The order N-Adj-Num is thus licensed.

Finally, the next cycle in the derivation is triggered by merger of DemP (47) and follows the same steps. In lack of any dedicated second-order LI, no successful match can be found until the algorithm triggers roll up of the entire complement of DemP, as shown in (48). This again produces a configuration in which the independent lexicalisation previously found for each branch is capitalized on to lexicalise the full structure, yielding N-Adj-Num-Dem.

As encoded by the Lexicalisation Algorithm, the derivational option of roll-up is not the only available one. In this subsection, we discuss two different linear orders that involve the only other type of scenario: (sub)extraction out of a complement.

Following the step b. and c. of the algorithm, what constituents can move is determined by the geometry of the tree, and lexicalisation-driven movements are attempted starting from the closest labelled movable branch. (Sub)extraction is a descriptive label for situations in which the moved branch is smaller than the complement of the newly merged f/FP. In such cases, lexicalisation-driven movement leaves a remnant in the complement of the newly merged f/FP, by either moving the left branch of the complement (extraction) or a subpart of an already moved constituent (subextraction).

To visualise the relevant type of configuration, consider the abstract structure in (49a). If direct lexicalisation fails, step b. of the algorithm dictates lexicalisation-driven movement of WP. The result of such movement is the structure in (49b), where the complement of the new feature x contains a remnant of the original complement, i.e. YP.

Before this lexicalisation-driven movement, the constituent to lexicalise – XP – contained all other branches. After extraction of WP, XP can be lexicalised by an LI that contains x and YP in the corresponding configuration, like (50).

In the present context, the question is what kind of LIs can match one such (sub)extraction configuration derived after the application of Merge FP. We argued in Section 3.2 that LIs containing an L-tree with one concrete syntactic syntactic configuration as (50) are not adequate. Defining the order of complex XPs standardly requires to abstract over all their possible syntactic configurations. LIs containing a pointer to WSp_main of the type we introduced in Section 3.2 are not suitable either. The current state of WSp_main contains the syntactic structure with which the new branch has been merged. This only allows direct lexicalisation after Merge FP, regardless of the internal articulation of the complement of the new branch. What needs to be encoded to capture cases of (sub)extraction is that a successful lexical match is conditional on the application of lexicalisation-driven movements which evacuate a subpart of the complement of the new branch (i.e. of the syntactic structure stored in WSp_main), leaving a remnant. Following the logic of lexicalisation, we need a second-order LI whose right branch matches the remnant WSp_main: WSp_main minus the evacuated XP.

To better understand the issue, let us consider the S-tree in (51). Parallel to (49a) above, this tree is the result of the application of roll-up, in this case involving movement of NP across Adj_XP, and of [[NP] [Adj_XP]] across NumP, as outlined in Section 4.2. The output of this successive application of roll-up is then merged with DemP, which projects its label at the root node.

(51) is compatible with multiple derivational possibilities, including two (sub)extraction cases. By step b. of the Lexicalisation Algorithm, the first attempt involves movement of the closest labelled constituent containing the lowest feature of the current fseq, i.e. NP (52); in case of failure, step c. will target [[NP] [Adj_XP]] (53), and, as a last resort, the entire complement of DemP (i.e. roll-up) (54). Each option yields a different order: N-Dem-Adj-Num, (line p. in Table 1), N-Adj-Dem-Num, (line l. in Table 1), and N-Adj-Num-Dem (line y. in Table 1). While (54) is derived in case no second-order LI is present (cf. Section 4.2), both (52) and (53) require the remnant DemP under the right node to be matched.

The implementation we propose for these cases starts from the reasoning we applied in Section 3.2 to allow for direct matches after Merge FP. To abstract away from the content of the complement of the new branch, we resorted to pointing to WSp_main, which contains the syntactic structure lexicalised in the main workspace at the previous cycle. In proposing that L-trees can point to WSp_main, we leverage the fact that such objects must be independently assumed to be available in the derivation and, therefore, visible to syntax (cf. Section 3.1). Similarly, the fseq – the universal sequence of features/categories – is not itself a syntactic object, but interacts with syntax in specifying the licit orders of merge of the relevant features/categories (cf. Section 3.1). We hence take the fseq and its categories to be visible to syntax, so that they can be referred to within specific L-trees. To account for cases of (sub)extraction, we then enrich the expressive possibilities of WSp_main with the possibility to specify “cut-off points” in terms of features/categories of the fseq. Given a (simplified) fseq <N, Adj_X, Num, Dem>, we propose second-order LIs like those in (55), which specify different “cut-off points”.

Specifically, we propose that the relevant diacritics specify a category in the fseq such that a match is found only if the right branch does not contain any element of that category or of a lower one in the fseq. To better define how this works, let us repeat how the Matching Condition applies with L-trees containing a pointer. When a pointer is found in the L-tree, the matching process checks if the information present in the pointed node matches the corresponding node in the S-tree. As discussed above, if the pointed node is an LI, identity must be established with the L-tree of that LI. If the pointer instead refers to a workspace, the S-tree under the corresponding node must be identical to a tree that has a lexicalisation in that workspace. Informally, diacritics like WSp_main-Adj_X mean that the procedure compares the relevant portion of the S-tree with the tree contained in WSp_main after the “removal” of any element of the same category as the specified “cut-off point” or of a lower category in the fseq. This “removal” operation can be understood in two possible ways. The first is to interpret it in terms of the creation of a copy of WSp_main out of which the closest phrase containing all and only the relevant categories is removed. The second is to interpret it as the instruction to ignore the lexicalisation of the relevant categories in WSp_main. Considering (51), the result of interpreting the diacritic WSp_main-Adj_X in LI₇₉ under the first option is represented on the left in (56), while the result of the second option is on the right.

Concretely, LI₇₉ matches (55) any configuration in which the complement of DemP does not contain Adj_X or any constituent with a lower label in the fseq. As we detail in Appendix 2, this correctly captures all possible orders in cases of gaps, namely in cases in which one or more modifiers are not part of the structure.

To show these two different second-order LIs at play, consider the different results they yield after merger of DemP in a configuration like (51) above. A language with LI₇₈ finds a match as soon as the first lexicalisation-driven movement – movement of NP – is attempted, yielding the order N-Dem-Adj-Num (57) (= (52)).

On the other hand, a language with an LI like LI₇₉ requires a further movement attempt to find a match, moving a larger constituent including the noun and the adjective across DemP. This yields N-Adj-Dem-Num (58).

This section outlined how the present systems replicates the different derivational scenarios employed by Cinque (2005) and ff., reducing them to an interaction between second-order LIs and the Lexicalisation Algorithm. The possibility of having LIs that license a direct match after the merger of a new branch corresponds to a situation where no movement occurs, or in more recent versions of Cinque’s approach, to cases of “pictures-of-whom pied-piping” (movement of a head-final phrase in Cinque’s (2023) terminology). The lexicalisation-driven movements made available by the algorithm cover instead the other two cases in Cinque’s system, i.e. movement without “pied-piping” (e.g. movement of N alone) or with “whose-pictures pied-piping” (e.g. roll-up movement of N-Adj across Num).

In this system, other derivational scenarios are not available. The consequence is that the ten unattested orders in Table 1 are not derivable. To repeat, this follows from the restrictions on licit movements encoded in the Lexicalisation Algorithm, repeated in (59).

Crucially, step b. and c. restrict the targets of movement to constituents containing the lowest feature in the current fseq (see the discussion in Section 3.2). This has the same effect achieved in Cinque (2005; 2023) by restricting licit movements to constituents containing the lexical head.

Like proposals by Cinque (2005; 2023) and Abels & Neeleman (2009; 2012), this system incorporates the restriction axiomatically. In that respect, an attempt to go beyond an axiomatic approach is put forth by Steddy & Samek-Lodovici (2011). Their analysis focusses on ruling out movements of constituents from which the lexical head of the extended projection has been extracted (i.e. remnant movements). This ban depends on a set of Optimality Theory constraints imposing that every category of the DP must be left-aligned with the DP’s left edge. Under this approach, the strings generated by remnant movement are always sub-optimal with respect to at least one string obtained without remnant movement under any possible ranking of the constraints. Crucially, however, this does not cover the necessary ban on movement of modifiers alone, for which additional assumptions are required. As discussed in Section 3.2, the alternative we propose identifies the proper targets of lexicalisation-driven movement with structures that represent a successful output of previous lexicalisation cycles in the current workspace. This correctly excludes both remnant movement and movement of modifiers alone. Moreover, defining the possible targets of movements in terms of derivational stages could also to capture the overall restriction in a non-axiomatic way. In this sense, one should investigate if there is a principled reason why lexicalisation-driven movements and the configurations that have already been lexicalised are linked, something we necessarily leave to future research.

As highlighted in the literature on the Universal 20, not all attested linear orders in nominal phrases are equally frequent across languages. The results of a series of artificial language learning experiments (Culbertson & Adger 2014; Martin et al. 2020; 2024) suggest that among the determinants of the typological frequency is a general cognitive bias towards transparent mappings between the hierarchical arrangement of items and their linear placement. What these studies observed is that participants learning nominal phrases in an artificial language tend to generalise homomorphic orders, in which items are linearly adjacent to items/phrases they dominate in the hierarchy. Crucially, this was found to be the case also when testing speakers who do not have superficial evidence for homomorphism in their language, as in the case of Kîîtharaka (Bantu) (Martin et al. 2024). Since precisely homomorphic orders are among the crosslinguistically most common ones, such experimental evidence can be invoked to support the idea that the same cognitive bias observed in the performance of participants is also responsible for the typological tendencies in the distribution of word-orders.

This argument leaves an open question: why would homomorphism in itself play a role? As it turns out, modelling the different orders in terms of LIs and lexicalisation-driven operations helps highlight a possible rationale for why homomorphic orders tend to be preferred, namely the fact that they require less input to be acquired.

To see how, consider again the question of how the parsing of simple N + modifier pairs relates to the acquisition of the target word-order in more complex nominal structures. Assuming a conservative lexical acquisition process, parsing a Num-N sequence will lead to positing an LI with the format of (62), while N-Num will support the deduction that no LI is needed, as the order is derived via roll-up (cf. Sections 3.2 and 4).

Now, all homomorphic orders can be fully characterised in terms of either of these options for each modifier. The consequence is that generalisations based on simple pairs of items are enough to correctly capture the behaviour of the same items in more complex structures. LI₇₂ in (62) will always license configurations in which Num comes before the lower parts of the structure, regardless of whether the noun combines with lower modifiers, and roll-up across Num will target a constituent that contains any item below it in the hierarchy. Thus, for instance, the information that can be deduced upon encountering N-Adj and N-Num is already enough to derive N-Adj-Num, without the need of additional, more specific input. Non-homomorphic orders, on the other hand, do not share this property. The reason is that their derivation always involves a (sub)extraction step, as outlined in the previous section, and pairwise input is not enough to posit the LIs that license it. In the example at hand, the information required for a target non-homomorphic sequence like N-Num-Adj can only be fully obtained after directly encountering a nominal phrase where the noun combines with both a numeral and an adjective, which will lead to positing a second-order LI like (63).

More abstractly, the proposal allows to formulate the following hypothesis: systems where the target LIs can be acquired based on shorter sequences of elements tend to be more frequent. While the empirical consequences of such logic remain to be explored, the crucial point is that it enables a concrete perspective on the typological frequency of homomorphic orders, based on an intuitively plausible claim: systems that can be learned reliably on the basis of fewer information tend to be preferred.

Note that the possibility of stating this in terms of ‘ease’ of lexical acquisition is directly connected to the proposal that word-order information is stored in terms of LIs. At the same time, an analogous reasoning about the role of homomorphism can be developed under the post-syntactic approaches discussed in Section 2 (Abels & Neeleman 2009; 2012; Manzini Submitted).22 There too, a difference is encoded between homomorphic and non-homomorphic orders: the first can be fully captured in terms of simple linearisation statements, provided that different modifiers like e.g. adjectives and numerals are adjoined to hierarchically different categories. Non-homomorphic orders, instead, additionally require movement of a category containing the nominal head.23 Under the assumption that linearisation statements are generalised as the default option to capture the order of two items, and meaningless movement is only posited as a last resort, the successful acquisition of a non-homomorphic order like N-Num-Adj requires input providing evidence for N-movement, i.e. minimally the sequence N-Num-Adj itself.

The previous section focused on testing our theoretical proposal considering empirical data from the typological tradition. In a similar vein, our proposal can also be connected to experimental measures such as syntactic priming. Priming refers to the facilitative effect that the processing of a linguistic expression has on the production or comprehension of the same or a related linguistic expression (Tulving et al. 1982). This phenomenon has been shown to be consistently attested in the production and comprehension of syntactic structures independently of other linguistic layers (see the seminal works in Bock 1986; Bock & Loebell 1990; Pickering & Branigan 1998; for a review see Branigan & Pickering 2017; see also the meta-analysis in Mahowald et al. 2016 showing how the syntactic priming effect in production is robust across constructions and languages).

Crucially for our discussion, priming processes have been claimed to tap into our linguistic representations and their inter-relations. On this basis, syntactic priming has been proposed as a methodological tool for probing the representational units shared between syntactic representations via their activation (see Branigan & Pickering 201724). From a generative perspective, however, it is unclear what the objects of such activation might be. Now, our approach provides a way to model syntactic activation along the more familiar lines of lexical activation: since any syntactic structure is licensed via lexicalisation, parsing a given input string results in the activation of the LIs required to license it, including second-order LIs. If syntactic priming involves the activation of second-order LIs, we expect their formal properties to be compatible with the general findings from syntactic priming experiments. This is what we show in the next paragraphs, before looking at some further predictions testable via the same methodology.

The most consistent and replicated finding from syntactic priming (Bock 1986; 1989; Bock & Loebell 1990, among others) is that syntactic information can be primed autonomously; syntactic priming effects do not depend on the repetition between the prime and the target of LIs with a specific externalisation (irrespective of these LIs being more “functional” or “lexical”). In our model, second-order LIs only encode syntactic information; no externalisation (or conceptual) information is present (see Section 3.2). If syntactic priming involves the activation of such LIs, independence from externalisation is expected. Besides externalisation, syntactic priming has also been proved to be independent from the complexity of the internal structure of the constituents involved (Pickering & Branigan 1998) and the general syntactic context in which the given structure is present (Branigan et al. 2006). This too is expected in our system. Second-order LIs encode local relationships between the syntactic constituent projecting a given functional category and the rest of the tree. Crucially, both the new branch and the rest of the derivation are pointed at as unanalysed units (workspaces), so that their internal syntactic structure is not decisive for the possibility of priming the whole second-order LI.

At the same time, the magnitude of the effect has been shown to significantly increase with the repetition of lexical material from the prime to the target sentence (lexical-boost effect; Pickering & Branigan 1998; Branigan et al. 2000; Cleland & Pickering 2003). The lexical-boost effect is however short-lived compared to the overall priming effect, to the extent that it entirely vanishes when material is found in between the prime and the target (Hartsuiker et al. 2008; Mahowald et al. 2016). As argued above, our second-order LIs do not directly contain overt lexical material and can therefore be activated independently of it. Nonetheless, the S-trees they match always necessarily contain overt lexical material in each workspace. Such information is inherited at the root node. We might then speculate that the lexical-boost effect stems from the co-activation of a second-order LI with the inherited lexical material. Repetition of the same lexical material in the next target enhances retrieval of the second-order LI (explicit memory as a retrieval cue, see Hartsuiker et al. 2008). While this enhancing-by-repetition effect is constrained to the immediately adjacent production, the implicit activation of the abstract second-order LI outlives it and persists over time.

Overall, the model we propose is balanced enough between abstraction and overt externalisation to account for these results. On the one hand, the lexicon contains a set of abstract “ordering instructions” represented as second-order LIs just encoding the relative position of the two branches they dominate (no externalisation or conceptual information). These branches are in turn represented as unanalysed units (WSp). On the other hand, such second-order LIs are necessarily always matched via the Nanosyntactic lexicalisation mechanism with actual syntactic derivations containing overt lexical material.

On top of being generally compatible with previous experimental evidence on syntactic priming, our system lends itself to further predictions in this domain. Here we briefly sketch three potential lines of inquiry.

Let us take the basic order between adjective (Adj) and noun (N). Our system makes a crucial difference between the Adj-N and the N-Adj order: the first requires a second-order LI stored in the lexicon licensing it (cfr. (38a)), the second is the result of the absence of any second-order LI ordering N and Adj (cfr. (43)). If true, this implies an asymmetry also in the priming effect between these two conditions. We moreover predict that the asymmetry should favour the Adj-N order, as activating an LI via priming should be less demanding than inhibiting one. To properly test this, one should investigate a bilingual population with language A in which only the Adj-N order is grammatical and language B where only the N-Adj order is grammatical.25 Finding a difference in the magnitude of the priming effect in favour of the Adj-N order would be consistent with our proposal.

Besides the asymmetry between presence and absence of a second-order LI, it is also possible to investigate the difference between the activation of one vs. two (or more) second-order LIs. Let us assume Language A, where the unmarked order is N-Adj-Num-Dem, Language B, where the unmarked order is Dem-Num-N-Adj, and Language C, where the unmarked order is Dem-N-Adj-Num. Language A requires 0 second-order LIs, Language B requires 2 second-order LIs, Language C requires 1 second-order LI (see Appendix 1). Following our proposal, it should be easier to prime the order of Language C to Language A than the order of Language B to Language A. Along the same lines, priming the order of Language B to the order of Language C (and vice versa) should give comparable results to priming the order of Language C to Language A, since in these cases the difference between the regular and the primed order amounts to one LI.

Finally, it is interesting to question the level of abstraction at which syntactic priming can take place. Is it possible to activate the abstract form of a second-order LI and transfer it to a separate second-order LI which refers to a different functional feature? To give a concrete example, would it be possible to transfer the format of the second-order LI ordering Adj before N to the functional level of the demonstrative, activating the order Dem-N? On a more speculative level, a positive answer to this question would partially explain the level of homogeneity or harmony that is found in natural languages (see Section 6.1): second-order LI tend to attract each other, and maybe more so if they are often found together, as when they all belong to the same functional domain (e.g. the nominal or the verbal domain).