Theory of Computation
Program Snapshot Sequences, Computations,
Partially Computable & Computable Functions
Vladimir Kulyukin
www.vkedco.blogspot.com
Definition: A State of Program P
• A state of a program P is a set of equations of the form V = m, where V is a variable and m is a number
• The set must have exactly one equation for every variable that occurs in P
• Corollary 1: The state may have equations for variables that do not occur in P (this is very useful for passing meta information)
• Corollary 2: It is irrelevant whether a state can or cannot be achieved by P
A Program is a Finite Sequence of Primitive L Instructions
1. Primitive L Instruction
2. Primitive L Instruction
3. Primitive L Instruction
4. Primitive L Instruction
5. Primitive L Instruction
…
n. Primitive L Instruction
Formal Definition of Program
Program Snapshots
• A program P is assumed to have n ≥ 0 instructions• A program snapshot is a pair (i, σ) where i is the
number of the instruction to be executed and σ is a state of P
• The values of i are in [1, n+1]
Initial Snapshot
snapshot. initial theis )(1,
.in other any for ,0 .2
;0,,..., 1.
:equations of sets twoofconsist
Let numbers.given be ,...,
let and in program a be Let
11
1
Then
PVV
YrXrX
mrr
LP
mm
m
Successor Snapshots
● Suppose there is a program P whose current state is captured in a snapshot S
● We would like to know what will happen next in P ● Technically speaking, we have to compute the next
instantaneous description, i.e., the successor snapshot of the current snapshot
● We would also like to proceed in a deterministic fashion, i.e., there must be one and only one successor snapshot
Successor Snapshot Assumption
● We assume that every program P, for which we are interested in computing successor snapshots (i.e., emulating), is compiled down to four types of primitive instructions, i.e., all of the macros have been expanded appropriately
● Recall that the four primitive instructions are: 1) V ← V + 1;
2) V ← V – 1;
3) V ← V;
4) IF V != 0 GOTO L
Successor Snapshots
● The computation of the successor shot depends on two things:
the current snapshot the instruction that is about to be executed
● We will define the successor snapshot function with four cases (one for each of the four primitive instruction types)
Successor Snapshot
snapshot.successor theis ),(
snapshot;current theis ,
where),,()),(successor(
j
i
ji
Successor Snapshot: Case 1: V ← V+1
.1by
equation thereplacingby
from obtained is and 1Then
.equation thecontains and
1 is ofn instructio The th
mV
mV
ij
mV
VVPi
Successor Snapshot: Case 2: V ← V-1
. ,0 if ;0 if 1by
equation thereplacingby
from obtained is and 1Then
.equation thecontains and
1 is ofn instructio The th
mmmV
mV
ij
mV
VVPi
Successor Snapshot: Case 4: Conditional Dispatch
.1Otherwise, . labeled is of
n instructioth thesuch that number least theis
, labeled ofn instructioan is thereif Then,
.0 where,equation thecontains .2
.1Then .0equation thecontains .1
. GOTO 0 IF is ofn instructio The th
njLP
jj
LP
mmV
ijV
LVPi
Example
1. [A] IF X != 0 GOTO B2. Z ← Z + 13. IF Z != 0 GOTO E4. [B] X ← X – 15. Y ← Y + 16. Z ← Z + 17. IF Z != 0 GOTO A
Suppose the current snapshot is (i, σ), where σ = {X = 4, Y = 0, Z = 0}. If i = 1, the successor snapshot is (4, σ).If i = 2, the successor snapshot is (3,τ), where τ = {X = 4, Y = 0, Z = 1}.If i = 4, the successor snapshot is (5,τ), where τ = {X = 3, Y = 0, Z = 0}.If i = 5, the successor snapshot is (6,τ), where τ = {X = 4, Y = 1, Z = 0}.
Formal Definition of Computation
terminal.is and 1,...,2,1
, ofsuccessor theis such that
of ,...,, snapshots of sequence a
is program a ofn computatioA
1
21
k
ii
k
ski
ss
Psss
P
Remarks on Computation
● Computation is finite by definition● Given a program P and a snapshot sequence S, it is possible
to determine whether S constitutes a computation of P on a given input
● The finiteness requirement may draw some disagreement, because one can think of meaningful programs that deliberately go into infinite loops (e.g., robot control loops of the type sense – act – sense)
What does P compute?
● Suppose there is a program P● Suppose that we give some inputs for P● If we start running/simulating P on the inputs, there are two
cases:● There is a computation, i.e., a sequence of snapshots s1 , s2 ,
… , sk where sk is a terminal snapshot● There is no computation, i.e., the sequence of snapshots is
infinite
What does P compute?
.
equations thecontains snapshot initial theand
snapshot terminalain of value thedenotes
snapshot. terminalain of value thecompute tosaid is
2211
1
21
mm
k
m(m)P
r , ... X r , X r X
ss
Y),...,r,r(rΨ
YP
Example 2: What does P compute?
Y ← X1Z1 ← X2
[A1] IF Z1 != 0 GOTO B1GOTO E1
[B1] Z1 ← Z1 – 1Y ← Y + 1GOTO A1
Number of Program Inputs
. :2 Case
. :1 Case
? if ),...,( isWhat
. variables of program a be Let
1)(
nm
nm
nmrr
nP
mm
P
Case 1: m < n
● If the remaining inputs are not specified in the input, all of them default to 0
● Example: If a program computes a function of 5 variables and only X1, X2, and X3 are specified in the initial snapshot, the values of X4 and X5 are assumed to be 0
● In practical terms, X4 = 0 and X5 = 0 are added to the initial snapshot
Case 2: m > n
● If more inputs are specified than necessary, the extra inputs are ignored
● Example: If a program computes a function of 2 variables but X1, X2, X3, and X4 have equations in the initial snapshot, the values for X3 and X4 are ignored
Example
1321)3(
121)2(
11)1(
)1(1
),,( .3
),( .2
)( .1
: trueare statements following Then the
.)( s,other wordIn . to
assigns that program a is Suppose
rrrr
rrr
rr
xxYr
P
P
P
P
P
Example
.),,(
.0)(
: trueare statements following Then the
.),(
such that program a is that Suppose
21321)3(
11)1(
)2(
rrrrr
rr
yxyx
P
P
P
P
Example 1: Comments on fact.c
● We can say that f(n) is computed by the C program in fact.c● We can also say that the C program in fact.c computes f(n)● The two statements are semantically equivalent:
programs compute functions functions are computed by programs
Definition: Partially Computable Functions
A partial function g is said to be partially computable
if it is computed by some L program P.
Definition: Partially Computable Functions
mm
Pm
mm
Pmm
rrrrrrg
LP
rrrrrrgrrrP
iffcomputablepartially g
,...,, iff ,...,, .2
program; an is where
,,...,,,...,,,...,, .1
:function a is
21)(
21
21)(
2121
L Program for g Y ← X1
Z ← X2
[A] IF Z != 0 GOTO B
GOTO E
[B] IF Y != 0 GOTO C
GOTO B
[C] Y ← Y – 1
Z ← Z – 1
GOTO A
Example
● g is a partially computable function because there exists a L program, defined on the previous slide, that computes it
● For any two natural numbers x and y, g(x, y) is the same as the value of Y and the program
terminates; g(x, y) is undefined and the program does not termi-
nate, in which case the value of Y is undefined as well
Definition: Computable Functions
● g(r1 , r2 , …, rm) is total if it is defined for all r1 , r2 , …, rm in its domain
● g is computable if it is both partially computable and total● Example: g(x, y) = x + y● Remember the following equivalents:
partially computable = partially recursive computable = recursive.
Partially Computable vs. Computable Functions
● f(x) = x● f(x, y) = x + y● f(x, y) = x * y● f(x, y) = x – y● All are partially computable on natural numbers● The first three are computable on natural numbers
Function Macros● Let f(x) be a partially computable function● Let P
f be a program that computes f
● What assumptions we can make about Pf?
Pf has the following variables: Y, X1, …. , Xn, Z1, …, Zk
Pf has the following labels: A1, …, Aj
The last assumption is true, because we can rename the labels to be only A labels
For every dispatch instruction IF Vi != 0 GOTO Aj, Aj exists. No loss of gen-erality here, because we can do a simple syntactic check to verify this condi-tion and refuse to compile a program if it does not meet this condition
Logical Steps of Macro Expansion
● A macro is expanded in the context of a larger program P
L● When the macro is expanded, we need to ensure that
its instructions are not in conflict with the instructions that come before it (pre-context) and the instructions that come after it (post-context)
Context-Sensitive Macro Expansion
L Instruction 1
L Instruction 2
L Instruction 3
L Instruction r
W ← f(V1, …, Vn)
…
…
Pre-Context
Post-ContextFunction Macro
to Expand
PL
Variable & Label Replacements Pf
● Suppose some function f is computed by a program Pf
● Suppose PL is a larger program that has n input and k
local variables and j labels into which f is expanded● We can always find a natural number m greater than all
other subscripts used in PL (variable & label subscripts)
Variable & Label Replacements in Pf
● When m is found, we replace Y references in Pf with Zm
● All input variable references are replaced according to the following mapping (replacement is denoted by →): X1 → Zm+1, X2 → Zm+2, …, Xn → Zm+n
● All local variable references are replaced as follows: Z1 → Zm+n+1, Z2 → Zm+n+2, …, Zk → Zm+n+k
● The end label E1 (or E) is replaced with Em● All labels are replaced as follows:
A1 → Am+1, A2 → Am+2, … , Aj → Am+j
Variable & Label Replacements Pf
jjmm
m
kknmnm
nnmm
m
jmmmknmnmnmmmfm
fm
AAAA
EE
ZZZZ
XXZZ
Z
AAEZZZZZPQ
PQ
,..., replace ,..., .5
; replaces .4
;,..., replace ,..., .3
;,..., replace ,..., .2
Y; replaces .1
where),,...,,,...,,,...,,(
Formally, specified. as made
tsreplacemen theall with code source s' denote Let
11
1
11
11
1,11
Macro Expansion
mm
m
knm
nm
nnm
m
m
n
ZWE
Q
Z
Z
VZ
VZ
Z
VVfW
][
0
...
0
...
0
:into expanded is ,..., macro theThus,
1
11
1
Assign V values into new input variables
Assign 0's to new localvariables
Modified Code of Pf
Example
01. Z1 ← Z1 + 102. Z1 ← Z1 + 103. Z2 ← Z2 + 104. Z2 ← Z2 + 105. Z3 ← Z1 * Z206. Y ← Z3
PL
01. Z1 ← 002. Z2 ← V203. [A1] IF Z2 != 0 GOTO A204. GOTO E105. [A2] Z2 ← Z2 – 106. Z1 ← V1 + Y07. Y ← Z108. GOTO A1
Pf : Macro V1 * V2
Line 05 is of the formW ← f(V1, V2), where
W = Z3, V1 = Z1, V2 = Z2and f is Multiplication
Example
• PL
has no input variables (n = 0) and no
labels (j = 0)• P
L has 3 local variables so (k = 3)
• Let us set m to max(n, j, k) + 1 = 4
Example• P
f has the following replacements (→ denotes “replacement”)
• Recall that m = 4 and n = 2 (because Pf has two input variables V1 & V2); j = 2, because P
f has
two labels: A1 & A2; and k = 2, because Pf has two local variables: Z1 & Z2
• Y Z4→• V1 Z5 (5 = m + 1 = 4) (V1 is the 1→ st input variable)• V2 Z6 (6 = m + 2 + 6) (V2 is the 2→ nd input variable)• Z1 Z7 (7 = m + n + 1 = 4 + 2 + 1)→• Z2 Z8 (8 = m + n + 2 = 4 + 2 + 2)→• E1 E4→• A1 A5 (5 = m + 1 = 4 + 1)→• A2 A6 (6 = m + 2 = 4 + 2)→
Example: Assigning V Values to New Input Variables & 0's to New Local Variables
Replacements
Z4 ← 0 // Z4 is the new YZ5 ← Z1 // 1st parameter V1Z6 ← Z2 // 2nd parameter V2Z7 ← 0 // Z7 replaces Z1Z8 ← 0 // Z8 replaces Z2
Assignment of Variables in Macro Expansion Y → Z4V1 → Z5 V2 → Z6 Z1 → Z7 Z2 → Z8 E1 → E4A1 → A5 A2 → A6
Example: Modified Pf
Replacements
01. Z7 ← 002. Z8 ← Z503. [A5] IF Z8 != 0 GOTO A604. GOTO E405. [A6] Z8 ← Z8 – 106. Z7 ← Z5 + Z407. Z4 ← Z708. GOTO A5
Modified Pf after replacements are made:
Y → Z4V1 → Z5 V2 → Z6 Z1 → Z7 Z2 → Z8 E1 → E4A1 → A5 A2 → A6
01. Z1 Z1 + 1←02. Z1 Z1 + 1←03. Z1 Z2 + 1←04. Z2 Z2 + 1←05. Z4 ← 0 // Z4 is the new Y06. Z5 ← Z1 // 1st parameter V107. Z6 ← Z2 // 2nd parameter V208. Z7 ← 0 // Z7 replaces Z109. Z8 ← 0 // Z8 replaces Z2 10. Z7 ← 011. Z8 ← Z612. [A5] IF Z8 != 0 GOTO A613. GOTO E4
Example: Modified PL
14. [A6] Z8 ← Z8 – 115. Z7 ← Z5 + Z416. Z4 ← Z717. GOTO A518. [E4] Z3 ← Z419. Y Z3 ←
Black lines are lines from original Pl; red lines are the macro expansion of P
f
Recursive Macro Expansion
• If the macro itself contains other macros, they can be recursively expanded in the same fashion
• When all the the expansions are done, the program contains only primitive instructions
• Since this expansion is algorithmic (the macros expands in the same way modulo variables and labels), we can assume that all macros contain only primitive instructions
The Point of Functional Macros
● The use of macros makes it easier for us to reason about computational properties of functions as mathematical objects
● If challenged by a mathematician on some function, we can write short, understandable programs to illustrate specific computational properties of that function
● If challenged by an computer scientist, we can expand the short programs into much longer programs written in the L primitive instructions
● Any computer scientist will readily acknowledge the realistic assumptions behind the primitive instructions of L