(Co)Algebraic Specification with Base Sets, Recursive and Iterative Equations

Peter Padawitz

TU Dortmund, Germany June 2, 2016

(actual version: http://fldit-www.cs.uni-dortmund.de/∼peter/IFIP2014.pdf) More details can be found in:

• Algebraic Compiler Construction

• Fixpoints, Categories, and (Co)Algebraic Modeling

• From Modal Logic to (Co)Algebraic Reasoning (with Expander2)

We present some fundamentals of a uniform approach to specify, implement and reason about (co)algebraic models in a many-sorted setting that covers constant, polynomial and collection types. Three kinds of (infinite-)tree models (finite terms, coterms and continuous trees) yield concrete representations (and Haskell implementations) of initial resp. final models.

On the axiomatic side, a format for recursive equations, which define either constructors on a final model or destructors on an initial one, is introduced. We show how iterative equations, which define continuous trees, can be translated into recursive equations so that the unique solvability of the latter implies the unique solvability of the former.

As a prototypical example, recursive equations define the Brzozowski automaton whose states are regular expressions and which accepts regular languages. We show how this set of equations can be extended by equations representing a non-left-recursive grammar G such that it defines an acceptor of the language of G.

• Syntax 4

• Semantics 12

• Initial and final algebras 27

• Recursive equations 48

• Iterative equations 59

• Context-free grammars with base sets 67

• Constructing recursive from iterative equations 75

• (Co-)Horn Logic 82

Let S be a set of sorts.

An S-sorted set A is a tuple (A_s)_s∈S of sets.

We also write A for the union of A_s over all s ∈ S.

An S-sorted subset B of A, written as B ⊆ A, is an S-sorted set with B_s ⊆ A_s for all s ∈ S.

Given S-sorted sets A₁, . . . , A_n, an S-sorted relation r ⊆ A₁× · · · ×A_n is an S-sorted set with r_s ⊆ A_1,s × . . .× A_n,s for all s ∈ S.

The S-sorted binary relation ∆_A = {∆_A,s | s ∈ S} is called the diagonal of A².

Given S-sorted sets A and B, an S-sorted function f : A → B is an S-sorted set such that for all s ∈ S, f_s is a function from A_s to B_s.

Set^S denotes the category of S-sorted sets and S-sorted functions.

Let S and BS be sets of sorts and base sets, respectively.

The set T(S, BS) of types over S and BS is inductively defined as follows:

• S ⊆ T(S, BS). (sorts)

• BS ⊆ T(S, BS). (base sets)

• For all n > 0, e₁, . . . , e_n ∈ T(S, BS), e₁ × · · · × e_n ∈ T(S, BS). (product types) The nullary product is identified with the base set 1 = {}.

• For all n > 0, e₁, . . . , e_n ∈ T(S, BS), e₁ + · · ·+ e_n ∈ T(S, BS). (sum types)

• For all e ∈ T(S, BS), word(e), bag(e), set(e) ∈ T(S, BS). (collection types over e)

• For all X ∈ BS and e ∈ T(S, BS), e^X ∈ T(S, BS). (power types over e)

• For all e, e⁰ ∈ T(S, BS) with e⁰ 6∈ BS, e^e0 ∈ T(S, BS). (higher-order types over e) A type is first-order if it does not contain higher-order types.

T¹(S, BS) denotes the set of first-order types over S and BS.

A type is flat if it is a sort, a base set or a collection or power type over a sort.

FT(S, BS) denotes the set of flat types over S and BS. A signature Σ = (S, BS, BF, F, P)

consists of

• a finite set S of sorts (symbols for sets),

• a finite set BS of base sets, implicitly including 1 = {} and 2 = {0,1},

• a finite set BF of base functions f : X → Y with X, Y ∈ BS,

• a finite set F of operations (symbols for functions) f : e → e⁰ with e, e⁰ ∈ T(S, BS),

• a finite set P of predicates (symbols for relations) p : e where e is a finite product of sorts and base sets.

For all f : e → e⁰ ∈ F, dom(f) = e resp. ran(f) = e⁰ is the domain resp. range of f. For all p : e ∈ P, dom(p) = e is the domain of p.

Given signatures Σ and Σ⁰, Σ ∪ Σ⁰ denotes the componentwise union of Σ and Σ⁰.

f ∈ F is a constructor if there are flat types e₁, . . . , e_n over S and BS such that dom(f) = e₁ × · · · ×e_n and ran(f) ∈ S.

f ∈ F is a destructor if there are non-power flat types e₁, . . . , e_n over S and BS and X ∈ BS such that dom(f) ∈ S and ran(f) = (e₁ +· · · + e_n)^X.

Σ is constructive resp. destructive if F consists of constructors resp. destructors.

Constructive signatures

Let X be a set of constants and CS be a set of nonempty sets of constants.

Nat 1 natural numbers

S = {nat}, BS = ∅, F = { zero : 1 → nat, succ : nat → nat }.

List(X) 1 finite sequences of elements of X

S = {list}, BS = {X}, F = { nil : 1 → list,

cons : X × list → list }.

Reg(CS) 1 regular expressions over CS and regular languages over X = S CS S = {reg}, BS = ∅, F = { eps : 1 → reg,

mt : 1 → reg,

par : reg × reg → reg, (parallel composition) seq : reg × reg → reg, (sequential composition) iter : reg → reg } ∪ (iteration)

{ C : 1 → reg | C ∈ CS } The nullary constructor C stands for a name of the set C. Destructive signatures

Let X and Y be sets of constants.

coNat 1 natural numbers with infinity

S = {nat}, BS = ∅, F = {pred : nat → 1 + nat}.

coList(X) 1 finite or infinite sequences of elements of X (coList(1) =b coNat) S = {list, pair}, BS = {X}, F = { split : list → 1 + pair,

first : pair → X, rest : pair → list }.

DAut(X, Y) 1 deterministic Moore automata with input from X and output in Y S = {state}, BS = {X, Y}, F = { δ : state → state^X,

β : state → Y }.

Acc(X) =b DAut(X,2) 1 deterministic acceptors of subsets of X^∗ S = {reg}, BS = {X,2}, F = { δ : reg → reg^X,

β : reg → 2 }.

Stream(X) =b DAut(1, X) 1 streams over X

S = {list}, BS = {X}, F = { head : list → X, tail : list → list }.

Let V be a T(S, BS)-sorted set of variables.

The T(S, BS)-sorted set T_Σ(V) of Σ-terms over V is inductively defined as follows:

• For all e ∈ T(S, BS), V_e ⊆ T_Σ(V)_e.

• For all X ∈ BS, X ⊆ T_Σ(V)_X.

• For all f : 1 → e ∈ BF ∪ F, f ∈ T_Σ(V )_e.

• For all n > 1, e₁, . . . , e_n ∈ T(S, BS), t ∈ T_Σ(V )_{e1×···×en} and 1 ≤ i ≤ n, π_it ∈ T_Σ(V)_ei.

• For all n > 1, e₁, . . . , e_n ∈ T(S, BS), 1 ≤ i ≤ n and t ∈ T_Σ(V)_ei, ι_it ∈ T_Σ(V)_e1+···+en.

• For all n > 1, e₁, . . . , e_n ∈ T(S, BS) and t_i ∈ T_Σ(V)_ei, 1 ≤ i ≤ n, (t₁, . . . , t_n) ∈ T_Σ(V)_{e1×···×en}.

• For all f : e → e⁰ ∈ BF ∪ F and t ∈ T_Σ(V )_e, f t ∈ T_Σ(V)_e⁰.

• For all c ∈ {word, bag, set}, e ∈ T(S, BS) and t ∈ T_Σ(V)^∗_e, c(t) ∈ T_Σ(V)_c(e).

• For all n > 0, e₁, . . . , e_n, e ∈ T(S, BS), x ∈ V_e1 ∪ · · · ∪ V_en and t₁, . . . , t_n ∈ T_Σ(V)_e, λx.(t₁|. . .|t_n) ∈ T_Σ(V)_e^e₁₊^···+en.

• For all e, e⁰ ∈ T(S, BS), t ∈ T_Σ(V ) ⁰ and u ∈ T_Σ(V)_e⁰, t(u) ∈ T_Σ(V)_e.

• For all e ∈ T(S, BS), t ∈ T_Σ(V )₂ and u, v ∈ T_Σ(V)_e, ite(t, u, v) ∈ T_Σ(V)_e. A Σ-term t that does not contain variables or ite, then t is called ground.

T_Σ denotes the set of ground Σ-terms.

The set Fo_Σ(V ) of Σ-formulas over V is inductively defined as follows:

• True,False ∈ Fo_Σ(V ).

• For all p : e ∈ P and t ∈ T_Σ(V)_e, pt ∈ Fo_Σ(V ). (Σ-atoms over V )

• For all e ∈ T(S, BS) and t, u ∈ T_Σ(V)_e, t =_e u ∈ Fo_Σ(V ). (Σ-equations over V )

• For all ϕ ∈ Fo_Σ(V), ¬ϕ ∈ Fo_Σ(V ).

• For all ϕ, ψ ∈ Fo_Σ(V), ϕ∧ ψ, ϕ∨ ψ, ϕ ⇒ ψ, ϕ ⇐ ψ, ϕ ⇔ ψ ∈ Fo_Σ(V ).

• For all x ∈ V and ϕ ∈ Fo_Σ(V), ∀xϕ, ∃xϕ ∈ Fo_Σ(V).

[0] =_def ∅ and for all n > 0, [n] =_def {1, . . . , n}.

For all f : A → B, f^∗ : A^∗ → B^∗ is defined as follows:

f^∗() = and for all n > 0 and (a₁, . . . , a_n) ∈ Aⁿ, f^∗(a₁, . . . , a_n) = (f(a₁), . . . , f(a_n)).

Let A, B be sets and a = (a₁, . . . , a_m), b = (b₁, . . . , b_n) ∈ A^∗. a =_word b ⇔_def a = b.

a =_bag b ⇔_def ∃ f : [n] →^∼ [n] : (a₁, . . . , a_n) = (b_f(1), . . . , b_f(n)), i.e., b is a permutation of a.

a =_set b ⇔_def {a₁, . . . , a_m} = {b₁, . . . , b_n}.

Let h : A → B.

B_fin(A) =_def A/=_bag and B_fin(h) : B_fin(A) → B_fin(B) maps [a]_=bag to [h^∗(a)]_=bag.

P_fin(A) = {C ⊆ A | |A| < ω} and P_fin(h) : P_fin(A) → P_fin(B) maps C to {f(a) a ∈ C}.

Predicate lifting

For alle e ∈ T¹(S, BS), the functor F_e : Set^S → Set is inductively defined as follows:

For all S-sorted sets A, B, S-sorted functions h : A → B, s ∈ S, X ∈ BS, n > 1 and e, e₁, . . . , e_n ∈ T¹(S, BS),

F_s(A) = A_s, F_s(h) = h_s, (projection functor)

F_X(A) = X, F_X(h) = id_X, (constant functor)

F_e1+···+en(A) = F_e1(A) + · · · +F_en(A), F_e1+···+en(h) = F_e1(h) + · · · +F_en(h), F_{e1×···×en}(A) = F_e1(A) × . . .× F_en(A), F_{e1×···×en}(h) = F_e1(h)× . . . × F_en(h), F_word(e)(A) = F_e(A)^∗, F_word(e)(h) = F_e(h)^∗,

F_bag(e)(A) = B_fin(F_e(A)), F_bag(e)(h) = B_fin(F_e(h)), F_set(e)(A) = P_fin(F_e(A)), F_set(e)(h) = P_fin(F_e(h)), F_eX(A) = F_e(A)^X, F_eX(h) = F_e(h)^X.

We mostly write A_e instead of F_e(A).

Relation lifting

Given an S-sorted relation R ⊆ A × B, R is extended to a T¹(S, BS)-sorted relation inductively as follows:

Let s ∈ S, e₁, . . . , e_n, e ∈ T¹(S, BS) and X ∈ BS. R_X = ∆_X,

R_e1+···+en = {((a, i),(b, i)) ∈ (`n

i=1 A_ei) × `n

i=1 B_ei | (a, b) ∈ R_ei, 1 ≤ i ≤ n}, R_{e1×···×en} = {((a₁, . . . , a_n),(b₁, . . . , b_n)) ∈ (Qn

i=1A_ei) × Qn

i=1 B_ei

| ∀ 1 ≤ i ≤ n : (a_i, b_i) ∈ R_ei}, R_word(e) = S

n∈N{((a₁, . . . , a_n),(b₁, . . . , b_n)) ∈ A^∗_e ×B_e^∗

| ∀ 1 ≤ i ≤ n : (a_i, b_i) ∈ R_e}, R_bag(e) = S

n∈N{([(a₁, . . . , a_n)]_=bag,[(b₁, . . . , b_n)]_=bag) ∈ B_fin(A_e) × B_fin(B_e)

| ∀ 1 ≤ i ≤ n : (a_i, b_i) ∈ R_e}, R_set(e) = {(C, D) ∈ P_fin(A_e) × P_fin(B_e) | ∀ c ∈ C ∃ d ∈ D : (c, d) ∈ R_e,

∀ d ∈ D ∃ c ∈ C : (c, d) ∈ R_e}, R_e^X = {(f, g) | ∀ x ∈ X : (f(x), g(x)) ∈ R_e}.

Let Σ = (S, BS, BF, F, P) be a signature.

A Σ-algebra A consists of

• an S-sorted set, called the carrier of A and often also denoted by A,

• for each f : e → e⁰ ∈ F, a function f^A : A_e → A_e⁰,

• for each p : e ∈ P, a subset p^A of A_e.

Suppose that all function and relation symbols of Σ have first-order domains and ranges.

Let A, B be Σ-algebras.

An S-sorted function h : A → B is a Σ-homomorphism if for all f : e → e⁰ ∈ F, h_e⁰ ◦f^A = f^B ◦ h_e, and for all p : e ∈ P, h_e(p^A) ⊆ p^B.

Alg_Σ denotes the category of Σ-algebras and Σ-homomorphisms.

1 A Σ-homomorphism h is iso in Alg_Σ iff his bijective and for all p : e ∈ P, p^B ⊆ h_e(p^A).

Let U_S be the forgetful functor from Alg_Σ to Set^S.

For all f : e → e⁰ ∈ F, f : F_eU_S → F_e⁰U_S with f(A) =_def f^A for all A ∈ Alg_Σ is a natural transformation:

A_e f^A

A_e⁰

B_e h_e

g f^B

B_e⁰ h_e⁰ g

Given a category K and an endofunctor F on K,

• an F-algebra or F-dynamics is a K-morphism α : F(A) → A,

• an F-coalgebra or F-codynamics is a K-morphism α : A → F(A).

Alg_F and coAlg_F denote the categories of F-algebras resp. F-coalgebras where

• an Alg_F-morphism from α : F(A) → A to β : F(B) → B is a K-morphism h:A → B with h◦ α = β ◦ F(h),

• a coAlg_F-morphism fromα : A : F(A) toβ : B → F(B)is a K-morphism h:A → B with F(h) ◦α = β ◦ h.

A constructive signature Σ = (S, BS, BF, F, P) induces a functor

H_Σ : Set^S → Set^S : For all A, B ∈ Set^S, h ∈ Set^S(A, B) and s ∈ S,

H_Σ(A)_s = `

f:e→s∈F A_e, H_Σ(h)_s = `

f:e→s∈F h_e. Alg_Σ and Alg_HΣ are equivalent categories:

Let A ∈ Alg_Σ and α : A → H_Σ(A) ∈ Alg_HΣ.

The H_Σ-algebra A⁰ : A → H_Σ(A) and the Σ-algebra α⁰ are defined as follows:

For all s ∈ S and f : e → s ∈ F,

H_Σ(A)_s A⁰_s = [f^A]_f:e→s∈F A_s

A_e ι_f

f

f^α0 = α_s ◦ ι_f

Examples

H_Nat(A)_nat = 1 +A_nat,

H_List(X)(A)_list = 1 + (X × A_list),

H_Reg(CS)(A)_reg = 1 + 1 +CS +A²_reg + A²_reg +A_reg.

h : A → B is a Σ-homomorphism ⇐⇒ h is an Alg_HΣ-morphism from α(A) to α(B):

A_e f^A

A_s H_Σ(A)_s α(A)_s

A_s

⇐⇒

B_e h_e

g

f^B B_s h_s

g H_Σ(B)_s H_Σ(h)_s

g

α(B)_sB_s h_s g

h : α → β is an Alg_HΣ-morphism ⇐⇒ h is a Σ-homomorphism from A(α) to A(β):

H_Σ(A)_s α_s

A_s A_e f^A(α)

A_s

⇐⇒

H_Σ(B)_s H_Σ(h)_s

g

β_s B_s h_s

g B_e h_e

g

f^A(β) B_s h_s g

A destructive signature Σ = (S, BS, BF, F, P) induces a functor

H_Σ : Set^S → Set^S : For all A, B ∈ Set^S, h ∈ Set^S(A, B) and s ∈ S,

H_Σ(A)_s = Q

f:s→e∈F A_e, H_Σ(h)_s = Q

f:s→e∈F h_e. Alg_Σ and coAlg_HΣ are equivalent categories:

Let A ∈ Alg_Σ and α : H_Σ(A) → A ∈ coAlg_HΣ.

The H_Σ(A)-coalgebra A⁰ : H_Σ(A) → A and the Σ-algebra α⁰ are defined as follows:

For all s ∈ S and f : s → e ∈ F,

A_s A⁰_s = hf^Ai_f:s→e∈F

H_Σ(A)_s

A_e π_f f^α0 = π_f ◦ α_s g

Examples

H_coNat(A)_nat = 1 + A_nat,

H_coList(X)(A)_list = 1 + (X ×A_list), H_DAut(X,Y)(A)_state = A^X_state ×Y.

Haskell implementation of Alg_Σ

Let Σ = (S, BS,∅, F,∅) be a signature,

BS = {X₁, . . . , X_k}, S = {s₁, . . . , s_m} and F = {f₁ : e₁ → e⁰₁, . . . , f_n : e_n → e⁰_n}.

Each Σ-algebra is an element of the following Haskell datatype:

data Sigma x1 ... xk s1 ... sm = Sigma {f1 :: e1 -> e1’,..., fn :: en -> en’}

Examples

data Nat nat = Nat {zero :: nat, succ :: nat -> nat}

data List x list = List {nil :: list, cons :: x -> list -> list}

data Reg cs reg = Reg {eps,mt :: reg, con :: cs -> reg, par,seq :: reg -> reg -> reg, iter :: reg -> reg}

data Conat nat = Conat {pred :: nat -> Maybe nat}

data Colist x list = Colist {split :: list -> Maybe (x,list)}

data DAut x y state = DAut {delta :: state -> x -> state, beta :: state -> y}

Evaluation of terms and formulas

Let V be a T(S, BS)-sorted set of variables, A be a Σ-algebra and A^V be the set of valuations of V in A, i.e., T(S, BS)-sorted functions from V to A.

For all g ∈ A^V, e ∈ T(S, BS), a ∈ A_e, x ∈ V_e and z ∈ V. g[a/x](z) =_def

( a if z = x, g(z) otherwise.

The T(S, BS)-sorted extension g^∗ : T_Σ(V) → A of g is defined as follows:

• For all x ∈ V , g^∗(x) = g(x).

• For all x ∈ X ∈ ∪BS, g^∗(x) = x.

• For all n > 1, e₁, . . . , e_n ∈ T(S, BS), t = (t₁, . . . , t_n) ∈ T_Σ(V)_{e1×···×en} and 1 ≤ i ≤ n, g^∗(π_it) = g^∗(t_i).

• For all n > 1, e₁, . . . , e_n ∈ T(S, BS), 1 ≤ i ≤ n and t ∈ T_Σ(V)_ei, g^∗(ι_it) = (g^∗(t), i).

• For all n ∈ N and t₁, . . . , t_n ∈ T_Σ(V ), g^∗(t₁, . . . , t_n) = (g^∗(t₁), . . . , g^∗(t_n)).

• For all f : e → e⁰ ∈ F and t ∈ T_Σ(V )_e, g^∗(f(t)) = f^A(g^∗(t)).

• For all c ∈ {word, bag, set}, c(t) ∈ T_Σ(V )_c(e), g^∗(c(t)) = [g^∗(t)]_=c.

• For all n > 0, e₁, . . . , e_n, e ∈ T(S, BS), x ∈ V_e1 ∪ · · · ∪ V_en, t_i ∈ T_Σ(V )_e, 1 ≤ i ≤ n, and (a, i) ∈ A_e1+···+en,

g^∗(λx.(t₁|. . .|t_n))(a, i) = g[a/x]^∗(t_i).

• For all e, e⁰ ∈ T(S, BS), t ∈ T_Σ(V )_ee⁰ and u ∈ T_Σ(V)_e⁰, g^∗(t(u)) = g^∗(t)(g^∗(u)).

• For all e ∈ T(S, BS), t ∈ T_Σ(V )₂ and u, v ∈ T_Σ(V)_e, g^∗(ite(t, u, v)) =

( g^∗(u) if g^∗(t) = 1, g^∗(v) otherwise.

A Σ-term t is first-order if the range of each subterm of t is first-order.

For all e ∈ T(S, BS) and first-order Σ-terms t, we define:

t^A : A^V → A_e g 7→ g^∗(t)

t : _^V → F_eU_S with t_A =_def t^A for all A ∈ Alg_Σ is a natural transformation:

A^V t^A

A_e (1)

B^V h^V

g

t^B B_e h_e g

(1) is equivalent to the Substitution Lemma:

For all g ∈ A^V, Σ-homomorphisms h : A → B and first-order Σ-terms t,

(h◦ g)^∗(t) = (h◦g^∗)(t). (2)

A interprets a Σ-formula ϕ over V by the set ϕ^A ⊆ A^V of valuations that satisfy ϕ and is inductively defined as follows:

For all e ∈ T(S, BS), p : e ∈ P, t, u ∈ T_Σ(V )_e, ϕ, ψ ∈ Fo_Σ(V), s ∈ S ∪ BS and x ∈ V_s, True^A = A^V,

False^A = ∅,

p(t)^A = {g ∈ A^V | g^∗(t) ∈ p^A}, (¬ϕ)^A = A^V \ ϕ^A,

(ϕ∧ ψ)^A = ϕ^A ∩ ψ^A, (ϕ∨ ψ)^A = ϕ^A ∪ ψ^A,

(ϕ ⇒ ψ)^A = (ψ ⇐ ϕ)^A = (¬ϕ ∨ ψ)^A,

(ψ ⇔ ϕ)^A = (ϕ ⇒ ψ)^A ∩ (ϕ ⇐ ψ)^A,

(∀xϕ)^A = {g ∈ A^V | ∀ a ∈ A_s : g[a/x] ∈ ϕ^A}, (∃xϕ)^A = {g ∈ A^V | ∃ a ∈ A_s : g[a/x] ∈ ϕ^A}.

A satisfies ϕ ∈ Fo_Σ(V ), written as A |= ϕ, if ϕ^A = A^V. The Substitution Lemma implies:

For all negation-free Σ-formulas ϕ, g ∈ A^V and Σ-homomorphisms h : A → B, g ∈ ϕ^A ⇒ h ◦g ∈ ϕ^B.

An S-sorted binary relation R on A is a Σ-congruence on A if for all f : e → e⁰ ∈ F and (a, b) ∈ R_e, (f^A(a), f^A(b)) ∈ R_e⁰.

If Σ is destructive, then Σ-congruences are also called Σ-bisimulations.

An S-sorted subset B of A is a Σ-invariant (or Σ-subalgebra of A) if for all f : e → e⁰ ∈ F andl a ∈ A_e, f^A(a) ∈ A_e⁰.

A Σ-algebra A satisfies the induction principle if for all S-sorted subsets B of A, A ⊆ B iff B contains a Σ-invariant.

A is initial in Alg_Σ ⇐⇒ A satisfies the induction principle and for all Σ-algebras B there is a Σ-homomorphism from A to B.

A Σ-algebra A satisfies the coinduction principle if for all S-sorted binary relations R on A, R ⊆ ∆_A iff R is contained in a Σ-congruence.

A is final in Alg_Σ ⇐⇒ A satisfies the coinduction principle and for all Σ-algebras B there is a Σ-homomorphism from B to A.

Terms for constructive signatures

Let Σ = (S, BS, BF, F) be a constructive signature.

T_Σ is a Σ-algebra:

For all f : e → s ∈ F and t ∈ T_Σ,e, f^TΣ(t) =_def f t.

Let ∼ be the least FT(S, BS)-sorted equivalence relation on T_Σ such that

• for all n > 1, e₁, . . . , e_n ∈ FT(S, BS) and t_i, t⁰_i ∈ T_Σ,ei, 1 ≤ i ≤ n,

t₁ ∼_e1 t⁰₁ ∧ · · · ∧ t_n ∼_en t⁰_n implies (t₁, . . . , t_n) ∼_{e1×···×en} (t⁰₁, . . . , t⁰_n),

• for all n > 1, e ∈ FT(S, BS) and t_i, t⁰_i ∈ T_Σ,e, 1 ≤ i ≤ n,

t₁ ∼_e t⁰₁ ∧ · · · ∧t_n ∼_e t⁰_n implies word(t₁, . . . , t_n) ∼_word(s) word(t⁰₁, . . . , t⁰_n),

• for all n > 1, e ∈ FT(S, BS), f : [n] →^∼ [n] and t_i, t⁰_i ∈ T_Σ,e, 1 ≤ i ≤ n,

t₁ ∼_e t⁰₁ ∧ · · · ∧ t_n ∼_e t⁰_n implies bag(f(t₁), . . . , f(t_n)) ∼_bag(s) bag(t⁰₁, . . . , t⁰_n),

• for all m, n > 0, e ∈ FT(S, BS), t_i ∈ T_Σ,e, i ∈ [m], and t⁰_i ∈ T_Σ,e, 1 ≤ i ≤ n,

∀ 1 ≤ i ≤ m ∃ 1 ≤ j ≤ n : t_i ∼_e t⁰_j ∧ ∀ 1 ≤ j ≤ n ∃ 1 ≤ i ≤ m : t_i ∼_e t⁰_j implies set(t₁, . . . , t_m) ∼_set(s) set(t⁰₁, . . . , t⁰_n),

• for all s ∈ S, f : e → s ∈ F and t, t⁰ ∈ T_Σ,e, t ∼_e t⁰ implies f t ∼_s f t⁰,

• for all X ∈ BS, ∼_X= ∆_X.

For simplicity, we identify T_Σ with T_Σ/∼.

T_Σ is initial in Alg_Σ.

For all Σ-algebras A, the unique Σ-homomorphism fold^A : T_Σ → A is defined inductively as follows:

For all f : e → s ∈ F, t ∈ T_Σ,e, c ∈ {word, bag, set}, e⁰ ∈ S ∪ BS and t⁰ ∈ T_Σ,e^∗ 0, fold^A_s (f t) = f^A(fold^A_e (t)),

fold^A_c(e0)(c(t⁰)) = [fold^A_e0(t⁰)]_=c.

Haskell implementation of T_Σ and fold

All collection types are implemented by Haskell’s list type.

Let BS = {X₁, . . . , X_k}, S = {s₁, . . . , s_m} and

F = {c_ij : e_ij → s_i | 1 ≤ i ≤ m, 1 ≤ j ≤ n_i}, i.e., Alg_Σ is implemented by the following datatype:

data Sigma x1 ... xk s1 ... sm =

Sigma {c11 :: e11 -> s1,...,c1n_1 :: e1n_1 -> s1, ...

cm1 :: em1 -> sm,...,cmn_m :: emn_m -> sm}

The following datatypes provide the carriers of T_Σ:

data S1T x1 ... xk = C11 E11T | ... | C1n_1 E1n_1T ...

data SmT x1 ... xk = Cm1 Em1T | ... | Cmn_m Emn_mT

The algebra T_Σ is then defined as follows:

sigmaT :: Sigma x1 ... xk (S1T x1 ... xk) ... (SmT x1 ... xk) sigmaT = Sigma C11 ... C1n_1 ... Cm1 ... Cmn_m

Let 1 ≤ i ≤ m.

foldSi :: Sigma x1 ... xk s1 ... sm -> SiT x1 ... xk -> si foldSi alg ti = case ti of Ci1 t -> ci1 alg $ foldEi1 alg t

...

Cin_i t -> cin_i alg $ foldEin_i alg t foldWordSi,foldBagSi,foldSetSi :: Sigma x1 ... xk s1 ... sm

-> [SiT x1 ... xk] -> [si]

foldWordSi = map . foldSi foldBagSi = map . foldSi foldSetSi = map . foldSi

foldxi :: Sigma x1 ... xk s1 ... sm -> xi -> xi foldxi _ = id

foldE1x...xEn :: Sigma x1 ... xk s1 ... sm -> (E1T,...,EnT) -> (E1,...,En)

foldE1x...xEn alg (t1,...,tn) = (foldE1 alg t1,...,foldEn alg tn)

Examples

data NatT = Zero | Succ NatT natT :: Nat NatT

natT = Nat Zero Succ

foldNat :: Nat nat -> NatT -> nat

foldNat alg t = case t of Zero -> zero alg

Succ t -> succ alg $ foldNat alg t

data ListT x = Nil | Cons x (ListT x) listT :: List x (ListT x)

listT = List Nil Cons

foldList :: List x list -> ListT x -> list foldList alg t = case t of Nil -> nil alg

Cons x t -> cons alg x $ foldList alg t data RegT cs = Eps | Mt | Con cs | Par (RegT cs) (RegT cs) |

Seq (RegT cs) (RegT cs) | Iter (RegT cs) regT :: Reg cs (RegT cs)

regT cs = Reg Eps Mt Con Var Par Seq Iter

foldReg :: Reg cs reg -> RegT cs -> reg foldReg alg t = case t of

Eps -> eps alg Mt -> mt alg

Con c -> con alg c

Par t u -> par alg (foldReg alg t) $ foldReg alg u Seq t u -> seq alg (foldReg alg t) $ foldReg alg u Iter t -> iter alg $ foldReg alg t

Coterms for destructive signatures

Let Σ = (S, BS, BF, F) be a destructive signature and

Lab_Σ = {(d, x, i) | d : s → (e₁ +· · · +e_n)^X ∈ F, x ∈ X, 1 ≤ i ≤ n} ∪ N. For all d : s → e^X, a ∈ A_s and x ∈ X, d^A_x(a) =_def d^A(a)(x).

coT_Σ denotes the greatest FT(S, BS)-sorted set of prefix closed partial functions t : Lab^∗_Σ (→ 1 + {word, bag, set}+ ∪BS

such that the following conditions hold true:

• For all s ∈ S, t ∈ coT_Σ,s, d : s → (e₁ + · · · + e_n)^X ∈ F and x ∈ X, t() = and there is 1 ≤ i ≤ n such that (d, x, i) ∈ def (t), λw.t((d, x, i)w) ∈ coT_Σ,ei and for all (d, x, i),(d, x, j) ∈ def (t), dom(d) = s and i = j.

• For all c ∈ {word, bag, set}, s ∈ S ∪ BS and t ∈ coT_Σ,c(s), t() = c and there is n ∈ N such that for all 1 ≤ i ≤ n, λw.t(iw) ∈ coT_Σ,s, and def (t) ∩ Lab_Σ = [n].

• For all X ∈ BS, coT_Σ,X = X (here identified with the set 1 → X of functions).

The elements of coT_Σ are called Σ-coterms.

s₄

s₂

s₁

s₂ s₃

s₄

s₄

s₁ s₂

b

ε

f₂,2 f₁,3

f₅,2

f₆,3 f₇,2

f₃,1 f₄,1

f₃,2 f₄,4

f₅,3

s₁

d

f₅,2

f₁,2 f₂,1 f₃,2 f₄,2

f₁,2 c f₂,1 d

f₈,2

b

set

s₁ ^f1,3 f₂,3

c 1

2

A Σ-coterm with destructors f₁, . . . , f₈ that map into sum types.

Each root of a subcoterm is labelled with its sort.

Each leaf is labelled with a base element. Three dots stand for an infinite coterm.

For all t ∈ coT_Σ, let def₁(t) = def (t) ∩ Lab_Σ.

Let ∼ be the greatest FT(S, BS)-sorted equivalence relation on coT_Σ such that

• for all s ∈ S, t ∼_s t⁰ and d ∈ def₁(t), λw.t(dw) ∼ λw.t⁰(dw),

• for all s ∈ S ∪ BS and t ∼_word(s) t⁰, D =_def def₁(t) = def₁(t⁰) and for all i ∈ D, λw.t(iw) ∼_s λw.t⁰(iw),

• for all s ∈ S∪BS and t ∼_bag(s) t⁰, D =_def def₁(t) = def₁(t⁰) and there is f : [n] →^∼ [n]

such that for all i ∈ D, λw.t(iw) ∼_s λw.t⁰(f(i)w),

• for all s ∈ S ∪ BS, t ∼_set(s) t⁰ and i ∈ def₁(t) there is j ∈ def₁(t⁰) such that λw.t(iw) ∼_s λw.t⁰(jw),

for all s ∈ S ∪ BS, t ∼_set(s) t⁰ and j ∈ def₁(t⁰) there is i ∈ def₁(t) such that λw.t(iw) ∼_s λw.t⁰(jw),

• for all X ∈ BS, ∼_X= ∆_X.

For simplicity, we identify coT_Σ with coT_Σ/∼.

coT_Σ is a Σ-algebra:

For all s ∈ S, t ∈ coT_Σ,s, d : s → (e₁ + · · ·+ e_n)^X ∈ F, x ∈ X and w ∈ Lab^∗_Σ, (d, x, i) ∈ def (t) ⇒ d^coTΣ(t)(x)(w) = t((d, i, x)w).

Example 1

Let L = {(δ, x) | x ∈ X}. coT_DAut(X,Y) consists of all functions from L^∗ +L^∗β to 1 +Y, that for all w ∈ L^∗ map w to and wβ to an element of Y :

coT_DAut(X,Y) ∼= 1^L∗ × Y^L∗β ∼= Y ^L∗β

L^∗β∼=X^∗

∼= Y ^X∗.

Hence coT_DAut(X,Y) is DAut(X, Y )-isomorphic to the DAut(X, Y)-algebra Beh(X, Y ) of behavior functions that is defined as follows:

Beh(X, Y)_state = Y ^X∗. For all f : X^∗ → Y, x ∈ X und w ∈ X^∗,

δ^Beh(X,Y)(f)(x)(w) = f(xw) and β^Beh(X,Y)(f) = f().

ε

ε

0 β δ 1

x

β x z

y z

ε ε

ε

tup y tup

δ

ε

ε

x y

z

ε

ε

ε tup

δ x y

z

ε ε

ε

tup δ

1 β

0 β

A DAut({x, y, z}, Y )-coterm of sort state

coT_Σ is final in Alg_Σ.

For all Σ-algebras A, the unique Σ-homomorphism unfold^A : A → coT_Σ is defined as follows: For all s ∈ FT(S, BS), a ∈ A_s, (d, x, i) ∈ Lab_Σ, w ∈ Lab^∗_Σ and k ∈ N,

unfold_s (a)() = , unfold^A_s (a)((d, x, i)w) =







unfold^A_ei(b)(w) if d : s → (e₁ +· · · + e_n)^X ∈ F and d^A(a)(x) = (b, i),

undefined otherwise,

unfold^A_s (a)(kw) =











unfold^A_s (a_k)(w) if ∃ c ∈ {word, bag, set}, e ∈ S ∪ BS : s = c(e), a = [(a₁, . . . , a_n)]_=c

and 1 ≤ k ≤ n, undefined otherwise.

Example 2

Let A be a DAut(X, Y)-algebra, ξ : Beh(X, Y) → coT_DAut(X,Y) be the isomorphism of Example 1 and unfoldB : A → Beh(X, Y) be defined as follows:

For all a ∈ A_state, x ∈ X and w ∈ X^∗,

unfoldB^A(a)() = β^A(a),

unfoldB^A(a)(xw) = unfoldB^A(δ^A(a)(x))(w).

Since unfoldB is DAut(X, Y)-homomorphic,

unfold^A = ξ ◦unfoldB^A.

Haskell implementation of coT_Σ and unfold

Again, all collection types are implemented by Haskell’s list type.

Let BS = {X₁, . . . , X_k}, S = {s₁, . . . , s_m} and

F = {d_ij : s_i → e_ij | 1 ≤ i ≤ m, 1 ≤ j ≤ n_i}, i.e., Alg_Σ is implemented by the following datatype:

data Sigma x1 ... xk s1 ... sm =

Sigma {d11 :: s1 -> e11,...,d1n_1 :: s1 -> e1n_1, ...

dm1 :: sm -> em1,...,dmn_m :: sm -> emn_m}

The following datatypes provide the carriers of coT_Σ:

data S1C x1 ... xk = S1C {d11C :: E11C | ... | d1n_1C :: E1n_1C}

...

data SmC x1 ... xk = SmC {dm1C :: Em1C | ... | dmn_mC :: Emn_mC}

The algebra coT_Σ is then defined as follows:

sigmaC :: Sigma x1 ... xk (S1C x1 ... xk) ... (SmC x1 ... xk) sigmaC = Sigma d11C ... d1n_1C ... dm1C ... dmn_mC

Let 1 ≤ i ≤ m.

unfoldSi :: Sigma x1 ... xk s1 ... sm -> si -> SiC x1 ... xk unfoldSi alg ai = SiC (unfoldEi1 alg $ di1 alg ai)

...

(unfoldEin_i alg $ din_i alg ai)

unfoldWordSi,foldBagSi,foldSetSi :: Sigma x1 ... xk s1 ... sm -> [si] -> [SiT x1 ... xk]

unfoldWordSi = map . unfoldSi unfoldBagSi = map . unfoldSi unfoldSetSi = map . unfoldSi Let 1 ≤ i ≤ k and n > 1.

unfoldxi :: Sigma x1 ... xk s1 ... sm -> xi -> xi unfoldxi _ = id

unfoldE^xi :: Sigma x1 ... xk s1 ... sm -> (xi -> E) -> xi -> EC unfoldE^xi alg f = unfoldE alg . f

data Sum_n e1 ... en = S1 e1 | ... | Sn en

Let 1 ≤ i ≤ n.

unfoldE1+...+En :: Sigma x1 ... xk s1 ... sm -> Sum_n E1 ... En -> Sum_n E1C ... EnC unfoldE1+...+En alg a = case a of S1 a -> unfoldE1 alg a

...

Sn a -> unfoldEn alg a

Examples

data ConatC = ConatC {predC :: Maybe ConatC}

conatC :: Conat ConatC conatC = Conat predC

unfoldConat :: Conat nat -> nat -> ConatC

unfoldConat alg nat = ConatC $ do nat <- pred alg nat

Just $ unfoldConat alg nat

data ColistC x = ColistC {splitC :: Maybe (x,ColistC x)}

colistC :: Colist x (ColistC x) colistC = Colist splitC

unfoldColist :: Colist x list -> list -> ColistC x

unfoldColist alg list = ColistC $ do (x,list) <- split alg list

Just (x,unfoldColist alg list) data StateC x y = StateC {deltaC :: x -> StateC x y, betaC :: y}

dAutC :: DAut x y (StateC x y) dAutCot = DAut deltaC betaC

unfoldDAut :: DAut x y state -> state -> StateC x y

unfoldDAut alg state = StateC (unfoldDAut alg . delta alg state) (beta alg state)

Realization of elements of final algebras

Given a Σ-algebra A, a final Σ-algebra Fin, a ∈ A and f ∈ Fin, (A, a) realizes f iff unfold^A(a) = f.

Example 3

Let A be the following Acc(Z)-algebra:

eo :: DAut Int Bool Bool

eo = DAut (\state -> if state then even else not . even) id and

f : Z^∗ → 2 g : Z^∗ → 2

(x₁, . . . , x_n) 7→ Pn

i=1 x_i is even (x₁, . . . , x_n) 7→ Pn

i=1 x_i is odd

ε

ε

1 β

δ,x|even x

ε β 0

δ,x|odd x unfoldeo(1)

unfoldeo(1) unfoldeo(0)

unfoldeo(0) ε

δ,x|^{even x} δ,x|odd x

ε

unfoldeo(1) 1

β

1 β

0 β

Since h : A → Beh(Z,2) with h(1) = f and h(0) = g is Acc(Z)-homomorphic, h = unfold^eo.

Hence (A,1) realizes f and (A,0) realizes g.

Given a constructive signature CΣ = (S, BS, BF, C) and a destructive signature DΣ = (S, BS⁰, BF⁰, D), Ψ = (CΣ, DΣ) is called a bisignature.

Let Σ = CΣ ∪ DΣ. A set

E = {dc(x₁, . . . , x_nc) = t_d,c | c : e₁ × · · · ×e_nc → s ∈ C, d : s → e ∈ D}

of Σ-equations is a system of recursive Ψ-equations if the following conditions hold true:

• For all d ∈ D and c ∈ C, freeVars(t_d,c) ⊆ {x₁, . . . , x_nc}.

• C is the union of disjoint sets C₁ and C₂.

• For all d ∈ D, c ∈ C₁ and subterms du of t_d,c, u is a variable and t_d,c is a term without elements of C₂.

⇒ no nesting of destructors, but possible nestings of constructors of C₁

• For all d ∈ D, c ∈ C₂, subterms du of t_d,c and paths p of (the tree representation of) t_d,c, u consists of destructors and a variable and p contains at most one occurrence of an element of C₂.

⇒ no nesting of constructors of C₂, but possible nestings of destructors

Let E be a system of recursive Ψ-equations and A be a CΣ-algebra. An inductive solution of E in A is a Σ-algebra B with B|_CΣ = A that satisfies E.

(1) If C₂ is empty, then E has a unique inductive solution in every initial CΣ-algebra.

Let E be a system of recursive Ψ-equations and A be a DΣ-algebra. A coinductive solution of E in A is a Σ-algebra B with B|_DΣ = A that satisfies E.

(2) E has a unique coinductive solution in every final DΣ-algebra.

Moreover, T_CΣ ∈ Alg_DΣ, coT_DΣ ∈ Alg_CΣ and fold^coTDΣ = unfold^TCΣ.

T_CΣ unfold^TCΣ

coT_DΣ

T_CΣ(coTDΣ)

inc

≺ inc

=

= T_CΣ

id g

fold^coTDΣ coT_DΣ id unfold^TCΣ(coTDΣ) g

Example 4 Let

CΣ = ({list},∅,∅,{evens, odds, exchange, exchange⁰ : list → list}), Ψ = (CΣ, Stream(X)) and s ∈ V . The equations

head(evens(s)) = head(s), tail(evens(s)) = evens(tail(tail(s))), head(odds(s)) = head(tail(s)), tail(odds(s)) = odds(tail(tail(s))), head(exchange(s)) = head(tail(s)), tail(exchange(s)) = exchange⁰(s),

head(exchange⁰(s)) = head(s), tail(exchange⁰(s)) = exchange(tail(tail(s))) form a system E of recursive Ψ-equations.

evens(s) und odds(s) list the elements of s at even resp. odd positions.

exchange(s) exchanges the elements at even positions with those at odd positions.

(2) =⇒ E has a unique coinductive solution in the final Stream(X)-algebra.

Example 5

Let CS be a set of nonempty sets of constants, X = S CS, DΣ = ({reg},{2, X},

{max,∗ : 2 × 2 → 2} ∪ {_ ∈ C : X → 2 | C ∈ CS}, {δ : reg → reg^X, β : reg → 2}),

Ψ = (Reg(CS), DΣ), C ∈ CS and t, u ∈ V . The equations δ(eps) = λx.mt,

δ(mt) = λx.mt,

δ(C) = λx.ite(χ(C)(x), eps, mt) δ(par(t, u)) = λx.par(δ(t)(x), δ(u)(x)),

δ(seq(t, u)) = λx.ite(β(t), par(seq(δ(t)(x), u), δ(u)(x)) seq(δ(t)(x), u)),

δ(iter(t)) = λx.seq(δ(t)(x), iter(t)), β(eps) = 1,

β(mt) = 0, β(C) = 0,

β(par(t, u)) = max{β(t), β(u)}, β(seq(t, u)) = β(t)∗ β(u),

β(iter(t)) = 1.

form the system BRE of recursive Ψ-equations.

(1) =⇒ BRE has a unique inductive solution A in the initial Reg(CS)-algebra T_Reg(CS). Bro(CS) =_def A|_Acc(X) is called the Brzozowski automaton.

(2) =⇒ BRE has a unique coinductive solution B in the final Acc(X))-algebra Pow(X), which is defined as follows:

For all L ⊆ X^∗ and x ∈ X,

Pow(X)_state = P(X^∗),

δ^Pow(X)(L)(x) = {w ∈ X^∗ | xw ∈ L}, β^Pow(X)(L) =

( 0 falls ∈ L, 1 sonst.

Lang(X) = B|_Reg(CS) is defined as follows:

For all L, L⁰ ⊆ X^∗ and C ∈ CS,

eps^Lang(X) = {}, mt^Lang(X) = ∅,

C^Lang(X) = C, par^Lang(X)(L, L⁰) = L ∪ L⁰,

seq^Lang(X)(L, L⁰) = L · L⁰, iter^Lang(X)(L) = L^∗. (2) =⇒ fold^Lang(X) = unfold^Bro(CS) : T_Reg(CS) → P(X^∗)

=⇒ For all t ∈ T_Reg(CS), (Bro(CS), t) realizes the characteristic function of the language fold^Lang(X)(t) of t.

Bro(CS) can be optimized toNorm(CS)by simplifying its states with respect to semiring axioms between each two transition steps:

For all t ∈ T_Reg(CS), δ^Norm(CS)(t) =_def reduce◦ δ^Bro(CS)(t). o Let Ψ = (CΣ, DΣ) be a bisignature, CΣ = (S, BS, BF, C), DΣ = (S, BS⁰, BF⁰, D), A be a (CΣ ∪ DΣ)-algebra and ∼ be an S-sorted relation on A.

The C-equivalence closure ∼_C of ∼ is the least S-sorted equivalence relation on A that contains ∼ and satisfies the following condition: For all c : e → s ∈ C and a, b ∈ A_e,

a ∼_C b implies c^A(a) ∼_C c^A(b).

∼ is a DΣ-congruence up to C if for all d : s → e ∈ D and a, b ∈ A_s, a ∼ b implies d^A(a) ∼_C d^A(b).

A|_DΣ is final in Alg_DΣ,

∼ is a DΣ-congruence up to C,

there is a system of recursive Ψ-equations







=⇒ ∼_C is a DΣ-congruence. (3)

Example 6

Let Ψ be as in Example 5 and V = {x, y, z},

∼= {(g^∗(seq(x, par(y, z))), g^∗(par(seq(x, y), seq(x, z))) | g : T_Reg(CS)(V) → Pow(X)}

is an Acc(X)-congruence up to C.

=⇒ Since Pow(X) is final in Alg_Acc(X), (3) implies that ∼_C is Acc(X)-congruence.

=⇒ Since Pow(X) satisfies the coinduction principle, ∼ ⊆ ∆_Pow(X) and thus Pow(X) |= seq(x, par(y, z)) = par(seq(x, y), seq(x, z)).

o

Given a bisignature Ψ, we have seen that a system E of recursive Ψ-equations defines

• destructors on constructors inductively or

• constructors on destructors coinductively.

Similarly,

• the rules of a structural operational semantics (SOS) or a transition system specification

• or a distributive law λ : T D → DT of an endofunctor T over an endofunctor D provide both

• an inductive definition of a semantics (destructors; D) of the syntax (constructors;

T) of some language and

• a coinductive definition of the constructors on the language’s behavioral model, given by the destructors.

Can λ be derived from Ψ such that (CΣ ∪ DΣ)-algebras satisfying E correspond to λ- bialgebras?

With regard to their domain and range types, functions that come as inductive or coin- ductive solutions of systems of recursive Ψ-equations are destructors or constructors, respectively.

Recursion schemas that define functions with more general domain or range types have been studied mainly in category-theoretical settings like distributive laws or adjunctions.

For instance, in Ralf Hinze, Adjoint Folds and Unfolds, functions are defined as adjoint (co)extensions of folds or unfolds.

We think that most examples investigated in category-theoretical settings can be pre- sented as systems of recursiveΨ-equations. Maybe, in some cases, the syntactic conditions given here must be weakened, but in many cases, they will already be weak enough – due to our powerful term language that involves polynomial as well as power and collection types.

Here are some modeling formalisms where coinductive definability has already been stud- ied in detail:

• basic process algebra

1 Rutten, Processes as Terms: Non-well-founded Models for Bisimulation

• stream expressions and infinite sequences

1 Rutten, A Coinductive Calculus of Streams

• tree expressions and infinite trees

1 Silva, Rutten, A Coinductive Calculus of Binary Trees

• arithmetic expressions and valuations, CCS and transition trees 1 Hutton, Fold and Unfold for Program Semantics

• stream function expressions and causal stream functions

1 Hansen, Rutten, Symbolic Synthesis of Mealy Machines from Arithmetic Bitstream Functions

Let Σ = (S, BS, BF, F) be a constructive signature and V be an S-sorted set.

An S-sorted function

E : V → T_Σ(V )

with img(E) ∩ V = ∅ is called a system of iterative Σ-equations.

Let A be a Σ-algebra and A^V be the set of S-sorted functions from V to A.

g ∈ A^V solves E in A if g^∗ ◦E = g.

Iterative equations are uniquely solvable in the following tree model:

CT_Σ denotes the greatest FT(S, BS)-sorted set of prefix closed partial functions t : N^∗ (→ F +{word, bag, set}+ ∪BS

such that

• for all s ∈ S and t ∈ CT_Σ,s there are n > 0 and e₁, . . . , e_n ∈ FT(S, BS) with t() : e₁ × · · · × e_n → s ∈ F, def (t) ∩ N = [n] and λw.t(iw) ∈ CT_Σ,ei for all 1 ≤ i ≤ n,