Journal of Formalized Mathematics
Volume 5, 1993
University of Bialystok
Copyright (c) 1993 Association of Mizar Users

### Development of Terminology for \bf SCM

by
Grzegorz Bancerek, and
Piotr Rudnicki

Received October 8, 1993

MML identifier: SCM_1
[ Mizar article, MML identifier index ]

environ

vocabulary AMI_3, INT_1, FINSEQ_1, AMI_1, AMI_2, FUNCT_1, RELAT_1, ARYTM_1,
NAT_1, MCART_1, SCM_1;
notation TARSKI, XBOOLE_0, SUBSET_1, NUMBERS, XCMPLX_0, XREAL_0, NAT_1, INT_1,
MCART_1, RELAT_1, FUNCT_1, FUNCT_2, FINSEQ_1, STRUCT_0, AMI_1, AMI_2,
AMI_3;
constructors NAT_1, AMI_2, AMI_3, MEMBERED, XBOOLE_0;
clusters AMI_1, AMI_3, INT_1, XBOOLE_0, RELSET_1, FINSEQ_1, FRAENKEL, XREAL_0,
MEMBERED, ZFMISC_1, NUMBERS, ORDINAL2;
requirements NUMERALS, REAL, SUBSET, BOOLE, ARITHM;

begin

definition
let i be Integer;
redefine func <*i*> -> FinSequence of INT;
end;

theorem :: SCM_1:1
for s being State of SCM
holds IC s = s.0 & CurInstr s = s.(s.0);

theorem :: SCM_1:2
for s being State of SCM, k being Nat
holds CurInstr (Computation s).k = s.(IC (Computation s).k) &
CurInstr (Computation s).k = s.((Computation s).k.0);

theorem :: SCM_1:3
for s being State of SCM
st ex k being Nat st s.(IC (Computation s).k) = halt SCM
holds s is halting;

theorem :: SCM_1:4
for s being State of SCM, k being Nat
st s.(IC (Computation s).k) = halt SCM
holds (Result s) = (Computation s).k;

canceled 2;

theorem :: SCM_1:7
for n, m being Nat holds
IC SCM <> il.n & IC SCM <> dl.n & il.n <> dl.m;

definition
let I be FinSequence of the Instructions of SCM,
D be FinSequence of INT,
il, ps, ds be Nat;
mode State-consisting of il, ps, ds, I, D -> State of SCM means
:: SCM_1:def 1
IC it = il.il &
(for k being Nat st k < len I holds it.il.(ps+k) = I.(k+1)) &
(for k being Nat st k < len D holds it.dl.(ds+k) = D.(k+1));
end;

theorem :: SCM_1:8
for x1, x2, x3, x4 being set, p being FinSequence
st p = <*x1*>^<*x2*>^<*x3*>^<*x4*>
holds len p = 4 & p.1 = x1 & p.2 = x2 & p.3 = x3 & p.4 = x4;

theorem :: SCM_1:9
for x1, x2, x3, x4, x5 being set, p being FinSequence
st p = <*x1*>^<*x2*>^<*x3*>^<*x4*>^<*x5*>
holds len p = 5 & p.1 = x1 & p.2 = x2 & p.3 = x3 & p.4 = x4 & p.5 = x5;

theorem :: SCM_1:10
for x1, x2, x3, x4, x5, x6 being set, p being FinSequence
st p = <*x1*>^<*x2*>^<*x3*>^<*x4*>^<*x5*>^<*x6*>
holds len p = 6 & p.1 = x1 & p.2 = x2 & p.3 = x3 & p.4 = x4 & p.5 = x5 &
p.6 = x6;

theorem :: SCM_1:11
for x1, x2, x3, x4, x5, x6, x7 being set, p being FinSequence
st p = <*x1*>^<*x2*>^<*x3*>^<*x4*>^<*x5*>^<*x6*>^<*x7*>
holds len p = 7 & p.1 = x1 & p.2 = x2 & p.3 = x3 & p.4 = x4 & p.5 = x5 &
p.6 = x6 & p.7 = x7;
theorem :: SCM_1:12
for x1,x2,x3,x4, x5, x6, x7, x8 being set, p being FinSequence
st p = <*x1*>^<*x2*>^<*x3*>^<*x4*>^<*x5*>^<*x6*>^<*x7*>^<*x8*>
holds len p = 8 & p.1 = x1 & p.2 = x2 & p.3 = x3 & p.4 = x4 & p.5 = x5 &
p.6 = x6 & p.7 = x7 & p.8 = x8;

