Logical predicates∈
-------------------
 P ∧ Q       conjunction
 P ∨ Q       disjunction
 P ⇒ Q      implication
 P ⇔ Q      equivalence
 ¬(P)        negation
 ∀(x).(P⇒Q) universal quantification
 ∃(x).(P∧Q)  existential quantification

Equality∈
---------
 E = F      equality
 E ≠ F      disequality

Booleans∈
---------
 TRUE
 FALSE
 BOOL        set of boolean values ({TRUE,FALSE})
 bool(P)     convert predicate into BOOL value

Sets∈
-----
 ∅          empty set
 {E}         singleton set
 {E,F}       set enumeration
 {x|P}       comprehension set
 ℙ(S)      power set
 ℙ₁(S)     set of non-empty subsets
 FIN(S)      set of all finite subsets
 FIN1(S)     set of all non-empty finite subsets
 card(S)     cardinality
 S*T         cartesian product
 S∪T        set union
 S∩T        set intersection
 S-T         set difference
 E∈S         element of
 E∉S        ¬ element of
 S⊆T        subset of
 S⊈T       ¬ subset of
 S⊂T       strict subset of
 S⊄T      ¬ strict subset of
 union(S)        generalised union over sets of sets
 inter(S)         generalised intersection over sets of sets
 UNION(z).(P|E)  generalised union with predicate
 INTER(z).(P|E)  generalised intersection with predicate

Numbers∈
--------
 ℤ     set of integers
 ℕ     set of ℕ numbers
 ℕ₁    set of non-zero ℕ numbers
 INT         set of implementable integers (MININT..MAXINT)
 NAT         set of implementable ℕ numbers
 NAT1        set of non-zero implementable ℕ numbers
 n..m        set of numbers from n to m
 MININT      the minimum implementable integer
 MAXINT      the maximum implementable integer
 m>n         greater than
 m<n         less than
 m≥n        greater than ∨ equal
 m≤n        less than ∨ equal
 max(S)      maximum of a set of numbers
 min(S)      minimum of a set of numbers
 m+n         addition
 m-n         difference
 m*n         multiplication
 m/n         division
 m**n        power
 m mod n     remainder of division
 PI(z).(P|E)    Set product
 SIGMA(z).(P|E) Set summation
 succ(n)     successor (n+1)
 pred(n)     predecessor (n-1)


Relations∈
----------
 S↔T     relation
 E↦F     maplet
 dom(r)    domain of relation
 ran(r)    range of relation
 id(S)     identity relation
 S◁r      domain restriction
 S⩤r     domain subtraction
 r▷S      range restriction
 r⩥S     range subtraction
 r⁻¹        inverse of relation
 r[S]      relational image
 r1<+r2    relational overriding (r2 overrides r1)
 r1><r2    direct product {x,(y,z) | x,y∈r1 ∧ x,z∈r2}
 (r1;r2)     relational composition {x,y| x↦z∈r1 ∧ z↦y∈r2}
 (r1||r2)    parallel product {((x,v),(y,w)) | x,y∈r1 ∧ v,w∈r2}
 prj1(S,T)     projection function (usage prj1(Dom,Ran)(Pair))
 prj2(S,T)     projection function (usage prj2(Dom,Ran)(Pair))
 closure1(r)   transitive closure
 closure(r)    reflexive ∧ transitive closure
               (equal to id(TYPEOF_r) ∪ closure1(r))
 iterate(r,n)  iteration of r with n≥0 
               (Note∈ iterate(r,0) = id(s) where s =TYPEOF_r)
 fnc(r)    translate relation A↔B into function A⇸POW(B)
 rel(r)    translate relation A↔POW(B) into relation A↔B

Functions∈
----------
  S⇸T      partial function
  S→T      total function
  S+->>T     partial surjection
  S-->>T     total surjection
  S>+>T      partial injection
  S>->T      total injection
  S>+>>T     partial bijection
  S>->>T     total bijection
  λx.(P|E)   lambda abstraction
  f(E)       function application
  f(E1,...,En)   is now supported (as well as f(E1↦E2))


Sequences∈
----------
  <> ∨ []   empty sequence
  [E]        singleton sequence
  [E,F]      constructed sequence
  seq(S)     set of sequences over Sequence
  seq1(S)    set of non-empty sequences over S
  iseq(S)    set of injective sequences
  iseq1(S)   set of non-empty injective sequences
  perm(S)    set of bijective sequences (permutations)
  size(s)    size of sequence
  s^t        concatenation
  E->s       prepend element
  s<-E       append element
  rev(s)     reverse of sequence
  first(s)   first element
  last(s)    last element
  front(s)   front of sequence (all but last element)
  tail(s)    tail of sequence (all but first element)
  conc(S)    concatenation of sequence of sequences
  s/|\n     take first n elements of sequence
  s\|/n     drop first n elements from sequence
