I learned this notation in university (in University College Dublin specifically), when studying computer science. I presume its origins are from the university in Eindhoven. It is a linear, HTML-friendly replacement for the sigma notation and the pi notation.

The basic notation is this:

( *operator* : `x` ∈ *set* : f(`x`) )

For those of you with browsers that don't display the symbols properly, that's: `x` [is an element of] *set*

Some examples would be a good idea before getting into the intimidating details: The sum of the first 5 square numbers is (+ : (`x` ∈ **Z** && (0 < `x` <= 5)) : (`x` ^ 2)). The product of the natural logarithms of the first 100 positive integers is (* : (`x` ∈ **Z** && (0 < `x` <= 100)) : ln(`x`)).

Again, in both instances above, that's: `x` [is an element of] [the set of integers]

Now for the details: The *operator* must have a unit, and it must be commutative and associative. This means that for all `x`, `y` and `z`: there must be a value `n`, so ((`x` *operator* `n`) == `x`), and ((`x` *operator* `y`) == (`y` *operator* `x`)), and (((`x` *operator* `y`) *operator* `z`) == (`x` *operator* (`y` *operator* `z`))).

The good news is that generally you don't have to worry about all that. Addition and multiplication (and indeed conjunction and disjunction) all have units, all are commutative, and all are associative. These are the main operators that are used with Eindhoven notation.

The Eindhoven expression can be formally evaluated (for finte sets) as:

(*operator* : (`x` ∈ ∅) : f(`x`)) = (the unit of *operator*)

That's: (`x` [is an element of] [the empty set])

(*operator* : (`x` ∈ (**A** ∪ {`z`})) : f(`x`)) =
((*operator* : (`x` ∈ **A**) : f(`x`)) *operator* f(`z`))

That's: (`x` [is an element of] (**A** [union] {`z`}))

and: (`x` [is an element of] **A**)

The Eindhoven expression when used with a countably infinite set can be expressed as a limit.

It takes only a little bit of practice to read Eindhoven notation, and it makes writing equations in HTML a whole heck of a lot easier.

BTW: The ∈ symbol is coded in HTML as ∈.

I have found the limitations of Eindhoven notation a bit ... well, a bit limiting. I developed two new notations, based on the Eindhoven notation, which I find to be even more useful.

Left list modified Eindhoven is like this:

( *operator* : list )

It is defined as:

( *operator* : ∅ ) is undefined

A liberal interpretation could be the left unit of *operator*, i.e. `ul` such that ((`ul` *operator* `x`) == `x`) for all `x`, *if such a *`ul` exists.

That's: [the empty list]

( *operator* : (`a`) ) = `a`

( *operator* : append(**L**, `a`) ) = (( *operator* : **L** ) *operator* `a`)

where **L** is a nonempty list

Informally: if there's zero or one elements in the list, the case is trivial. Otherwise, take the first pair and operate on them (in the order they appear). Take the result, and operate with the result on the left and the next element in the list on the right. Repeat until you go through all the elements in the list.

The other notation is right list modified Eindhoven:

( ∅ : *operator* ) is undefined

Or, it could be the right unit of *operator*, i.e. `ur` such that ((`x` *operator* `ur`) == `x`) for all `x`, *if such a *`ur` exists.

That's: [the empty list]

( (`a`) : *operator* ) = `a`

( prepend(`a`, **L**
) : *operator* ) = (`a` *operator* ( **L** : *operator* ))

where **L** is a nonempty list

This allows non-commutative, non-associative operators with no unit to be manipulated in the same way. For example, the power operator has a right unit (1) but no left unit. Matrix multiplication is not commutative. This more versatile notation can be used for a wider range of operators such as these.