Ok. so their main criticism is the inability to construct novel models using the current framework. The risk of generalising is that the metalanguage becomes unwieldy. I think I have the basic idea for a compromise.
The most general term that we could find in
an equation is of the following form:
$$
C_{i_1 i_2 i_3 \dots i_n} O^{(1)}_{i_1} \dots O^{(2)}_{i_n}
$$
where $O^{(j)}$ are classes $S$, $I$, etc.
But is this correct ? There could be partial contractions as well, rather than full contraction ? because, the index should remain free ... some indices. Ok. what is the role of the C ? C is the contact matrix. I see. Yes, that is nice. Ok, but what if we want a term, that is constant ? so one could nest arbitrarily like this ,right?
Can gamma be a delta * 2d array ?
yes, but technically the above accounts for that as well. The first index would just be a delta. So it'd be diagonal in $i_1$.
My suggestion is that we could have terms of in the following form:
```python
["beta", "S", ["C", "I"]]
```
The term always has the same form `[parameter, factor, factor, ...]`. But each factor can also be of the form `[parameter, factor, factor, ...]`.
Furthermore, the way that the `parameter` enters into the equation depends on what kind of value that the user passes as that paramter (scalar, 1D arary, 2D array, etc).
Let's first consider `["C", "I"]`:
- The user can pass "C" as a scalar. In which case `["C", "I"]` will be
$$
C I_i
$$
- "C" is a 1D array.
$$
C_{i} I_i
$$
(no sum)
- "C" is a 2D array.
$$
\sum_j C_{ij} I_j
$$
The same goes for "beta". Let's now consider "C" a 2D array, and consider "beta":
- "beta" is a scalar
$$
\beta S_i \sum_j C_{ij} I_j
$$
- "beta" is a 1D array
$$
\beta_i S_i \sum_j C_{ij} I_j
$$
- "beta" is a 2D array
$$
\sum_k \beta_{ik} S_k \sum_j C_{kj} I_j
$$
C_i + D_i + A_j + B_k -> ... @ gamma_jk
Finally, consider the term `["gamma", "A", "B", "C", "D"]`.
- `"gamma"` is a scalar
$$
\gamma A_i B_i C_i D_i
$$
- 1D array
$$
\gamma_i A_i B_i C_i D_i
$$
- 5D array
$$
\gamma_{ijkle} A_j B_k C_l D_e
$$
$$
\gamma_{ij}A_i B_j *(C_k D_k)
$$
```python
["_", "C", "D", ["gamma", "A", "B"]]
```
$$
C_i D_i \gamma_{ijk} A_j B_k
$$
where
$$
\gamma_{ijk} = \tilde{\gamma}_{jk},\ \forall i
$$