Article SCM_HALT, MML version 4.99.1005
:: SCM_HALT:attrnot 1 => SCM_HALT:attr 1
definition
let a1 be finite programmed initial Element of sproduct the Object-Kind of SCM+FSA;
attr a1 is InitClosed means
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being Element of NAT
st Initialized a1 c= b1
holds IC Computation(b1,b2) in proj1 a1;
end;
:: SCM_HALT:dfs 1
definiens
let a1 be finite programmed initial Element of sproduct the Object-Kind of SCM+FSA;
To prove
a1 is InitClosed
it is sufficient to prove
thus for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being Element of NAT
st Initialized a1 c= b1
holds IC Computation(b1,b2) in proj1 a1;
:: SCM_HALT:def 1
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA holds
b1 is InitClosed
iff
for b2 being Element of product the Object-Kind of SCM+FSA
for b3 being Element of NAT
st Initialized b1 c= b2
holds IC Computation(b2,b3) in proj1 b1;
:: SCM_HALT:attrnot 2 => SCM_HALT:attr 2
definition
let a1 be finite programmed initial Element of sproduct the Object-Kind of SCM+FSA;
attr a1 is InitHalting means
Initialized a1 is halting(NAT, {INT,INT *}, SCM+FSA);
end;
:: SCM_HALT:dfs 2
definiens
let a1 be finite programmed initial Element of sproduct the Object-Kind of SCM+FSA;
To prove
a1 is InitHalting
it is sufficient to prove
thus Initialized a1 is halting(NAT, {INT,INT *}, SCM+FSA);
:: SCM_HALT:def 2
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA holds
b1 is InitHalting
iff
Initialized b1 is halting(NAT, {INT,INT *}, SCM+FSA);
:: SCM_HALT:attrnot 3 => SCM_HALT:attr 3
definition
let a1 be finite programmed initial Element of sproduct the Object-Kind of SCM+FSA;
attr a1 is keepInt0_1 means
for b1 being Element of product the Object-Kind of SCM+FSA
st Initialized a1 c= b1
for b2 being Element of NAT holds
(Computation(b1,b2)) . intloc 0 = 1;
end;
:: SCM_HALT:dfs 3
definiens
let a1 be finite programmed initial Element of sproduct the Object-Kind of SCM+FSA;
To prove
a1 is keepInt0_1
it is sufficient to prove
thus for b1 being Element of product the Object-Kind of SCM+FSA
st Initialized a1 c= b1
for b2 being Element of NAT holds
(Computation(b1,b2)) . intloc 0 = 1;
:: SCM_HALT:def 3
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA holds
b1 is keepInt0_1
iff
for b2 being Element of product the Object-Kind of SCM+FSA
st Initialized b1 c= b2
for b3 being Element of NAT holds
(Computation(b2,b3)) . intloc 0 = 1;
:: SCM_HALT:th 1
theorem
for b1 being set
for b2, b3, b4 being Element of NAT
st b1 in proj1 (((intloc b2) .--> b3) +* Start-At insloc b4) &
b1 <> intloc b2
holds b1 = IC SCM+FSA;
:: SCM_HALT:th 2
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
for b2, b3, b4 being Element of NAT holds
proj1 b1 misses proj1 (((intloc b2) .--> b3) +* Start-At insloc b4);
:: SCM_HALT:th 3
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA holds
Initialized b1 = b1 +* (((intloc 0) .--> 1) +* Start-At insloc 0);
:: SCM_HALT:th 4
theorem
Macro halt SCM+FSA is InitHalting;
:: SCM_HALT:exreg 1
registration
cluster Relation-like Function-like finite programmed initial InitHalting Element of sproduct the Object-Kind of SCM+FSA;
end;
:: SCM_HALT:th 5
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial InitHalting Element of sproduct the Object-Kind of SCM+FSA
st Initialized b2 c= b1
holds b1 is halting(NAT, {INT,INT *}, SCM+FSA);
:: SCM_HALT:th 6
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA holds
b1 +* Start-At insloc 0 c= Initialized b1;
:: SCM_HALT:th 7
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
for b2 being Element of product the Object-Kind of SCM+FSA
st Initialized b1 c= b2
holds b2 . intloc 0 = 1;
:: SCM_HALT:condreg 1
registration
cluster finite programmed initial paraclosed -> InitClosed (Element of sproduct the Object-Kind of SCM+FSA);
end;
:: SCM_HALT:condreg 2
registration
cluster finite programmed initial parahalting -> InitHalting (Element of sproduct the Object-Kind of SCM+FSA);
end;
:: SCM_HALT:condreg 3
registration
cluster finite programmed initial InitHalting -> InitClosed (Element of sproduct the Object-Kind of SCM+FSA);
end;
:: SCM_HALT:condreg 4
registration
cluster finite programmed initial keepInt0_1 -> InitClosed (Element of sproduct the Object-Kind of SCM+FSA);
end;
:: SCM_HALT:condreg 5
registration
cluster finite programmed initial keeping_0 -> keepInt0_1 (Element of sproduct the Object-Kind of SCM+FSA);
end;
:: SCM_HALT:th 8
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial InitHalting Element of sproduct the Object-Kind of SCM+FSA
for b3 being read-write Int-Location
st not b3 in UsedIntLoc b2
holds (IExec(b2,b1)) . b3 = b1 . b3;
:: SCM_HALT:th 9
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial InitHalting Element of sproduct the Object-Kind of SCM+FSA
for b3 being FinSeq-Location
st not b3 in UsedInt*Loc b2
holds (IExec(b2,b1)) . b3 = b1 . b3;
:: SCM_HALT:funcreg 1
registration
let a1 be finite programmed initial InitHalting Element of sproduct the Object-Kind of SCM+FSA;
cluster Initialized a1 -> finite halting;
end;
:: SCM_HALT:condreg 6
registration
cluster finite programmed initial InitHalting -> non empty (Element of sproduct the Object-Kind of SCM+FSA);
end;
:: SCM_HALT:th 10
theorem
for b1 being finite programmed initial InitHalting Element of sproduct the Object-Kind of SCM+FSA holds
proj1 b1 <> {};
:: SCM_HALT:th 11
theorem
for b1 being finite programmed initial InitHalting Element of sproduct the Object-Kind of SCM+FSA holds
insloc 0 in proj1 b1;
:: SCM_HALT:th 12
theorem
for b1, b2 being Element of product the Object-Kind of SCM+FSA
for b3 being finite programmed initial InitHalting Element of sproduct the Object-Kind of SCM+FSA
st Initialized b3 c= b1
for b4 being Element of NAT
st ProgramPart Relocated(b3,b4) c= b2 &
IC b2 = insloc b4 &
b1 | (Int-Locations \/ FinSeq-Locations) = b2 | (Int-Locations \/ FinSeq-Locations)
for b5 being Element of NAT holds
(IC Computation(b1,b5)) + b4 = IC Computation(b2,b5) &
IncAddr(CurInstr Computation(b1,b5),b4) = CurInstr Computation(b2,b5) &
(Computation(b1,b5)) | (Int-Locations \/ FinSeq-Locations) = (Computation(b2,b5)) | (Int-Locations \/ FinSeq-Locations);
:: SCM_HALT:th 13
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
for b2 being Element of product the Object-Kind of SCM+FSA
st Initialized b1 c= b2
holds b1 c= b2;
:: SCM_HALT:th 14
theorem
for b1, b2 being Element of product the Object-Kind of SCM+FSA
for b3 being finite programmed initial InitHalting Element of sproduct the Object-Kind of SCM+FSA
st Initialized b3 c= b1 & Initialized b3 c= b2 & b1,b2 equal_outside NAT
for b4 being Element of NAT holds
Computation(b1,b4),Computation(b2,b4) equal_outside NAT & CurInstr Computation(b1,b4) = CurInstr Computation(b2,b4);
:: SCM_HALT:th 15
theorem
for b1, b2 being Element of product the Object-Kind of SCM+FSA
for b3 being finite programmed initial InitHalting Element of sproduct the Object-Kind of SCM+FSA
st Initialized b3 c= b1 & Initialized b3 c= b2 & b1,b2 equal_outside NAT
holds LifeSpan b1 = LifeSpan b2 & Result b1,Result b2 equal_outside NAT;
:: SCM_HALT:exreg 2
registration
cluster Relation-like Function-like finite programmed initial keeping_0 InitHalting Element of sproduct the Object-Kind of SCM+FSA;
end;
:: SCM_HALT:exreg 3
registration
cluster Relation-like Function-like finite programmed initial InitHalting keepInt0_1 Element of sproduct the Object-Kind of SCM+FSA;
end;
:: SCM_HALT:th 17
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial InitHalting keepInt0_1 Element of sproduct the Object-Kind of SCM+FSA holds
(IExec(b2,b1)) . intloc 0 = 1;
:: SCM_HALT:th 18
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial InitClosed Element of sproduct the Object-Kind of SCM+FSA
for b3 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
st Initialized b2 c= b1 &
b1 is halting(NAT, {INT,INT *}, SCM+FSA)
for b4 being Element of NAT
st b4 <= LifeSpan b1
holds Computation(b1,b4),Computation(b1 +* (b2 ';' b3),b4) equal_outside NAT;
:: SCM_HALT:th 19
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
for b2 being Element of product the Object-Kind of SCM+FSA
for b3, b4, b5 being Element of NAT holds
(b2 +* b1) +* (((intloc b3) .--> b4) +* Start-At insloc b5) = (b2 +* (((intloc b3) .--> b4) +* Start-At insloc b5)) +* b1;
:: SCM_HALT:th 20
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
for b2 being Element of product the Object-Kind of SCM+FSA
st ((intloc 0) .--> 1) +* Start-At insloc 0 c= b2
holds Initialized b1 c= b2 +* (b1 +* (((intloc 0) .--> 1) +* Start-At insloc 0)) &
b2 +* (b1 +* (((intloc 0) .--> 1) +* Start-At insloc 0)) = b2 +* b1 &
(b2 +* (b1 +* (((intloc 0) .--> 1) +* Start-At insloc 0))) +* Directed b1 = b2 +* Directed b1;
:: SCM_HALT:th 21
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial InitClosed Element of sproduct the Object-Kind of SCM+FSA
st b1 +* b2 is halting(NAT, {INT,INT *}, SCM+FSA) &
Directed b2 c= b1 &
((intloc 0) .--> 1) +* Start-At insloc 0 c= b1
holds IC Computation(b1,(LifeSpan (b1 +* b2)) + 1) = insloc card b2;
:: SCM_HALT:th 22
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial InitClosed Element of sproduct the Object-Kind of SCM+FSA
st b1 +* b2 is halting(NAT, {INT,INT *}, SCM+FSA) &
Directed b2 c= b1 &
((intloc 0) .--> 1) +* Start-At insloc 0 c= b1
holds (Computation(b1,LifeSpan (b1 +* b2))) | (Int-Locations \/ FinSeq-Locations) = (Computation(b1,(LifeSpan (b1 +* b2)) + 1)) | (Int-Locations \/ FinSeq-Locations);
:: SCM_HALT:th 23
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial InitHalting Element of sproduct the Object-Kind of SCM+FSA
st Initialized b2 c= b1
for b3 being Element of NAT
st b3 <= LifeSpan b1
holds CurInstr Computation(b1 +* Directed b2,b3) <> halt SCM+FSA;
:: SCM_HALT:th 24
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial InitClosed Element of sproduct the Object-Kind of SCM+FSA
st b1 +* Initialized b2 is halting(NAT, {INT,INT *}, SCM+FSA)
for b3 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
for b4 being Element of NAT
st b4 <= LifeSpan (b1 +* Initialized b2)
holds Computation(b1 +* Initialized b2,b4),Computation(b1 +* Initialized (b2 ';' b3),b4) equal_outside NAT;
:: SCM_HALT:th 25
theorem
for b1 being finite programmed initial InitHalting keepInt0_1 Element of sproduct the Object-Kind of SCM+FSA
for b2 being finite programmed initial InitHalting Element of sproduct the Object-Kind of SCM+FSA
for b3 being Element of product the Object-Kind of SCM+FSA
st Initialized (b1 ';' b2) c= b3
holds IC Computation(b3,(LifeSpan (b3 +* b1)) + 1) = insloc card b1 &
(Computation(b3,(LifeSpan (b3 +* b1)) + 1)) | (Int-Locations \/ FinSeq-Locations) = ((Computation(b3 +* b1,LifeSpan (b3 +* b1))) +* Initialized b2) | (Int-Locations \/ FinSeq-Locations) &
ProgramPart Relocated(b2,card b1) c= Computation(b3,(LifeSpan (b3 +* b1)) + 1) &
(Computation(b3,(LifeSpan (b3 +* b1)) + 1)) . intloc 0 = 1 &
b3 is halting(NAT, {INT,INT *}, SCM+FSA) &
LifeSpan b3 = ((LifeSpan (b3 +* b1)) + 1) + LifeSpan ((Result (b3 +* b1)) +* Initialized b2) &
(b2 is keeping_0 implies (Result b3) . intloc 0 = 1);
:: SCM_HALT:funcreg 2
registration
let a1 be finite programmed initial InitHalting keepInt0_1 Element of sproduct the Object-Kind of SCM+FSA;
let a2 be finite programmed initial InitHalting Element of sproduct the Object-Kind of SCM+FSA;
cluster a1 ';' a2 -> finite programmed initial InitHalting;
end;
:: SCM_HALT:th 26
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial keepInt0_1 Element of sproduct the Object-Kind of SCM+FSA
st b1 +* b2 is halting(NAT, {INT,INT *}, SCM+FSA)
for b3 being finite programmed initial InitClosed Element of sproduct the Object-Kind of SCM+FSA
st Initialized (b2 ';' b3) c= b1
for b4 being Element of NAT holds
(Computation((Result (b1 +* b2)) +* Initialized b3,b4)) +* Start-At ((IC Computation((Result (b1 +* b2)) +* Initialized b3,b4)) + card b2),Computation(b1 +* (b2 ';' b3),((LifeSpan (b1 +* b2)) + 1) + b4) equal_outside NAT;
:: SCM_HALT:th 27
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial keepInt0_1 Element of sproduct the Object-Kind of SCM+FSA
st b1 +* Initialized b2 is halting(not NAT, {INT,INT *}, SCM+FSA)
for b3 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
for b4 being Element of NAT holds
Computation(b1 +* Initialized b2,b4),Computation(b1 +* Initialized (b2 ';' b3),b4) equal_outside NAT;
:: SCM_HALT:th 28
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial InitHalting keepInt0_1 Element of sproduct the Object-Kind of SCM+FSA
for b3 being finite programmed initial InitHalting Element of sproduct the Object-Kind of SCM+FSA holds
LifeSpan (b1 +* Initialized (b2 ';' b3)) = ((LifeSpan (b1 +* Initialized b2)) + 1) + LifeSpan ((Result (b1 +* Initialized b2)) +* Initialized b3);
:: SCM_HALT:th 29
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial InitHalting keepInt0_1 Element of sproduct the Object-Kind of SCM+FSA
for b3 being finite programmed initial InitHalting Element of sproduct the Object-Kind of SCM+FSA holds
IExec(b2 ';' b3,b1) = (IExec(b3,IExec(b2,b1))) +* Start-At ((IC IExec(b3,IExec(b2,b1))) + card b2);
:: SCM_HALT:funcreg 3
registration
let a1 be parahalting Element of the Instructions of SCM+FSA;
cluster Macro a1 -> finite programmed initial InitHalting;
end;
:: SCM_HALT:funcreg 4
registration
let a1 be parahalting Element of the Instructions of SCM+FSA;
let a2 be finite programmed initial parahalting Element of sproduct the Object-Kind of SCM+FSA;
cluster a1 ';' a2 -> finite programmed initial InitHalting;
end;
:: SCM_HALT:funcreg 5
registration
let a1 be parahalting keeping_0 Element of the Instructions of SCM+FSA;
let a2 be finite programmed initial InitHalting Element of sproduct the Object-Kind of SCM+FSA;
cluster a1 ';' a2 -> finite programmed initial InitHalting;
end;
:: SCM_HALT:funcreg 6
registration
let a1, a2 be finite programmed initial keepInt0_1 Element of sproduct the Object-Kind of SCM+FSA;
cluster a1 ';' a2 -> finite programmed initial keepInt0_1;
end;
:: SCM_HALT:funcreg 7
registration
let a1 be parahalting keeping_0 Element of the Instructions of SCM+FSA;
let a2 be finite programmed initial InitHalting keepInt0_1 Element of sproduct the Object-Kind of SCM+FSA;
cluster a2 ';' a1 -> finite programmed initial InitHalting keepInt0_1;
end;
:: SCM_HALT:funcreg 8
registration
let a1 be parahalting keeping_0 Element of the Instructions of SCM+FSA;
let a2 be finite programmed initial InitHalting keepInt0_1 Element of sproduct the Object-Kind of SCM+FSA;
cluster a1 ';' a2 -> finite programmed initial InitHalting keepInt0_1;
end;
:: SCM_HALT:funcreg 9
registration
let a1 be parahalting Element of the Instructions of SCM+FSA;
let a2 be finite programmed initial parahalting Element of sproduct the Object-Kind of SCM+FSA;
cluster a2 ';' a1 -> finite programmed initial InitHalting;
end;
:: SCM_HALT:funcreg 10
registration
let a1, a2 be parahalting Element of the Instructions of SCM+FSA;
cluster a1 ';' a2 -> finite programmed initial InitHalting;
end;
:: SCM_HALT:th 30
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being Int-Location
for b3 being finite programmed initial InitHalting keepInt0_1 Element of sproduct the Object-Kind of SCM+FSA
for b4 being finite programmed initial InitHalting Element of sproduct the Object-Kind of SCM+FSA holds
(IExec(b3 ';' b4,b1)) . b2 = (IExec(b4,IExec(b3,b1))) . b2;
:: SCM_HALT:th 31
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being FinSeq-Location
for b3 being finite programmed initial InitHalting keepInt0_1 Element of sproduct the Object-Kind of SCM+FSA
for b4 being finite programmed initial InitHalting Element of sproduct the Object-Kind of SCM+FSA holds
(IExec(b3 ';' b4,b1)) . b2 = (IExec(b4,IExec(b3,b1))) . b2;
:: SCM_HALT:th 32
theorem
for b1 being finite programmed initial InitHalting keepInt0_1 Element of sproduct the Object-Kind of SCM+FSA
for b2 being Element of product the Object-Kind of SCM+FSA holds
(Initialize IExec(b1,b2)) | (Int-Locations \/ FinSeq-Locations) = (IExec(b1,b2)) | (Int-Locations \/ FinSeq-Locations);
:: SCM_HALT:th 33
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being Int-Location
for b3 being finite programmed initial InitHalting keepInt0_1 Element of sproduct the Object-Kind of SCM+FSA
for b4 being parahalting Element of the Instructions of SCM+FSA holds
(IExec(b3 ';' b4,b1)) . b2 = (Exec(b4,IExec(b3,b1))) . b2;
:: SCM_HALT:th 34
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being FinSeq-Location
for b3 being finite programmed initial InitHalting keepInt0_1 Element of sproduct the Object-Kind of SCM+FSA
for b4 being parahalting Element of the Instructions of SCM+FSA holds
(IExec(b3 ';' b4,b1)) . b2 = (Exec(b4,IExec(b3,b1))) . b2;
:: SCM_HALT:prednot 1 => SCM_HALT:pred 1
definition
let a1 be finite programmed initial Element of sproduct the Object-Kind of SCM+FSA;
let a2 be Element of product the Object-Kind of SCM+FSA;
pred A1 is_closed_onInit A2 means
for b1 being Element of NAT holds
IC Computation(a2 +* Initialized a1,b1) in proj1 a1;
end;
:: SCM_HALT:dfs 4
definiens
let a1 be finite programmed initial Element of sproduct the Object-Kind of SCM+FSA;
let a2 be Element of product the Object-Kind of SCM+FSA;
To prove
a1 is_closed_onInit a2
it is sufficient to prove
thus for b1 being Element of NAT holds
IC Computation(a2 +* Initialized a1,b1) in proj1 a1;
:: SCM_HALT:def 4
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
for b2 being Element of product the Object-Kind of SCM+FSA holds
b1 is_closed_onInit b2
iff
for b3 being Element of NAT holds
IC Computation(b2 +* Initialized b1,b3) in proj1 b1;
:: SCM_HALT:prednot 2 => SCM_HALT:pred 2
definition
let a1 be finite programmed initial Element of sproduct the Object-Kind of SCM+FSA;
let a2 be Element of product the Object-Kind of SCM+FSA;
pred A1 is_halting_onInit A2 means
a2 +* Initialized a1 is halting(NAT, {INT,INT *}, SCM+FSA);
end;
:: SCM_HALT:dfs 5
definiens
let a1 be finite programmed initial Element of sproduct the Object-Kind of SCM+FSA;
let a2 be Element of product the Object-Kind of SCM+FSA;
To prove
a1 is_halting_onInit a2
it is sufficient to prove
thus a2 +* Initialized a1 is halting(NAT, {INT,INT *}, SCM+FSA);
:: SCM_HALT:def 5
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
for b2 being Element of product the Object-Kind of SCM+FSA holds
b1 is_halting_onInit b2
iff
b2 +* Initialized b1 is halting(NAT, {INT,INT *}, SCM+FSA);
:: SCM_HALT:th 35
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA holds
b1 is InitClosed
iff
for b2 being Element of product the Object-Kind of SCM+FSA holds
b1 is_closed_onInit b2;
:: SCM_HALT:th 36
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA holds
b1 is InitHalting
iff
for b2 being Element of product the Object-Kind of SCM+FSA holds
b1 is_halting_onInit b2;
:: SCM_HALT:th 37
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
for b3 being Int-Location
st b2 does_not_destroy b3 & b2 is_closed_onInit b1 & Initialized b2 c= b1
for b4 being Element of NAT holds
(Computation(b1,b4)) . b3 = b1 . b3;
:: SCM_HALT:exreg 4
registration
cluster Relation-like Function-like finite programmed initial good InitHalting Element of sproduct the Object-Kind of SCM+FSA;
end;
:: SCM_HALT:condreg 7
registration
cluster finite programmed initial good InitClosed -> keepInt0_1 (Element of sproduct the Object-Kind of SCM+FSA);
end;
:: SCM_HALT:funcreg 11
registration
cluster SCM+FSA-Stop -> finite good InitHalting;
end;
:: SCM_HALT:th 38
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being parahalting keeping_0 Element of the Instructions of SCM+FSA
for b3 being finite programmed initial InitHalting Element of sproduct the Object-Kind of SCM+FSA
for b4 being Int-Location holds
(IExec(b2 ';' b3,b1)) . b4 = (IExec(b3,Exec(b2,Initialize b1))) . b4;
:: SCM_HALT:th 39
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being parahalting keeping_0 Element of the Instructions of SCM+FSA
for b3 being finite programmed initial InitHalting Element of sproduct the Object-Kind of SCM+FSA
for b4 being FinSeq-Location holds
(IExec(b2 ';' b3,b1)) . b4 = (IExec(b3,Exec(b2,Initialize b1))) . b4;
:: SCM_HALT:th 40
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA holds
b2 is_closed_onInit b1
iff
b2 is_closed_on Initialize b1;
:: SCM_HALT:th 41
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA holds
b2 is_halting_onInit b1
iff
b2 is_halting_on Initialize b1;
:: SCM_HALT:th 42
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
for b2 being Element of product the Object-Kind of SCM+FSA holds
IExec(b1,b2) = IExec(b1,Initialize b2);
:: SCM_HALT:th 43
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2, b3 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
for b4 being read-write Int-Location
st b1 . b4 = 0 & b2 is_closed_onInit b1 & b2 is_halting_onInit b1
holds if=0(b4,b2,b3) is_closed_onInit b1 & if=0(b4,b2,b3) is_halting_onInit b1;
:: SCM_HALT:th 44
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2, b3 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
for b4 being read-write Int-Location
st b1 . b4 = 0 & b2 is_closed_onInit b1 & b2 is_halting_onInit b1
holds IExec(if=0(b4,b2,b3),b1) = (IExec(b2,b1)) +* Start-At insloc (((card b2) + card b3) + 3);
:: SCM_HALT:th 45
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2, b3 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
for b4 being read-write Int-Location
st b1 . b4 <> 0 & b3 is_closed_onInit b1 & b3 is_halting_onInit b1
holds if=0(b4,b2,b3) is_closed_onInit b1 & if=0(b4,b2,b3) is_halting_onInit b1;
:: SCM_HALT:th 46
theorem
for b1, b2 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
for b3 being read-write Int-Location
for b4 being Element of product the Object-Kind of SCM+FSA
st b4 . b3 <> 0 & b2 is_closed_onInit b4 & b2 is_halting_onInit b4
holds IExec(if=0(b3,b1,b2),b4) = (IExec(b2,b4)) +* Start-At insloc (((card b1) + card b2) + 3);
:: SCM_HALT:th 47
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2, b3 being finite programmed initial InitHalting Element of sproduct the Object-Kind of SCM+FSA
for b4 being read-write Int-Location holds
if=0(b4,b2,b3) is InitHalting &
(b1 . b4 = 0 implies IExec(if=0(b4,b2,b3),b1) = (IExec(b2,b1)) +* Start-At insloc (((card b2) + card b3) + 3)) &
(b1 . b4 = 0 or IExec(if=0(b4,b2,b3),b1) = (IExec(b3,b1)) +* Start-At insloc (((card b2) + card b3) + 3));
:: SCM_HALT:th 48
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2, b3 being finite programmed initial InitHalting Element of sproduct the Object-Kind of SCM+FSA
for b4 being read-write Int-Location holds
IC IExec(if=0(b4,b2,b3),b1) = insloc (((card b2) + card b3) + 3) &
(b1 . b4 = 0 implies (for b5 being Int-Location holds
(IExec(if=0(b4,b2,b3),b1)) . b5 = (IExec(b2,b1)) . b5) &
(for b5 being FinSeq-Location holds
(IExec(if=0(b4,b2,b3),b1)) . b5 = (IExec(b2,b1)) . b5)) &
(b1 . b4 = 0 or (for b5 being Int-Location holds
(IExec(if=0(b4,b2,b3),b1)) . b5 = (IExec(b3,b1)) . b5) &
(for b5 being FinSeq-Location holds
(IExec(if=0(b4,b2,b3),b1)) . b5 = (IExec(b3,b1)) . b5));
:: SCM_HALT:th 49
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2, b3 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
for b4 being read-write Int-Location
st 0 < b1 . b4 & b2 is_closed_onInit b1 & b2 is_halting_onInit b1
holds if>0(b4,b2,b3) is_closed_onInit b1 & if>0(b4,b2,b3) is_halting_onInit b1;
:: SCM_HALT:th 50
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2, b3 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
for b4 being read-write Int-Location
st 0 < b1 . b4 & b2 is_closed_onInit b1 & b2 is_halting_onInit b1
holds IExec(if>0(b4,b2,b3),b1) = (IExec(b2,b1)) +* Start-At insloc (((card b2) + card b3) + 3);
:: SCM_HALT:th 51
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2, b3 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
for b4 being read-write Int-Location
st b1 . b4 <= 0 & b3 is_closed_onInit b1 & b3 is_halting_onInit b1
holds if>0(b4,b2,b3) is_closed_onInit b1 & if>0(b4,b2,b3) is_halting_onInit b1;
:: SCM_HALT:th 52
theorem
for b1, b2 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
for b3 being read-write Int-Location
for b4 being Element of product the Object-Kind of SCM+FSA
st b4 . b3 <= 0 & b2 is_closed_onInit b4 & b2 is_halting_onInit b4
holds IExec(if>0(b3,b1,b2),b4) = (IExec(b2,b4)) +* Start-At insloc (((card b1) + card b2) + 3);
:: SCM_HALT:th 53
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2, b3 being finite programmed initial InitHalting Element of sproduct the Object-Kind of SCM+FSA
for b4 being read-write Int-Location holds
if>0(b4,b2,b3) is InitHalting &
(b1 . b4 <= 0 or IExec(if>0(b4,b2,b3),b1) = (IExec(b2,b1)) +* Start-At insloc (((card b2) + card b3) + 3)) &
(b1 . b4 <= 0 implies IExec(if>0(b4,b2,b3),b1) = (IExec(b3,b1)) +* Start-At insloc (((card b2) + card b3) + 3));
:: SCM_HALT:th 54
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2, b3 being finite programmed initial InitHalting Element of sproduct the Object-Kind of SCM+FSA
for b4 being read-write Int-Location holds
IC IExec(if>0(b4,b2,b3),b1) = insloc (((card b2) + card b3) + 3) &
(b1 . b4 <= 0 or (for b5 being Int-Location holds
(IExec(if>0(b4,b2,b3),b1)) . b5 = (IExec(b2,b1)) . b5) &
(for b5 being FinSeq-Location holds
(IExec(if>0(b4,b2,b3),b1)) . b5 = (IExec(b2,b1)) . b5)) &
(b1 . b4 <= 0 implies (for b5 being Int-Location holds
(IExec(if>0(b4,b2,b3),b1)) . b5 = (IExec(b3,b1)) . b5) &
(for b5 being FinSeq-Location holds
(IExec(if>0(b4,b2,b3),b1)) . b5 = (IExec(b3,b1)) . b5));
:: SCM_HALT:th 55
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2, b3 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
for b4 being read-write Int-Location
st b1 . b4 < 0 & b2 is_closed_onInit b1 & b2 is_halting_onInit b1
holds IExec(if<0(b4,b2,b3),b1) = (IExec(b2,b1)) +* Start-At insloc ((((card b2) + card b3) + card b3) + 7);
:: SCM_HALT:th 56
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2, b3 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
for b4 being read-write Int-Location
st b1 . b4 = 0 & b3 is_closed_onInit b1 & b3 is_halting_onInit b1
holds IExec(if<0(b4,b2,b3),b1) = (IExec(b3,b1)) +* Start-At insloc ((((card b2) + card b3) + card b3) + 7);
:: SCM_HALT:th 57
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2, b3 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
for b4 being read-write Int-Location
st 0 < b1 . b4 & b3 is_closed_onInit b1 & b3 is_halting_onInit b1
holds IExec(if<0(b4,b2,b3),b1) = (IExec(b3,b1)) +* Start-At insloc ((((card b2) + card b3) + card b3) + 7);
:: SCM_HALT:th 58
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2, b3 being finite programmed initial InitHalting Element of sproduct the Object-Kind of SCM+FSA
for b4 being read-write Int-Location holds
if<0(b4,b2,b3) is InitHalting &
(0 <= b1 . b4 or IExec(if<0(b4,b2,b3),b1) = (IExec(b2,b1)) +* Start-At insloc ((((card b2) + card b3) + card b3) + 7)) &
(0 <= b1 . b4 implies IExec(if<0(b4,b2,b3),b1) = (IExec(b3,b1)) +* Start-At insloc ((((card b2) + card b3) + card b3) + 7));
:: SCM_HALT:funcreg 12
registration
let a1, a2 be finite programmed initial InitHalting Element of sproduct the Object-Kind of SCM+FSA;
let a3 be read-write Int-Location;
cluster if=0(a3,a1,a2) -> finite programmed initial InitHalting;
end;
:: SCM_HALT:funcreg 13
registration
let a1, a2 be finite programmed initial InitHalting Element of sproduct the Object-Kind of SCM+FSA;
let a3 be read-write Int-Location;
cluster if>0(a3,a1,a2) -> finite programmed initial InitHalting;
end;
:: SCM_HALT:funcreg 14
registration
let a1, a2 be finite programmed initial InitHalting Element of sproduct the Object-Kind of SCM+FSA;
let a3 be read-write Int-Location;
cluster if<0(a3,a1,a2) -> finite programmed initial InitHalting;
end;
:: SCM_HALT:th 59
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA holds
b1 is InitHalting
iff
for b2 being Element of product the Object-Kind of SCM+FSA holds
b1 is_halting_on Initialize b2;
:: SCM_HALT:th 60
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA holds
b1 is InitClosed
iff
for b2 being Element of product the Object-Kind of SCM+FSA holds
b1 is_closed_on Initialize b2;
:: SCM_HALT:th 61
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial InitHalting Element of sproduct the Object-Kind of SCM+FSA
for b3 being read-write Int-Location holds
(IExec(b2,b1)) . b3 = (Computation((Initialize b1) +* (b2 +* Start-At insloc 0),LifeSpan ((Initialize b1) +* (b2 +* Start-At insloc 0)))) . b3;
:: SCM_HALT:th 62
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial InitHalting Element of sproduct the Object-Kind of SCM+FSA
for b3 being Int-Location
for b4 being Element of NAT
st b2 does_not_destroy b3
holds (IExec(b2,b1)) . b3 = (Computation((Initialize b1) +* (b2 +* Start-At insloc 0),b4)) . b3;
:: SCM_HALT:th 63
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial InitHalting Element of sproduct the Object-Kind of SCM+FSA
for b3 being Int-Location
st b2 does_not_destroy b3
holds (IExec(b2,b1)) . b3 = (Initialize b1) . b3;
:: SCM_HALT:th 64
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial InitHalting keepInt0_1 Element of sproduct the Object-Kind of SCM+FSA
for b3 being read-write Int-Location
st b2 does_not_destroy b3
holds (Computation((Initialize b1) +* ((b2 ';' SubFrom(b3,intloc 0)) +* Start-At insloc 0),LifeSpan ((Initialize b1) +* ((b2 ';' SubFrom(b3,intloc 0)) +* Start-At insloc 0)))) . b3 = (b1 . b3) - 1;
:: SCM_HALT:th 65
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial InitClosed Element of sproduct the Object-Kind of SCM+FSA
st Initialized b2 c= b1 &
b1 is halting(NAT, {INT,INT *}, SCM+FSA)
for b3 being Element of NAT
st b3 <= LifeSpan b1
holds Computation(b1,b3),Computation(b1 +* loop b2,b3) equal_outside NAT;
:: SCM_HALT:th 66
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial InitHalting Element of sproduct the Object-Kind of SCM+FSA
st Initialized b2 c= b1
for b3 being Element of NAT
st b3 <= LifeSpan b1
holds CurInstr Computation(b1 +* loop b2,b3) <> halt SCM+FSA;
:: SCM_HALT:th 67
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
for b2 being Element of product the Object-Kind of SCM+FSA holds
b1 c= b2 +* Initialized b1;
:: SCM_HALT:th 68
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
st b2 is_closed_onInit b1 & b2 is_halting_onInit b1
for b3 being Element of NAT
st b3 <= LifeSpan (b1 +* Initialized b2)
holds Computation(b1 +* Initialized b2,b3),Computation(b1 +* Initialized loop b2,b3) equal_outside NAT;
:: SCM_HALT:th 69
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
st b2 is_closed_onInit b1 & b2 is_halting_onInit b1
for b3 being Element of NAT
st b3 < LifeSpan (b1 +* Initialized b2)
holds CurInstr Computation(b1 +* Initialized b2,b3) = CurInstr Computation(b1 +* Initialized loop b2,b3);
:: SCM_HALT:th 70
theorem
for b1 being Instruction-Location of SCM+FSA holds
not b1 in proj1 (((intloc 0) .--> 1) +* Start-At insloc 0);
:: SCM_HALT:th 71
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
st b2 is_closed_onInit b1 & b2 is_halting_onInit b1
holds CurInstr Computation(b1 +* Initialized loop b2,LifeSpan (b1 +* Initialized b2)) = goto insloc 0 &
(for b3 being Element of NAT
st b3 <= LifeSpan (b1 +* Initialized b2)
holds CurInstr Computation(b1 +* Initialized loop b2,b3) <> halt SCM+FSA);
:: SCM_HALT:th 72
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
st b2 is_closed_onInit b1 & b2 is_halting_onInit b1
holds CurInstr Computation(b1 +* Initialized loop b2,LifeSpan (b1 +* Initialized b2)) = goto insloc 0;
:: SCM_HALT:th 73
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial good InitHalting Element of sproduct the Object-Kind of SCM+FSA
for b3 being read-write Int-Location
st b2 does_not_destroy b3 & b1 . intloc 0 = 1 & 0 < b1 . b3
holds loop if=0(b3,Goto insloc 2,b2 ';' SubFrom(b3,intloc 0)) is_pseudo-closed_on b1;
:: SCM_HALT:th 74
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial good InitHalting Element of sproduct the Object-Kind of SCM+FSA
for b3 being read-write Int-Location
st b2 does_not_destroy b3 & 0 < b1 . b3
holds Initialized loop if=0(b3,Goto insloc 2,b2 ';' SubFrom(b3,intloc 0)) is_pseudo-closed_on b1;
:: SCM_HALT:th 75
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial good InitHalting Element of sproduct the Object-Kind of SCM+FSA
for b3 being read-write Int-Location
st b2 does_not_destroy b3 & b1 . intloc 0 = 1
holds Times(b3,b2) is_closed_on b1 & Times(b3,b2) is_halting_on b1;
:: SCM_HALT:th 76
theorem
for b1 being finite programmed initial good InitHalting Element of sproduct the Object-Kind of SCM+FSA
for b2 being read-write Int-Location
st b1 does_not_destroy b2
holds Initialized Times(b2,b1) is halting(NAT, {INT,INT *}, SCM+FSA);
:: SCM_HALT:funcreg 15
registration
let a1 be read-write Int-Location;
let a2 be finite programmed initial good Element of sproduct the Object-Kind of SCM+FSA;
cluster Times(a1,a2) -> finite programmed initial good;
end;
:: SCM_HALT:th 77
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial good InitHalting Element of sproduct the Object-Kind of SCM+FSA
for b3 being read-write Int-Location
st b2 does_not_destroy b3 & 0 < b1 . b3
holds ex b4 being Element of product the Object-Kind of SCM+FSA st
ex b5 being Element of NAT st
b4 = b1 +* Initialized loop if=0(b3,Goto insloc 2,b2 ';' SubFrom(b3,intloc 0)) &
b5 = (LifeSpan (b1 +* Initialized if=0(b3,Goto insloc 2,b2 ';' SubFrom(b3,intloc 0)))) + 1 &
(Computation(b4,b5)) . b3 = (b1 . b3) - 1 &
(Computation(b4,b5)) . intloc 0 = 1 &
(for b6 being read-write Int-Location
st b6 <> b3
holds (Computation(b4,b5)) . b6 = (IExec(b2,b1)) . b6) &
(for b6 being FinSeq-Location holds
(Computation(b4,b5)) . b6 = (IExec(b2,b1)) . b6) &
IC Computation(b4,b5) = insloc 0 &
(for b6 being Element of NAT
st b6 <= b5
holds IC Computation(b4,b6) in proj1 loop if=0(b3,Goto insloc 2,b2 ';' SubFrom(b3,intloc 0)));
:: SCM_HALT:th 78
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial good InitHalting Element of sproduct the Object-Kind of SCM+FSA
for b3 being read-write Int-Location
st b1 . intloc 0 = 1 & b1 . b3 <= 0
holds (IExec(Times(b3,b2),b1)) | (Int-Locations \/ FinSeq-Locations) = b1 | (Int-Locations \/ FinSeq-Locations);
:: SCM_HALT:th 79
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial good InitHalting Element of sproduct the Object-Kind of SCM+FSA
for b3 being read-write Int-Location
st b2 does_not_destroy b3 & 0 < b1 . b3
holds (IExec(b2 ';' SubFrom(b3,intloc 0),b1)) . b3 = (b1 . b3) - 1 &
(IExec(Times(b3,b2),b1)) | (Int-Locations \/ FinSeq-Locations) = (IExec(Times(b3,b2),IExec(b2 ';' SubFrom(b3,intloc 0),b1))) | (Int-Locations \/ FinSeq-Locations);
:: SCM_HALT:th 80
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial good InitHalting Element of sproduct the Object-Kind of SCM+FSA
for b3 being FinSeq-Location
for b4 being read-write Int-Location
st b1 . b4 <= 0
holds (IExec(Times(b4,b2),b1)) . b3 = b1 . b3;
:: SCM_HALT:th 81
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial good InitHalting Element of sproduct the Object-Kind of SCM+FSA
for b3 being Int-Location
for b4 being read-write Int-Location
st b1 . b4 <= 0
holds (IExec(Times(b4,b2),b1)) . b3 = (Initialize b1) . b3;
:: SCM_HALT:th 82
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial good InitHalting Element of sproduct the Object-Kind of SCM+FSA
for b3 being FinSeq-Location
for b4 being read-write Int-Location
st b2 does_not_destroy b4 & 0 < b1 . b4
holds (IExec(Times(b4,b2),b1)) . b3 = (IExec(Times(b4,b2),IExec(b2 ';' SubFrom(b4,intloc 0),b1))) . b3;
:: SCM_HALT:th 83
theorem
for b1 being Element of product the Object-Kind of SCM+FSA
for b2 being finite programmed initial good InitHalting Element of sproduct the Object-Kind of SCM+FSA
for b3 being Int-Location
for b4 being read-write Int-Location
st b2 does_not_destroy b4 & 0 < b1 . b4
holds (IExec(Times(b4,b2),b1)) . b3 = (IExec(Times(b4,b2),IExec(b2 ';' SubFrom(b4,intloc 0),b1))) . b3;
:: SCM_HALT:attrnot 4 => SCM_HALT:attr 4
definition
let a1 be Element of the Instructions of SCM+FSA;
attr a1 is good means
a1 does_not_destroy intloc 0;
end;
:: SCM_HALT:dfs 6
definiens
let a1 be Element of the Instructions of SCM+FSA;
To prove
a1 is good
it is sufficient to prove
thus a1 does_not_destroy intloc 0;
:: SCM_HALT:def 6
theorem
for b1 being Element of the Instructions of SCM+FSA holds
b1 is good
iff
b1 does_not_destroy intloc 0;
:: SCM_HALT:exreg 5
registration
cluster parahalting good Element of the Instructions of SCM+FSA;
end;
:: SCM_HALT:funcreg 16
registration
let a1 be good Element of the Instructions of SCM+FSA;
let a2 be finite programmed initial good Element of sproduct the Object-Kind of SCM+FSA;
cluster a1 ';' a2 -> finite programmed initial good;
end;
:: SCM_HALT:funcreg 17
registration
let a1 be good Element of the Instructions of SCM+FSA;
let a2 be finite programmed initial good Element of sproduct the Object-Kind of SCM+FSA;
cluster a2 ';' a1 -> finite programmed initial good;
end;
:: SCM_HALT:funcreg 18
registration
let a1, a2 be good Element of the Instructions of SCM+FSA;
cluster a1 ';' a2 -> finite programmed initial good;
end;
:: SCM_HALT:funcreg 19
registration
let a1 be read-write Int-Location;
let a2 be Int-Location;
cluster a1 := a2 -> good;
end;
:: SCM_HALT:funcreg 20
registration
let a1 be read-write Int-Location;
let a2 be Int-Location;
cluster SubFrom(a1,a2) -> good;
end;
:: SCM_HALT:funcreg 21
registration
let a1 be read-write Int-Location;
let a2 be Int-Location;
let a3 be FinSeq-Location;
cluster a1 :=(a3,a2) -> good;
end;
:: SCM_HALT:funcreg 22
registration
let a1, a2 be Int-Location;
let a3 be FinSeq-Location;
cluster (a3,a1):= a2 -> good;
end;
:: SCM_HALT:funcreg 23
registration
let a1 be read-write Int-Location;
let a2 be FinSeq-Location;
cluster a1 :=len a2 -> good;
end;
:: SCM_HALT:funcreg 24
registration
let a1 be Element of NAT;
cluster intloc (a1 + 1) -> read-write;
end;