Fast Iterative Arrays with Restricted Inter-Cell Communication: - - PowerPoint PPT Presentation

Fast Iterative Arrays with Restricted Inter-Cell Communication: Computational Capacity

Martin Kutrib Andreas Malcher

Institut f¨ ur Informatik, Universit¨ at Giessen Institut f¨ ur Informatik, Johann Wolfgang Goethe-Universit¨ at Frankfurt

Overview

➜ Language Recognition and Restricted Inter-Cell

Communication

➜ Iterative Arrays versus Cellular Automata ➜ Dimension and Bit Hierarchies

Overview

➜ Language Recognition and Restricted Inter-Cell

Communication

➜ Iterative Arrays versus Cellular Automata ➜ Dimension and Bit Hierarchies

Overview

➜ Language Recognition and Restricted Inter-Cell

Communication

➜ Iterative Arrays versus Cellular Automata ➜ Dimension and Bit Hierarchies

Two-way cellular automata with k-bit restricted inter-cell communication (CAk):

· · · # a1 a2 a3 an #

Local transition function δ : S × ({0, 1}k)2 → S Bit functions b1, b2 : S → {0, 1}k

One-way cellular automata with k-bit restricted inter-cell communication (OCAk):

· · · a1 a2 a3 an #

Local transition function δ : S × {0, 1}k → S Bit functions b1 : S → {0, 1}k

Language Recognition Loosely speaking:

➜ An input word is accepted, if the leftmost cell enters an

accepting state during its course of computation.

Language Recognition Loosely speaking:

➜ An input word is accepted, if the leftmost cell enters an

accepting state during its course of computation.

➜ For a mapping t : N → N, a formal language L is said to be of

time complexity t, if all words w in L are accepted at time step t(|w|).

Language Recognition Loosely speaking:

➜ An input word is accepted, if the leftmost cell enters an

accepting state during its course of computation.

➜ For a mapping t : N → N, a formal language L is said to be of

time complexity t, if all words w in L are accepted at time step t(|w|).

This “definition” is nonsense!

Example Let L ⊆ {a}n be an arbitrary language. t(n) = n if an / ∈ L and t(n) = n + 1 if an ∈ L

Example Let L ⊆ {a}n be an arbitrary language. t(n) = n if an / ∈ L and t(n) = n + 1 if an ∈ L

t n

# a a a a a a a a a a # #

• #

#

• +

# #

• +

# #

• +

# #

• +

# #

• +

# #

• +

# #

• +

# #

• +

# #

• +

# # + #

➜ The time complexity should be a function constructible by the

device itself.

➜ The time complexity should be a function constructible by the

device itself.

➜ E.g. the functions 2n, n2, nth prime number, and nth

Fibonacci number are constructible by one-bit CAs [Umeo, Kamikawa 2002,2003].

➜ The time complexity should be a function constructible by the

device itself.

➜ E.g. the functions 2n, n2, nth prime number, and nth

Fibonacci number are constructible by one-bit CAs [Umeo, Kamikawa 2002,2003].

➜ But

➜ The time complexity should be a function constructible by the

device itself.

➜ E.g. the functions 2n, n2, nth prime number, and nth

Fibonacci number are constructible by one-bit CAs [Umeo, Kamikawa 2002,2003].

➜ But ➜ In general, function constructor and language recognizer

cannot be superposed due to restricted communication bandwidth.

➜ The time complexity should be a function constructible by the

device itself.

➜ E.g. the functions 2n, n2, nth prime number, and nth

Fibonacci number are constructible by one-bit CAs [Umeo, Kamikawa 2002,2003].

➜ But ➜ In general, function constructor and language recognizer

cannot be superposed due to restricted communication bandwidth.

➜ Wide unexplored field of questions and answers.

Here: Real-time computations (i.e. t(n) = n)

Here: Real-time computations (i.e. t(n) = n)

Theorem

For all k ∈ N, there is a regular language which is not accepted by any real-time k-bit CA.

➜ L = {xvx | v ∈ {a}∗ and x ∈ {a0, . . . , a22k}}

Here: Real-time computations (i.e. t(n) = n)

Theorem

For all k ∈ N, there is a regular language which is not accepted by any real-time k-bit CA.

➜ L = {xvx | v ∈ {a}∗ and x ∈ {a0, . . . , a22k}}

Theorem

For all k ∈ N, Lrt(CAk) ⊂ Lrt(CAk+1).

