CADiZ

Reference manual / Extended toolkit / section seqdefs


Sequences

The `definition' parts of this chapter are a formal specification of the sequence section of the tool-kit. The principle of definition before use has been observed in all cases. Furthermore, all definitions are explicit, so that the model conjecture for the whole of this section is trivially satisfied.

Written by Sam Valentine

Last updated September 1999

section seqdefs parents numdefs, setdefs

Name

.. -- Number range

Definition

function 20 leftassoc  (_ .. _)

_ .. _ == \lambda a, b: \real @ { k: \num | a \leq k \leq b }

Name

# -- Number of members of a set

Definition

# [X] == { S: \power X; n: \nat | 1 .. n \bij S \neq \emptyset }

Name

items -- Bag of elements of an indexed set

Definition

items [I, X] == \lambda s: I \rel X | \forall x: X @ finite (s \rres { x }) @
\lambda x: ran s @ # (s \rres { x })

Name

min, max -- Minimum and maximum of a set of numbers

Definition

min == { S: \power1 \real; m: \real |
    m \in S \land (\forall n: S @ m \leq n) @ S \mapsto m )

max == {S: \power1 \real; m: \real |
    m \in S \land (\forall n: S @ m \geq n) @ S \mapsto m )

Sequences

Name

sequence -- Sequences
seq -- Finite sequences
sequence1 -- Non-empty sequences
isequence -- Injective sequences

Definition

generic (sequence _)

sequence X == { f: \nat1 \pfun X | \forall n: dom f; m: \nat1 | m < n @ m \in dom f }

sequence1 X == { f: sequence X | f \neq \emptyset }

generic (isequence _)

isequence X == sequence X \cap (\nat1 \pinj X)

isequence1 X == { f: isequence X | f \neq \emptyset }

generic (seq _)

seq X == { f: sequence X | finite f }

seq1 X == { f: seq X | f \neq \emptyset }

generic (iseq _)

iseq X == { f: isequence X | finite f }

iseq1 X == { f: iseq X | f \neq \emptyset }

Description

sequence X is the set of finite or infinite sequences over X. These are functions from \nat1 to X where for every element in the domain, all lower members of \nat1 are also in the domain. There are then three possible orthogonal restrictions on sequences, generating eight cases in all. The restrictions are: to finiteness, seq X etc, to non-emptiness, sequence1 X etc, and to injectivity, isequence X etc.

Name

Finite Sequence Displays.

Definition

function  (\langle ,, \rangle)

\langle ,, \rangle [X] == \lambda s: seq X @ s

Name

\cat -- Concatenation

Definition

function 30 leftassoc  (_ \cat _)

_ \cat _ [X] == \lambda s: seq X; t: sequence X @ s \cup { n: dom t @ n + # s \mapsto t n }

Name

rev -- Reverse

Definition

rev [X] == \lambda s: seq X @ { n: dom s @ # { i: dom s | n \leq i } \mapsto s n }

Name

head, last, tail, front -- Sequence decomposition

Definition

head [X] == \lambda s: sequence1 X @ s 1

last [X] == \lambda s: seq1 X @ s (# s)

tail [X] == \lambda s: sequence X @ { m, n: dom s | n = m + 1 @ m \mapsto s n }

front [X] == \lambda s: sequence X @ { m, n: dom s | n = m + 1 @ m \mapsto s m }

Name

squash -- Compaction
\extract -- Extraction
\filter -- Filtering

Definition

squash [X] == \lambda f: \nat \pfun X @ { p: dom f @ # { i: dom f | i \leq p } \mapsto f p }

function 40 leftassoc  (_ \filter _)

_ \filter _ [X] == \lambda s: sequence X; V: \power X @ squash (s \rres V)

function 41 rightassoc  (_ \extract _)

_ \extract _ [X] == \lambda U: \power \nat; s: sequence X @ squash (U \dres s)

Name

prefix -- Prefix relation
suffix -- Suffix relation
infix -- Segment relation

Definition

relation (_ prefix _)

_ prefix _ [X] == { s, t: sequence X | s \subseteq t }

relation (_ suffix _)

_ suffix _ [X] == { s, t: sequence X | (\exists u: seq X @ u \cat s = t) }

relation (_ infix _)

_ infix _ [X] == { s, t: sequence X | (\exists u: seq X @ u \cat s \subseteq t) }

Name

+/ -- Distributed sum

Definition

+/ [ I ] == \bigcap { f: (I \rel \real) \rel \real |
    (\emptyset , 0) \in f \land
    (\forall S: I \rel \real; p: I \cross \real; x: \real |
    p \in S \land (S \ { p }, x) \in f @
    (S, x + p.2) \in f) )

Name

\dcat -- Distributed concatenation

Definition

\dcat [X] == \lambda s: sequence sequence X | front s \in sequence seq X @
    { m: dom s; n: \nat1 | n \in dom (s m) @
    (n + +/ (\lambda k: 1 .. m - 1 @ # (s k)), s m n) )

Name

Rk -- Iteration

Definition

iter [X] == \bigcap { f: \num \rel (X \rel X) \rel (X \rel X) |
    (0, (\lambda R: X \rel X @ id X)) \in f \land
    (\forall k: \nat; R, S: X \rel X; g: (X \rel X) \rel (X \rel X) |
    (R, S) \in g \land (k, g) \in f @
    \exists h: (X \rel X) \rel (X \rel X) @ (R, R \comp S) \in h \land (k + 1, h) \in f) \land
    (\forall k: \nat; R, S: X \rel X; g: (X \rel X) \rel (X \rel X) |
    (R ~ , S) \in g \land (k, g) \in f @
    \exists h: (X \rel X) \rel (X \rel X) @ (R, S) \in h \land (- k, h) \in f) )

Notation

iter k R is sometimes written Rk.

function ( _  _  )

_ _ [X] == \lambda r : X \rel X; n : \nat @ iter n r

IT 22-Jan-2002