# opaque math notations
here are several categories of mathematical notation that are especially opaque or hard to track for someone from a computer science background, along with illustrative examples. these represent excellent test cases for stress-testing a referential, programming-inspired notation.

# overloaded and omitted operators
example:
```math
f(x + y) = f(x) + f(y)
```
problems:
* `+` may mean real addition, group operation, vector addition, etc.
* function `f` might be a morphism, homomorphism, or arbitrary function.
* no types or domains are specified.

# implicit quantification
example:
```math
∀ε > 0, ∃δ > 0, ∀x, |x - c| < δ ⇒ |f(x) - l| < ε
```
problems:
* no indication of types (`x`, `c`, `f`, `l`).
* scope nesting is unclear.
* logical structure is compressed and non-linear.

# index-heavy algebra and summation notation
example:
```math
∑_{i=1}^{n} a_{ij} b_{jk}
```
problems:
* index tracking is manual.
* variable binding is implicit.
* semantics are lost outside the matrix context.

# category theory diagrams and composition notation
example:
```math
f: a -> b, g: b -> c, h = g ∘ f
```
problems:
* directional semantics depend on convention.
* composition order (`g ∘ f`) is opposite of evaluation order.
* diagrams are informal, often with no canonical syntax.

# point-free notation
example:
```math
(id × f) ∘ δ
```
problems:
* no variables, so the dataflow is opaque.
* requires fluency with combinators.
* difficult to evaluate step-by-step.

# multi-level operator precedence
example:
```math
a + b * c^d / e - f
```
problems:
* implicit precedence and associativity.
* no parentheses, types, or grouping indicators.
* meaning changes dramatically with minor edits.

# set-builder notation
example:
```math
{x ∈ ℝ | x² < 2}
```
problems:
* semantics of `|` vs `:` varies by source.
* logical interpretation (`x² < 2`) is implicit.
* no binding or scoping shown explicitly.

# ellipsis and notational shortcuts
example:
```math
1 + 2 + ... + n
```
problems:
* no defined semantics for `...`.
* interpretation is context-sensitive.
* not machine-readable.

# generic maps without concrete definitions
example:
```math
let φ: g -> h be a group homomorphism
```
problems:
* no definition of `φ`, only type.
* all behavior is inferred from "homomorphism".
* mapping rules are abstracted away.

# use of symbols for concepts without clear anchoring
example:
```math
ℒ(x, y), hom(x, y), ⟨x, y⟩, [x]_∼
```
problems:
* notation depends on domain-specific conventions.
* no universal syntax for defining these constructs.
* requires extensive background knowledge to interpret.
would you like to prototype referential rephrasings for one or more of these cases?