@Argyll I can give you a brief sketch. Let me know if you want to learn more, as it happens to be related to my expertise.

A pushdown automata (PDA) is a machine that has finitely many states and a number of stacks. Each stack is a list of symbols, and we think of one end as the top and the other end as the bottom. At each step, the PDA does something and then transitions to another state, where its action and state transition depends only on its state and what is at the top of its stacks, and it is only allowed to remove or add symbols one at a time to the top of each stack.

Adding to the top of a stack is called pushing, and removing from the top of a stack is called popping. There may be more than one possible option at each step; the current state and current symbols on top of the stacks determines a set of possible (action, state transition) pairs. There are special stacks called the input stack and output stack, where the PDA can only push to the input stack and can only pop from the output stack.

Oops I mistyped in the last message.

Should be "the PDA can only pop from the input stack and can only push to the output stack.

The PDA has some states marked as final states. If the PDA reaches a final state, it stops, and its output is defined to be what is in its output stack at that point. If it does not stop, then there is no output. So a PDA defines a non-deterministic procedure that on each input string produces some output string or does not stop.

If we use a PDA as a recognizer, we say that it accepts an input iff for some sequence of steps (recall there may be multiple possible options for each step) it stops and produces non-empty output. The language recognized by the PDA is defined as the set of all possible inputs x such that it accepts x.

If we use a PDA as a generator, we say that it generates x iff x is a possible output when given an empty input stack (recall that multiple options for each step implies that there are multiple possible outputs). The language generated by the PDA is defined as all the outputs that it generates. It turns out that every language is recognized by some PDA iff it is generated by some PDA.

One can consider what a PDA can do with a limited number of stacks. If a PDA has 0 other stacks besides the input/output stacks, then it is as weak as an NFA (non-deterministic finite-state automaton), and so the language it recognizes/generates is a regular language. If the PDA has only 1 other stack, then it is stronger, being able to recognize/generate a CFG (context-free grammar). If the PDA has 2 or more stacks, then it has maximal power equivalent to that of a TM (Turing machine).

For example, here is a 1-stack PDA that generates a binary palindrome. It has 4 states 0,1,2,3, and starts in state 0. At each step, if it is in state 0 then it has 3 possible options:

(1) Go to state 1.

(2) Push 0 onto the working stack (i.e. the 1 extra stack) and onto the output stack and remain in state 0.

In state 1 it has 3 possible options:

(1) Go to state 2.

(2) Push 0 onto the working stack and go to state 2.

(3) Push 1 onto the working stack and go to state 2.

In state 2 it pops the top symbol off the working stack. If there are none, it goes to state 3. If the top symbol was x, then it pushes x onto the output stack and goes to state 2.

State 3 is the final state.

State 0 basically pushes an arbitrary binary string onto the output stack and stores it in the working stack. State 2 pops the entire working stack off and onto the output stack (which would be in reverse order). State 1 either goes to state 2 or adds an extra arbitrary bit to the working stack, to cater for a middle bit in a binary palindrome with odd number of bits.

So when I said "multi-stack push-down automaton with a small constant number of stacks each of which has small maximum size", I mean a PDA with a small number of stacks except that each of the working stacks (excluding the input/output stacks) is limited in size. Formally, if each stack has maximum size m, then in each step the PDA knows whether a stack is full or not, and is not allowed to add symbols to a full stack.

Note that a 2-stack PDA is equivalent to a TM, but a 2-stack PDA with working stack size m is extremely weak from a computability point of view, because it has finitely many possible stack configurations (since the number of symbols used is finite), and so it can be translated into an NFA.

However, the total number of possible stack configurations is exponential in m! So in practice, it is like a TM with a small tape, and it can also easily simulate CFGs except with a small recursion depth.

The notion of working stacks/tapes with small maximum size corresponds well to what humans appear to use as short-term memory stores, called working memory.

If you think carefully about it, you will see that this explains why we get confused if there are too many centre embeddings, but we can tolerate almost unlimited succeeding subordinate clauses.