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 $$