theorem :: SCM_1:13
for x1,x2,x3,x4,x5,x6,x7, x8, x9 being set, p being FinSequence
st p = <*x1*>^<*x2*>^<*x3*>^<*x4*>^<*x5*>^<*x6*>^<*x7*>^<*x8*>^<*x9*>
holds len p = 9 & p.1 = x1 & p.2 = x2 & p.3 = x3 & p.4 = x4 & p.5 = x5 &
p.6 = x6 & p.7 = x7 & p.8 = x8 & p.9 = x9;

theorem :: SCM_1:14
for I1, I2, I3, I4, I5, I6, I7, I8, I9 being Instruction of SCM,
i1, i2, i3, i4 being Integer,
il being Nat,
s being State-consisting of il, 0, 0,
<*I1*>^<*I2*>^<*I3*>^<*I4*>^<*I5*>^<*I6*>^<*I7*>^<*I8*>^<*I9*>,
<*i1*>^<*i2*>^<*i3*>^<*i4*>
holds IC s = il.il &
s.il.0 = I1 & s.il.1 = I2 & s.il.2 = I3 & s.il.3 = I4 &
s.il.4 = I5 & s.il.5 = I6 & s.il.6 = I7 & s.il.7 = I8 & s.il.8 = I9 &
s.dl.0 = i1 & s.dl.1 = i2 & s.dl.2 = i3 & s.dl.3 = i4;

theorem :: SCM_1:15
for I1, I2 being Instruction of SCM,
i1, i2 being Integer,
il being Nat,
s being State-consisting of il, 0, 0, <*I1*>^<*I2*>, <*i1*>^<*i2*>
holds IC s = il.il &
s.il.0 = I1 & s.il.1 = I2 &
s.dl.0 = i1 & s.dl.1 = i2;

definition
let N be with_non-empty_elements set;
let S be halting IC-Ins-separated definite
(non empty non void AMI-Struct over N);
let s be State of S such that
s is halting;
func Complexity s -> Nat means
:: SCM_1:def 2
CurInstr((Computation s).it) = halt S &
for k being Nat st CurInstr((Computation s).k) = halt S holds it <= k;
synonym LifeSpan s;
end;

theorem :: SCM_1:16
for s being State of SCM, k being Nat
holds s.(IC (Computation s).k) <> halt SCM &
s.(IC (Computation s).(k+1)) = halt SCM
iff Complexity s = k+1 & s is halting;

theorem :: SCM_1:17
for s being State of SCM, k being Nat
st IC (Computation s).k <> IC (Computation s).(k+1) &
s.(IC (Computation s).(k+1)) = halt SCM
holds Complexity s = k+1;

theorem :: SCM_1:18
for k, n being Nat, s being State of SCM, a, b being Data-Location
st IC (Computation s).k = il.n & s.il.n = a := b
holds IC (Computation s).(k+1) = il.(n+1) &
(Computation s).(k+1).a = (Computation s).k.b &
for d being Data-Location st d <> a holds
(Computation s).(k+1).d = (Computation s).k.d;

theorem :: SCM_1:19
for k, n being Nat, s being State of SCM, a, b being Data-Location
st IC (Computation s).k = il.n & s.il.n = AddTo(a,b)
holds IC (Computation s).(k+1) = il.(n+1) &
(Computation s).(k+1).a = (Computation s).k.a+(Computation s).k.b &
for d being Data-Location st d <> a holds
(Computation s).(k+1).d = (Computation s).k.d;

theorem :: SCM_1:20
for k, n being Nat, s being State of SCM, a, b being Data-Location
st IC (Computation s).k = il.n & s.il.n = SubFrom(a,b)
holds IC (Computation s).(k+1) = il.(n+1) &
(Computation s).(k+1).a = (Computation s).k.a-(Computation s).k.b &
for d being Data-Location st d <> a holds
(Computation s).(k+1).d = (Computation s).k.d;

