what is the intuition behind separate activation/memory paths in LSTM's? See the diagram below, which is taken from a homework in Andrew Ng's course on Sequence Models on Coursera (this question is not related to a homework task per se, just for general edification).
I'm wondering what the intuition is, if any, behind passing two values in between time steps: both the memory cell value and the activation value. As you may know, in GRU's we dispense with this and only pass a memory cell value forward (there is no separate activation). But I assume there must be some reason why LSTM's decide to do both.
Relatedly, what is the intuition behind using the activation values to compute the gates and candidate values, but not the memory cell values? Of course sometimes we also use the memory cell values by modifying the LSTM to use peephole connections, but it's not present in the default setup.
Any further intuition you can provide would be appreciated.

 A: In a vanilla RNN, there is only the activation path (also often referred to as the hidden-state $h_t$). 
LSTM added on the cell memory $c_t$ as a way to store information over long time-spans in particular.
GRU, which was developed later, simplifies the LSTM by combining both the cell memory and the hidden-state. 
Therefore the intuition is that the cell memory stores longer-term information while the hidden-state is still used the same way as it is used in vanilla RNN, but later on, we discovered that it's possible to combine the two without too much degradation in performance. In other words, GRU is a sort of refinement on the ideas from LSTM.

The cell memory is used to modify the activation path before the output, so intuitively, whatever relevant information in the long-term memory can be dumped into the short-term memory (the activations) right before an output needs to be extracted
A: To understand the intuition behind, one should probably know the evolution of the algorithms.
1. RNN
An RNN network initially wants to model the sequence of inputs. By sharing the network parameters between the individual inputs, and using the output of previous input as part of the input for next computation, the sequence state can be accumulated along with the sequence, virtually achieving a variable-depth network.
For this purpose, the most straightforward network design is to build a path between the hidden nodes (i.e., from the output of the hidden node to the input of it in the subsequent time-step). 
$$
   c_t = \sigma( f \cdot c_{t-1} + g \cdot x_t) 
$$
Here, both $f$ and $g$ are parameters, hence single path suffices. This design is powerful enough to encode all the history information. But it has a problem of vanishing or exploding gradient. 
2. Leaky Unit
One way among others to overcome the problem is to use the leaky unit that provides linear self-connection in following way:
$$
   c_t = f\cdot c_{t-1} + (1-f) \cdot \hat x_t 
$$
Now since $c_t = f^{n}\cdot c_{t-n} + ...$, with $f$ being near one, the far distant history has no problem to be passed along. When $f$ being near zero, the history can be quickly forgotten. 
Leaky unit is a clever design. Then the problem is how to decide the value of $f$. It can be a constant, or a parameter, or a function of the history info. (It does not make much sense for $f$ to be a function of the input.) When we use a function for $f$, the function is called a gating function. Depending on the choice of $f$, leaky unit can be single or two paths.
3. LSTM
The idea of using a gate function of the history info requires introducing another path between steps (i.e., from the output of hidden node to the input of the gating function.) So you have,
$$
\begin{align*}
f_t & = \sigma(h_{t-1}, x_t) \\
\end{align*}
$$
And you know this is LSTM, if you have,
$$
\begin{align*}
c_t &= f_t \cdot c_{t-1} + i_t \cdot \hat x_t \\ 
h_t & = o_t \cdot c_t \\
    & ... 
\end{align*}
$$
With gating functions, the network can control very well how long and how short the memory should be. LSTM uses the output $h_{t-1}$ to gate not only the hidden node connection, but also the input and, especially the output from $c_{t}$ to $h_{t}$, which makes the two paths hard to be merged into one. Then $h_{t}$ is supposed to encode best the information for both long and short memory. 
4. GRU
As such, you definitely can use the cell state to compute the gating functions, but the original setup is more straightforward - with clean separation between gating and cell state. Inspired by the idea, one can come up with different designs.
GRU is then designed to use single path, by removing the output gating and output the cell state directly. Then the cell state can be used by the subsequent step for both state update and gating function computation. You can interpret it differently anyway. For example, the reset gate in GRU can be considered as a shifted output gate of LSTM: it shifts from the output of current step (in LSTM) to the input of next step (in GRU).
$$
\begin{align*}
c_t &= f_t \cdot c_{t-1} + (1-f_t) \cdot \hat x_t \\
f_t & = \sigma(c_{t-1}, x_t) \\
    & ... 
\end{align*}
$$
A figure is better than a thousand words.

You can further simplify GRU with fewer gates, for example, with the same update gate for reset gate. The point is, from the viewpoint of "path", there is no essential difference no matter if it is one or two.