Iterative Arrays versus Cellular Automata

Iterative array with k-bit restricted inter-cell communication (IAk):

s0 s0 s0 s0 s0 a1a2a3 · · · an#

Local transition functions δ : S × ({0, 1}k)2 → S δ0 : S × (A ∪ {#}) × {0, 1}k → S Bit functions b1, b2 : S → {0, 1}k

Counting arguments Let L ⊆ A∗ be a language and l ∈ N be a constant.

Counting arguments Let L ⊆ A∗ be a language and l ∈ N be a constant.

➜ Two words w ∈ A∗ and w′ ∈ A∗ are l-right-equivalent with

respect to L if wy ∈ L ⇐ ⇒ w′y ∈ L, for all y ∈ A≤l

Counting arguments Let L ⊆ A∗ be a language and l ∈ N be a constant.

➜ Two words w ∈ A∗ and w′ ∈ A∗ are l-right-equivalent with

respect to L if wy ∈ L ⇐ ⇒ w′y ∈ L, for all y ∈ A≤l

➜ Two words w ∈ A≤l and w′ ∈ A≤l are l-left-equivalent with

respect to L if wy ∈ L ⇐ ⇒ w′y ∈ L, for all y ∈ A∗

Lemma

Let d, k ∈ N be constants.

• 1. If L ∈ Lrt(IAd

k), then there exists a constant p ∈ N

such that Nr(l, L) ≤ p(l+1)d for all l ∈ N.

Lemma

Let d, k ∈ N be constants.

• 1. If L ∈ Lrt(IAd

k), then there exists a constant p ∈ N

such that Nr(l, L) ≤ p(l+1)d and

• 2. if L ∈ Llt(IAd

k), then there exists a constant p ∈ N

such that Nℓ(l, L) ≤ p · 2d·k·l for all l ∈ N.

Theorem

For any constants k ∈ N, there is a language belonging to the difference Lrt(OCA1) \ Llt(IAk).

Theorem

For any constants k ∈ N, there is a language belonging to the difference Lrt(OCA1) \ Llt(IAk).

➜ Lk = {u1 · · · umex | m ∈ N, ui ∈ {a0, . . . , a2k−1}, 1 ≤ i ≤

m, and x = (u1 · · · um)2k}

➜ Induced equivalence classes: Nℓ(m, Lk+1) > p · 2d·k·m ➜ Distinguished equivalence classes: Nℓ(m, Lk+1) ≤ p · 2d·k·m

Theorem

For any constants k ∈ N, there is a language belonging to the difference Lrt(OCA1) \ Llt(IAk).

➜ Lk = {u1 · · · umex | m ∈ N, ui ∈ {a0, . . . , a2k−1}, 1 ≤ i ≤

m, and x = (u1 · · · um)2k}

➜ Induced equivalence classes: Nℓ(m, Lk+1) > p · 2d·k·m ➜ Distinguished equivalence classes: Nℓ(m, Lk+1) ≤ p · 2d·k·m

Theorem

For any constants k ∈ N, there is a language belonging to the difference Lrt(OCA1) \ Llt(IAk).

➜ Lk = {u1 · · · umex | m ∈ N, ui ∈ {a0, . . . , a2k−1}, 1 ≤ i ≤

m, and x = (u1 · · · um)2k}

➜ Induced equivalence classes: Nℓ(m, Lk+1) > p · 2d·k·m ➜ Distinguished equivalence classes: Nℓ(m, Lk+1) ≤ p · 2d·k·m

Llt(NCA) = Llt(NIA) Lrt(NCA) = Lrt(NIA) Llt(CA) = Llt(IA) Lrt(CA) Lrt(OCA) Lrt(IA) REG

Llt(NCA) = Llt(NIA) Lrt(NCA) = Lrt(NIA) Llt(CA) = Llt(IA) Lrt(CA) Lrt(OCA) Lrt(IA) REG Llt(NCAk) Llt(NIAk) Lrt(NCAk) Lrt(NIAk) Llt(CAk) Lrt(CAk) Llt(IAk) Lrt(OCAk) Lrt(IAk) REG

Dimension and Bit Hierarchies s0 s0 s0 s0 s0 s0 s0 s0 s0 s0 s0 s0 s0 s0 s0 s0 s0 s0 s0 s0 s0 s0 s0 s0 s0 a1a2a3 · · · an#

Theorem

For any constants d, k ∈ N, there is a language over a two- letter alphabet belonging to the difference Lrt(IAd+1

1

) \ Lrt(IAd

k).

✩ ✩ ➣ ✩ ✩ ✩ ✩ ✩ ➣ ✩ ➣

Theorem

For any constants d, k ∈ N, there is a language over a two- letter alphabet belonging to the difference Lrt(IAd+1

1

) \ Lrt(IAd

k). ➜ X1 = {a, b}+ and Xi+1 = ✩(Xi✩)+, for i ≥ 1. ➜ M(d) = {u➣ex1✩ · · · ✩exd✩e2x✩v | u ∈ Xd, xi ∈ N, 1 ≤ i ≤ d,

and x = x1 + · · · + xd and u[x1][x2] · · · [xd] is defined and v = u[x1][x2] · · · [xd]}

➜ Finally, the language L(d) = h(M(d)) is given as

homomorphic image of M(d), where h : {a, b, e, ✩, ➣}∗ → {a, b}∗ is defined as follows: h(a) = ba, h(b) = bb, h(e) = b, h(✩) = ab, h(➣) = aa.

Theorem

For any constants d, k ∈ N, there is a language over a two- letter alphabet belonging to the difference Lrt(IAd+1

1

) \ Lrt(IAd

k). ➜ X1 = {a, b}+ and Xi+1 = ✩(Xi✩)+, for i ≥ 1. ➜ M(d) = {u➣ex1✩ · · · ✩exd✩e2x✩v | u ∈ Xd, xi ∈ N, 1 ≤ i ≤ d,

and x = x1 + · · · + xd and u[x1][x2] · · · [xd] is defined and v = u[x1][x2] · · · [xd]}

➜ Finally, the language L(d) = h(M(d)) is given as

homomorphic image of M(d), where h : {a, b, e, ✩, ➣}∗ → {a, b}∗ is defined as follows: h(a) = ba, h(b) = bb, h(e) = b, h(✩) = ab, h(➣) = aa.

Theorem

For any constants d, k ∈ N, there is a language over a two- letter alphabet belonging to the difference Lrt(IAd+1

1

) \ Lrt(IAd

k). ➜ X1 = {a, b}+ and Xi+1 = ✩(Xi✩)+, for i ≥ 1. ➜ M(d) = {u➣ex1✩ · · · ✩exd✩e2x✩v | u ∈ Xd, xi ∈ N, 1 ≤ i ≤ d,

and x = x1 + · · · + xd and u[x1][x2] · · · [xd] is defined and v = u[x1][x2] · · · [xd]}

➜ Finally, the language L(d) = h(M(d)) is given as

homomorphic image of M(d), where h : {a, b, e, ✩, ➣}∗ → {a, b}∗ is defined as follows: h(a) = ba, h(b) = bb, h(e) = b, h(✩) = ab, h(➣) = aa.

Theorem

For any constants d, k ∈ N there is a language belonging to the difference Lrt(IAd

k+1) \ Lrt(IAd k).

✩ ✩ ✩

Theorem

For any constants d, k ∈ N there is a language belonging to the difference Lrt(IAd

k+1) \ Lrt(IAd k). ➜ Ad,k = {a0, . . . , a2d·k−2} ➜ L(d, k) = {u1 · · · um✩ex✩e2x✩v | m, x ∈ N and x ≤ m and

ui ∈ Ad,k, 1 ≤ i ≤ m, and v = ux}

Theorem

For any constants d, k ∈ N there is a language belonging to the difference Lrt(IAd

k+1) \ Lrt(IAd k). ➜ Ad,k = {a0, . . . , a2d·k−2} ➜ L(d, k) = {u1 · · · um✩ex✩e2x✩v | m, x ∈ N and x ≤ m and

ui ∈ Ad,k, 1 ≤ i ≤ m, and v = ux}

· · · · · · · · · ⊂ ⊂ ⊂ Lrt(IAk

1) ⊂ Lrt(IAk 2) ⊂ · · · ⊂ Lrt(IAk k) ⊂ · · ·

⊂ ⊂ ⊂ · · · · · · · · · ⊂ ⊂ ⊂ Lrt(IA2

1) ⊂ Lrt(IA2 2) ⊂ · · · ⊂ Lrt(IA2 k) ⊂ · · ·

⊂ ⊂ ⊂ Lrt(IA1

1) ⊂ Lrt(IA1 2) ⊂ · · · ⊂ Lrt(IA1 k) ⊂ · · ·