---
# System prepended metadata

title: Untitled

---

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