theorem :: SCM_1:21
for k, n being Nat, s being State of SCM, a, b being Data-Location
st IC (Computation s).k = il.n & s.il.n = MultBy(a,b)
holds IC (Computation s).(k+1) = il.(n+1) &
(Computation s).(k+1).a = (Computation s).k.a*(Computation s).k.b &
for d being Data-Location st d <> a holds
(Computation s).(k+1).d = (Computation s).k.d;

theorem :: SCM_1:22
for k, n being Nat, s being State of SCM, a, b being Data-Location
st IC (Computation s).k = il.n & s.il.n = Divide(a,b) & a<>b
holds IC (Computation s).(k+1) = il.(n+1) &
(Computation s).(k+1).a = (Computation s).k.a div (Computation s).k.b &
(Computation s).(k+1).b = (Computation s).k.a mod (Computation s).k.b &
for d being Data-Location st d <> a & d <> b holds
(Computation s).(k+1).d = (Computation s).k.d;

theorem :: SCM_1:23
for k, n being Nat, s being State of SCM,
il being Instruction-Location of SCM
st IC (Computation s).k = il.n & s.il.n = goto il
holds IC (Computation s).(k+1) = il &
for d being Data-Location holds
(Computation s).(k+1).d = (Computation s).k.d;

theorem :: SCM_1:24
for k, n being Nat, s being State of SCM, a being Data-Location,
il being Instruction-Location of SCM
st IC (Computation s).k = il.n & s.il.n = a =0_goto il
holds ((Computation s).k.a = 0 implies IC (Computation s).(k+1) = il) &
((Computation s).k.a <>0 implies IC (Computation s).(k+1) = il.(n+1)) &
for d being Data-Location holds
(Computation s).(k+1).d = (Computation s).k.d;

theorem :: SCM_1:25
for k, n being Nat, s being State of SCM, a being Data-Location,
il being Instruction-Location of SCM
st IC (Computation s).k = il.n & s.il.n = a >0_goto il
holds ((Computation s).k.a > 0 implies IC (Computation s).(k+1) = il) &
((Computation s).k.a <= 0 implies IC (Computation s).(k+1) = il.(n+1)) &
for d being Data-Location holds
(Computation s).(k+1).d = (Computation s).k.d;

theorem :: SCM_1:26
(halt SCM)1 = 0 &
(for a, b being Data-Location holds (a := b)1 = 1) &
(for a, b being Data-Location holds (AddTo(a,b))1 = 2) &
(for a, b being Data-Location holds (SubFrom(a,b))1 = 3) &
(for a, b being Data-Location holds (MultBy(a,b))1 = 4) &
(for a, b being Data-Location holds (Divide(a,b))1 = 5) &
(for i being Instruction-Location of SCM holds (goto i)1 = 6) &
(for a being Data-Location, i being Instruction-Location of SCM
holds (a =0_goto i)1 = 7) &
(for a being Data-Location, i being Instruction-Location of SCM
holds (a >0_goto i)1 = 8);

theorem :: SCM_1:27
for N being non empty with_non-empty_elements set,
S be IC-Ins-separated definite halting
(non empty non void AMI-Struct over N),
s being State of S, m being Nat
holds s is halting iff (Computation s).m is halting;

theorem :: SCM_1:28
for s1, s2 being State of SCM, k, c being Nat
st s2 = (Computation s1).k & Complexity s2 = c & s2 is halting & 0 < c
holds Complexity s1 = k+c;

theorem :: SCM_1:29
for s1, s2 being State of SCM, k being Nat
st s2 = (Computation s1).k & s2 is halting
holds Result s2 = Result s1;

theorem :: SCM_1:30
for I1, I2, I3, I4, I5, I6, I7, I8, I9 being Instruction of SCM,
i1, i2, i3, i4 being Integer,
il being Nat,
s being State of SCM
st IC s = il.il &
s.il.0 = I1 & s.il.1 = I2 & s.il.2 = I3 & s.il.3 = I4 &
s.il.4 = I5 & s.il.5 = I6 & s.il.6 = I7 & s.il.7 = I8 & s.il.8 = I9 &
s.dl.0 = i1 & s.dl.1 = i2 & s.dl.2 = i3 & s.dl.3 = i4
holds
s is State-consisting of il, 0, 0,
<*I1*>^<*I2*>^<*I3*>^<*I4*>^<*I5*>^<*I6*>^<*I7*>^<*I8*>^<*I9*>,
<*i1*>^<*i2*>^<*i3*>^<*i4*>;

::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
:: Empty program
::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

theorem :: SCM_1:31
for s being State-consisting of 0, 0, 0, <*halt SCM*>, <*>INT
holds s is halting & Complexity s = 0 & Result s = s;

::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
:: Assignment
::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

theorem :: SCM_1:32
for i1, i2 being Integer,
s being State-consisting of 0, 0, 0, <*dl.0 := dl.1*>^<*halt SCM*>,
<*i1*>^<*i2*>
holds s is halting &
Complexity s = 1 &
(Result s).dl.0 = i2 &
for d being Data-Location st d<>dl.0 holds (Result s).d = s.d;

::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
:: Adding two integers
::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

theorem :: SCM_1:33
for i1, i2 being Integer,
s being State-consisting of 0, 0, 0, <*AddTo(dl.0,dl.1)*>^<*halt SCM*>,
<*i1*>^<*i2*>
holds s is halting &
Complexity s = 1 &
(Result s).dl.0 = i1 + i2 &
for d being Data-Location st d<>dl.0 holds (Result s).d = s.d;

::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
:: Subtracting two integers
::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

theorem :: SCM_1:34
for i1, i2 being Integer,
s being State-consisting of 0, 0, 0, <*SubFrom(dl.0,dl.1)*>^<*halt SCM*>,
<*i1*>^<*i2*>
holds s is halting &
Complexity s = 1 &
(Result s).dl.0 = i1 - i2 &
for d being Data-Location st d<>dl.0 holds (Result s).d = s.d;

::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
:: Multiplying two integers
::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

theorem :: SCM_1:35
for i1, i2 being Integer,
s being State-consisting of 0, 0, 0, <*MultBy(dl.0,dl.1)*>^<*halt SCM*>,
<*i1*>^<*i2*>
holds s is halting &
Complexity s = 1 &
(Result s).dl.0 = i1 * i2 &
for d being Data-Location st d<>dl.0 holds (Result s).d = s.d;

::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
:: Dividing two integers
::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

theorem :: SCM_1:36
for i1, i2 being Integer,
s being State-consisting of 0, 0, 0, <*Divide(dl.0,dl.1)*>^<*halt SCM*>,
<*i1*>^<*i2*>
holds s is halting &
Complexity s = 1 &
(Result s).dl.0 = i1 div i2 & (Result s).dl.1 = i1 mod i2 &
::            (i2 <> 0 implies abs((Result s).dl.1) < abs i2
for d being Data-Location st d<>dl.0 & d<>dl.1
holds (Result s).d = s.d;

::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
:: Unconditional jump
::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

theorem :: SCM_1:37
for i1, i2 being Integer,
s being State-consisting of 0, 0, 0, <*goto il.1*>^<*halt SCM*>,
<*i1*>^<*i2*>
holds s is halting &
Complexity s = 1 &
for d being Data-Location holds (Result s).d = s.d;

::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
:: Jump at zero
::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

theorem :: SCM_1:38
for i1, i2 being Integer,
s being State-consisting of 0, 0, 0, <*dl.0 =0_goto il.1*>^<*halt SCM*>,
<*i1*>^<*i2*>
holds s is halting &
Complexity s = 1 &
for d being Data-Location holds (Result s).d = s.d;

::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
:: Jump at greater than zero
::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

theorem :: SCM_1:39
for i1, i2 being Integer,
s being State-consisting of 0, 0, 0, <*dl.0 >0_goto il.1*>^<*halt SCM*>,
<*i1*>^<*i2*>
holds s is halting &
Complexity s = 1 &
for d being Data-Location holds (Result s).d = s.d;

`