Article SF_MASTR, MML version 4.99.1005
:: SF_MASTR:funcreg 1
registration
cluster Int-Locations -> non empty;
end;
:: SF_MASTR:funcreg 2
registration
cluster FinSeq-Locations -> non empty;
end;
:: SF_MASTR:th 5
theorem
for b1, b2, b3, b4 being Int-Location
st b1 := b2 = b3 := b4
holds b1 = b3 & b2 = b4;
:: SF_MASTR:th 6
theorem
for b1, b2, b3, b4 being Int-Location
st AddTo(b1,b2) = AddTo(b3,b4)
holds b1 = b3 & b2 = b4;
:: SF_MASTR:th 7
theorem
for b1, b2, b3, b4 being Int-Location
st SubFrom(b1,b2) = SubFrom(b3,b4)
holds b1 = b3 & b2 = b4;
:: SF_MASTR:th 8
theorem
for b1, b2, b3, b4 being Int-Location
st MultBy(b1,b2) = MultBy(b3,b4)
holds b1 = b3 & b2 = b4;
:: SF_MASTR:th 9
theorem
for b1, b2, b3, b4 being Int-Location
st Divide(b1,b2) = Divide(b3,b4)
holds b1 = b3 & b2 = b4;
:: SF_MASTR:th 10
theorem
for b1, b2 being Instruction-Location of SCM+FSA
st goto b1 = goto b2
holds b1 = b2;
:: SF_MASTR:th 11
theorem
for b1, b2 being Int-Location
for b3, b4 being Instruction-Location of SCM+FSA
st b1 =0_goto b3 = b2 =0_goto b4
holds b1 = b2 & b3 = b4;
:: SF_MASTR:th 12
theorem
for b1, b2 being Int-Location
for b3, b4 being Instruction-Location of SCM+FSA
st b1 >0_goto b3 = b2 >0_goto b4
holds b1 = b2 & b3 = b4;
:: SF_MASTR:th 13
theorem
for b1, b2, b3, b4 being Int-Location
for b5, b6 being FinSeq-Location
st b1 :=(b5,b2) = b3 :=(b6,b4)
holds b2 = b4 & b1 = b3 & b5 = b6;
:: SF_MASTR:th 14
theorem
for b1, b2, b3, b4 being Int-Location
for b5, b6 being FinSeq-Location
st (b5,b1):= b2 = (b6,b3):= b4
holds b1 = b3 & b2 = b4 & b5 = b6;
:: SF_MASTR:th 15
theorem
for b1, b2 being Int-Location
for b3, b4 being FinSeq-Location
st b1 :=len b3 = b2 :=len b4
holds b1 = b2 & b3 = b4;
:: SF_MASTR:th 16
theorem
for b1, b2 being Int-Location
for b3, b4 being FinSeq-Location
st b3 :=<0,...,0> b1 = b4 :=<0,...,0> b2
holds b1 = b2 & b3 = b4;
:: SF_MASTR:funcnot 1 => SF_MASTR:func 1
definition
let a1 be Element of the Instructions of SCM+FSA;
func UsedIntLoc A1 -> Element of Fin Int-Locations means
ex b1, b2 being Int-Location st
(a1 <> b1 := b2 & a1 <> AddTo(b1,b2) & a1 <> SubFrom(b1,b2) & a1 <> MultBy(b1,b2) implies a1 = Divide(b1,b2)) &
it = {b1,b2}
if InsCode a1 in {1,2,3,4,5},
ex b1 being Int-Location st
ex b2 being Instruction-Location of SCM+FSA st
(a1 = b1 =0_goto b2 or a1 = b1 >0_goto b2) & it = {b1}
if (InsCode a1 = 7 or InsCode a1 = 8),
ex b1, b2 being Int-Location st
ex b3 being FinSeq-Location st
(a1 = b2 :=(b3,b1) or a1 = (b3,b1):= b2) &
it = {b1,b2}
if (InsCode a1 = 9 or InsCode a1 = 10),
ex b1 being Int-Location st
ex b2 being FinSeq-Location st
(a1 = b1 :=len b2 or a1 = b2 :=<0,...,0> b1) & it = {b1}
if (InsCode a1 = 11 or InsCode a1 = 12)
otherwise it = {};
end;
:: SF_MASTR:def 1
theorem
for b1 being Element of the Instructions of SCM+FSA
for b2 being Element of Fin Int-Locations holds
(InsCode b1 in {1,2,3,4,5} implies (b2 = UsedIntLoc b1
iff
ex b3, b4 being Int-Location st
(b1 <> b3 := b4 & b1 <> AddTo(b3,b4) & b1 <> SubFrom(b3,b4) & b1 <> MultBy(b3,b4) implies b1 = Divide(b3,b4)) &
b2 = {b3,b4})) &
(InsCode b1 <> 7 & InsCode b1 <> 8 or (b2 = UsedIntLoc b1
iff
ex b3 being Int-Location st
ex b4 being Instruction-Location of SCM+FSA st
(b1 = b3 =0_goto b4 or b1 = b3 >0_goto b4) & b2 = {b3})) &
(InsCode b1 <> 9 & InsCode b1 <> 10 or (b2 = UsedIntLoc b1
iff
ex b3, b4 being Int-Location st
ex b5 being FinSeq-Location st
(b1 = b4 :=(b5,b3) or b1 = (b5,b3):= b4) &
b2 = {b3,b4})) &
(InsCode b1 <> 11 & InsCode b1 <> 12 or (b2 = UsedIntLoc b1
iff
ex b3 being Int-Location st
ex b4 being FinSeq-Location st
(b1 = b3 :=len b4 or b1 = b4 :=<0,...,0> b3) & b2 = {b3})) &
(not InsCode b1 in {1,2,3,4,5} &
InsCode b1 <> 7 &
InsCode b1 <> 8 &
InsCode b1 <> 9 &
InsCode b1 <> 10 &
InsCode b1 <> 11 &
InsCode b1 <> 12 implies (b2 = UsedIntLoc b1
iff
b2 = {}));
:: SF_MASTR:th 17
theorem
UsedIntLoc halt SCM+FSA = {};
:: SF_MASTR:th 18
theorem
for b1, b2 being Int-Location
for b3 being Element of the Instructions of SCM+FSA
st (b3 <> b1 := b2 & b3 <> AddTo(b1,b2) & b3 <> SubFrom(b1,b2) & b3 <> MultBy(b1,b2) implies b3 = Divide(b1,b2))
holds UsedIntLoc b3 = {b1,b2};
:: SF_MASTR:th 19
theorem
for b1 being Instruction-Location of SCM+FSA holds
UsedIntLoc goto b1 = {};
:: SF_MASTR:th 20
theorem
for b1 being Int-Location
for b2 being Instruction-Location of SCM+FSA
for b3 being Element of the Instructions of SCM+FSA
st (b3 = b1 =0_goto b2 or b3 = b1 >0_goto b2)
holds UsedIntLoc b3 = {b1};
:: SF_MASTR:th 21
theorem
for b1, b2 being Int-Location
for b3 being FinSeq-Location
for b4 being Element of the Instructions of SCM+FSA
st (b4 = b1 :=(b3,b2) or b4 = (b3,b2):= b1)
holds UsedIntLoc b4 = {b2,b1};
:: SF_MASTR:th 22
theorem
for b1 being Int-Location
for b2 being FinSeq-Location
for b3 being Element of the Instructions of SCM+FSA
st (b3 = b1 :=len b2 or b3 = b2 :=<0,...,0> b1)
holds UsedIntLoc b3 = {b1};
:: SF_MASTR:funcnot 2 => SF_MASTR:func 2
definition
let a1 be finite programmed Element of sproduct the Object-Kind of SCM+FSA;
func UsedIntLoc A1 -> Element of bool Int-Locations means
ex b1 being Function-like quasi_total Relation of the Instructions of SCM+FSA,Fin Int-Locations st
(for b2 being Element of the Instructions of SCM+FSA holds
b1 . b2 = UsedIntLoc b2) &
it = Union (a1 * b1);
end;
:: SF_MASTR:def 2
theorem
for b1 being finite programmed Element of sproduct the Object-Kind of SCM+FSA
for b2 being Element of bool Int-Locations holds
b2 = UsedIntLoc b1
iff
ex b3 being Function-like quasi_total Relation of the Instructions of SCM+FSA,Fin Int-Locations st
(for b4 being Element of the Instructions of SCM+FSA holds
b3 . b4 = UsedIntLoc b4) &
b2 = Union (b1 * b3);
:: SF_MASTR:funcreg 3
registration
let a1 be finite programmed Element of sproduct the Object-Kind of SCM+FSA;
cluster UsedIntLoc a1 -> finite;
end;
:: SF_MASTR:th 23
theorem
for b1 being Element of the Instructions of SCM+FSA
for b2 being finite programmed Element of sproduct the Object-Kind of SCM+FSA
st b1 in proj2 b2
holds UsedIntLoc b1 c= UsedIntLoc b2;
:: SF_MASTR:th 24
theorem
for b1, b2 being finite programmed Element of sproduct the Object-Kind of SCM+FSA holds
UsedIntLoc (b1 +* b2) c= (UsedIntLoc b1) \/ UsedIntLoc b2;
:: SF_MASTR:th 25
theorem
for b1, b2 being finite programmed Element of sproduct the Object-Kind of SCM+FSA
st proj1 b1 misses proj1 b2
holds UsedIntLoc (b1 +* b2) = (UsedIntLoc b1) \/ UsedIntLoc b2;
:: SF_MASTR:th 26
theorem
for b1 being finite programmed Element of sproduct the Object-Kind of SCM+FSA
for b2 being Element of NAT holds
UsedIntLoc b1 = UsedIntLoc Shift(b1,b2);
:: SF_MASTR:th 27
theorem
for b1 being Element of the Instructions of SCM+FSA
for b2 being Element of NAT holds
UsedIntLoc b1 = UsedIntLoc IncAddr(b1,b2);
:: SF_MASTR:th 28
theorem
for b1 being finite programmed Element of sproduct the Object-Kind of SCM+FSA
for b2 being Element of NAT holds
UsedIntLoc b1 = UsedIntLoc IncAddr(b1,b2);
:: SF_MASTR:th 29
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
for b2 being Element of NAT holds
UsedIntLoc b1 = UsedIntLoc ProgramPart Relocated(b1,b2);
:: SF_MASTR:th 30
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA holds
UsedIntLoc b1 = UsedIntLoc Directed b1;
:: SF_MASTR:th 31
theorem
for b1, b2 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA holds
UsedIntLoc (b1 ';' b2) = (UsedIntLoc b1) \/ UsedIntLoc b2;
:: SF_MASTR:th 32
theorem
for b1 being Element of the Instructions of SCM+FSA holds
UsedIntLoc Macro b1 = UsedIntLoc b1;
:: SF_MASTR:th 33
theorem
for b1 being Element of the Instructions of SCM+FSA
for b2 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA holds
UsedIntLoc (b1 ';' b2) = (UsedIntLoc b1) \/ UsedIntLoc b2;
:: SF_MASTR:th 34
theorem
for b1 being Element of the Instructions of SCM+FSA
for b2 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA holds
UsedIntLoc (b2 ';' b1) = (UsedIntLoc b2) \/ UsedIntLoc b1;
:: SF_MASTR:th 35
theorem
for b1, b2 being Element of the Instructions of SCM+FSA holds
UsedIntLoc (b1 ';' b2) = (UsedIntLoc b1) \/ UsedIntLoc b2;
:: SF_MASTR:funcnot 3 => SF_MASTR:func 3
definition
let a1 be Element of the Instructions of SCM+FSA;
func UsedInt*Loc A1 -> Element of Fin FinSeq-Locations means
ex b1, b2 being Int-Location st
ex b3 being FinSeq-Location st
(a1 = b2 :=(b3,b1) or a1 = (b3,b1):= b2) &
it = {b3}
if (InsCode a1 = 9 or InsCode a1 = 10),
ex b1 being Int-Location st
ex b2 being FinSeq-Location st
(a1 = b1 :=len b2 or a1 = b2 :=<0,...,0> b1) & it = {b2}
if (InsCode a1 = 11 or InsCode a1 = 12)
otherwise it = {};
end;
:: SF_MASTR:def 3
theorem
for b1 being Element of the Instructions of SCM+FSA
for b2 being Element of Fin FinSeq-Locations holds
(InsCode b1 <> 9 & InsCode b1 <> 10 or (b2 = UsedInt*Loc b1
iff
ex b3, b4 being Int-Location st
ex b5 being FinSeq-Location st
(b1 = b4 :=(b5,b3) or b1 = (b5,b3):= b4) &
b2 = {b5})) &
(InsCode b1 <> 11 & InsCode b1 <> 12 or (b2 = UsedInt*Loc b1
iff
ex b3 being Int-Location st
ex b4 being FinSeq-Location st
(b1 = b3 :=len b4 or b1 = b4 :=<0,...,0> b3) & b2 = {b4})) &
(InsCode b1 <> 9 & InsCode b1 <> 10 & InsCode b1 <> 11 & InsCode b1 <> 12 implies (b2 = UsedInt*Loc b1
iff
b2 = {}));
:: SF_MASTR:th 36
theorem
for b1, b2 being Int-Location
for b3 being Instruction-Location of SCM+FSA
for b4 being Element of the Instructions of SCM+FSA
st (b4 <> halt SCM+FSA & b4 <> b1 := b2 & b4 <> AddTo(b1,b2) & b4 <> SubFrom(b1,b2) & b4 <> MultBy(b1,b2) & b4 <> Divide(b1,b2) & b4 <> goto b3 & b4 <> b1 =0_goto b3 implies b4 = b1 >0_goto b3)
holds UsedInt*Loc b4 = {};
:: SF_MASTR:th 37
theorem
for b1, b2 being Int-Location
for b3 being FinSeq-Location
for b4 being Element of the Instructions of SCM+FSA
st (b4 = b1 :=(b3,b2) or b4 = (b3,b2):= b1)
holds UsedInt*Loc b4 = {b3};
:: SF_MASTR:th 38
theorem
for b1 being Int-Location
for b2 being FinSeq-Location
for b3 being Element of the Instructions of SCM+FSA
st (b3 = b1 :=len b2 or b3 = b2 :=<0,...,0> b1)
holds UsedInt*Loc b3 = {b2};
:: SF_MASTR:funcnot 4 => SF_MASTR:func 4
definition
let a1 be finite programmed Element of sproduct the Object-Kind of SCM+FSA;
func UsedInt*Loc A1 -> Element of bool FinSeq-Locations means
ex b1 being Function-like quasi_total Relation of the Instructions of SCM+FSA,Fin FinSeq-Locations st
(for b2 being Element of the Instructions of SCM+FSA holds
b1 . b2 = UsedInt*Loc b2) &
it = Union (a1 * b1);
end;
:: SF_MASTR:def 4
theorem
for b1 being finite programmed Element of sproduct the Object-Kind of SCM+FSA
for b2 being Element of bool FinSeq-Locations holds
b2 = UsedInt*Loc b1
iff
ex b3 being Function-like quasi_total Relation of the Instructions of SCM+FSA,Fin FinSeq-Locations st
(for b4 being Element of the Instructions of SCM+FSA holds
b3 . b4 = UsedInt*Loc b4) &
b2 = Union (b1 * b3);
:: SF_MASTR:funcreg 4
registration
let a1 be finite programmed Element of sproduct the Object-Kind of SCM+FSA;
cluster UsedInt*Loc a1 -> finite;
end;
:: SF_MASTR:th 39
theorem
for b1 being Element of the Instructions of SCM+FSA
for b2 being finite programmed Element of sproduct the Object-Kind of SCM+FSA
st b1 in proj2 b2
holds UsedInt*Loc b1 c= UsedInt*Loc b2;
:: SF_MASTR:th 40
theorem
for b1, b2 being finite programmed Element of sproduct the Object-Kind of SCM+FSA holds
UsedInt*Loc (b1 +* b2) c= (UsedInt*Loc b1) \/ UsedInt*Loc b2;
:: SF_MASTR:th 41
theorem
for b1, b2 being finite programmed Element of sproduct the Object-Kind of SCM+FSA
st proj1 b1 misses proj1 b2
holds UsedInt*Loc (b1 +* b2) = (UsedInt*Loc b1) \/ UsedInt*Loc b2;
:: SF_MASTR:th 42
theorem
for b1 being finite programmed Element of sproduct the Object-Kind of SCM+FSA
for b2 being Element of NAT holds
UsedInt*Loc b1 = UsedInt*Loc Shift(b1,b2);
:: SF_MASTR:th 43
theorem
for b1 being Element of the Instructions of SCM+FSA
for b2 being Element of NAT holds
UsedInt*Loc b1 = UsedInt*Loc IncAddr(b1,b2);
:: SF_MASTR:th 44
theorem
for b1 being finite programmed Element of sproduct the Object-Kind of SCM+FSA
for b2 being Element of NAT holds
UsedInt*Loc b1 = UsedInt*Loc IncAddr(b1,b2);
:: SF_MASTR:th 45
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
for b2 being Element of NAT holds
UsedInt*Loc b1 = UsedInt*Loc ProgramPart Relocated(b1,b2);
:: SF_MASTR:th 46
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA holds
UsedInt*Loc b1 = UsedInt*Loc Directed b1;
:: SF_MASTR:th 47
theorem
for b1, b2 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA holds
UsedInt*Loc (b1 ';' b2) = (UsedInt*Loc b1) \/ UsedInt*Loc b2;
:: SF_MASTR:th 48
theorem
for b1 being Element of the Instructions of SCM+FSA holds
UsedInt*Loc Macro b1 = UsedInt*Loc b1;
:: SF_MASTR:th 49
theorem
for b1 being Element of the Instructions of SCM+FSA
for b2 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA holds
UsedInt*Loc (b1 ';' b2) = (UsedInt*Loc b1) \/ UsedInt*Loc b2;
:: SF_MASTR:th 50
theorem
for b1 being Element of the Instructions of SCM+FSA
for b2 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA holds
UsedInt*Loc (b2 ';' b1) = (UsedInt*Loc b2) \/ UsedInt*Loc b1;
:: SF_MASTR:th 51
theorem
for b1, b2 being Element of the Instructions of SCM+FSA holds
UsedInt*Loc (b1 ';' b2) = (UsedInt*Loc b1) \/ UsedInt*Loc b2;
:: SF_MASTR:attrnot 1 => SF_MASTR:attr 1
definition
let a1 be Int-Location;
attr a1 is read-only means
a1 = intloc 0;
end;
:: SF_MASTR:dfs 5
definiens
let a1 be Int-Location;
To prove
a1 is read-only
it is sufficient to prove
thus a1 = intloc 0;
:: SF_MASTR:def 5
theorem
for b1 being Int-Location holds
b1 is read-only
iff
b1 = intloc 0;
:: SF_MASTR:attrnot 2 => SF_MASTR:attr 1
notation
let a1 be Int-Location;
antonym read-write for read-only;
end;
:: SF_MASTR:funcreg 5
registration
cluster intloc 0 -> read-only;
end;
:: SF_MASTR:exreg 1
registration
cluster read-write Int-Location;
end;
:: SF_MASTR:funcnot 5 => SF_MASTR:func 5
definition
let a1 be finite Element of bool Int-Locations;
func FirstNotIn A1 -> Int-Location means
ex b1 being non empty Element of bool NAT st
it = intloc min b1 &
b1 = {b2 where b2 is Element of NAT: not intloc b2 in a1};
end;
:: SF_MASTR:def 6
theorem
for b1 being finite Element of bool Int-Locations
for b2 being Int-Location holds
b2 = FirstNotIn b1
iff
ex b3 being non empty Element of bool NAT st
b2 = intloc min b3 &
b3 = {b4 where b4 is Element of NAT: not intloc b4 in b1};
:: SF_MASTR:th 52
theorem
for b1 being finite Element of bool Int-Locations holds
not FirstNotIn b1 in b1;
:: SF_MASTR:th 53
theorem
for b1, b2 being Element of NAT
for b3 being finite Element of bool Int-Locations
st FirstNotIn b3 = intloc b1 & not intloc b2 in b3
holds b1 <= b2;
:: SF_MASTR:funcnot 6 => SF_MASTR:func 6
definition
let a1 be finite programmed Element of sproduct the Object-Kind of SCM+FSA;
func FirstNotUsed A1 -> Int-Location means
ex b1 being finite Element of bool Int-Locations st
b1 = (UsedIntLoc a1) \/ {intloc 0} &
it = FirstNotIn b1;
end;
:: SF_MASTR:def 7
theorem
for b1 being finite programmed Element of sproduct the Object-Kind of SCM+FSA
for b2 being Int-Location holds
b2 = FirstNotUsed b1
iff
ex b3 being finite Element of bool Int-Locations st
b3 = (UsedIntLoc b1) \/ {intloc 0} &
b2 = FirstNotIn b3;
:: SF_MASTR:funcreg 6
registration
let a1 be finite programmed Element of sproduct the Object-Kind of SCM+FSA;
cluster FirstNotUsed a1 -> read-write;
end;
:: SF_MASTR:th 54
theorem
for b1 being finite programmed Element of sproduct the Object-Kind of SCM+FSA holds
not FirstNotUsed b1 in UsedIntLoc b1;
:: SF_MASTR:th 55
theorem
for b1, b2 being Int-Location
for b3 being finite programmed Element of sproduct the Object-Kind of SCM+FSA
st (not b1 := b2 in proj2 b3 & not AddTo(b1,b2) in proj2 b3 & not SubFrom(b1,b2) in proj2 b3 & not MultBy(b1,b2) in proj2 b3 implies Divide(b1,b2) in proj2 b3)
holds FirstNotUsed b3 <> b1 & FirstNotUsed b3 <> b2;
:: SF_MASTR:th 56
theorem
for b1 being Int-Location
for b2 being Instruction-Location of SCM+FSA
for b3 being finite programmed Element of sproduct the Object-Kind of SCM+FSA
st (b1 =0_goto b2 in proj2 b3 or b1 >0_goto b2 in proj2 b3)
holds FirstNotUsed b3 <> b1;
:: SF_MASTR:th 57
theorem
for b1, b2 being Int-Location
for b3 being FinSeq-Location
for b4 being finite programmed Element of sproduct the Object-Kind of SCM+FSA
st (b1 :=(b3,b2) in proj2 b4 or (b3,b2):= b1 in proj2 b4)
holds FirstNotUsed b4 <> b2 & FirstNotUsed b4 <> b1;
:: SF_MASTR:th 58
theorem
for b1 being Int-Location
for b2 being FinSeq-Location
for b3 being finite programmed Element of sproduct the Object-Kind of SCM+FSA
st (b1 :=len b2 in proj2 b3 or b2 :=<0,...,0> b1 in proj2 b3)
holds FirstNotUsed b3 <> b1;
:: SF_MASTR:funcnot 7 => SF_MASTR:func 7
definition
let a1 be finite Element of bool FinSeq-Locations;
func First*NotIn A1 -> FinSeq-Location means
ex b1 being non empty Element of bool NAT st
it = fsloc min b1 &
b1 = {b2 where b2 is Element of NAT: not fsloc b2 in a1};
end;
:: SF_MASTR:def 8
theorem
for b1 being finite Element of bool FinSeq-Locations
for b2 being FinSeq-Location holds
b2 = First*NotIn b1
iff
ex b3 being non empty Element of bool NAT st
b2 = fsloc min b3 &
b3 = {b4 where b4 is Element of NAT: not fsloc b4 in b1};
:: SF_MASTR:th 59
theorem
for b1 being finite Element of bool FinSeq-Locations holds
not First*NotIn b1 in b1;
:: SF_MASTR:th 60
theorem
for b1, b2 being Element of NAT
for b3 being finite Element of bool FinSeq-Locations
st First*NotIn b3 = fsloc b1 & not fsloc b2 in b3
holds b1 <= b2;
:: SF_MASTR:funcnot 8 => SF_MASTR:func 8
definition
let a1 be finite programmed Element of sproduct the Object-Kind of SCM+FSA;
func First*NotUsed A1 -> FinSeq-Location means
ex b1 being finite Element of bool FinSeq-Locations st
b1 = UsedInt*Loc a1 & it = First*NotIn b1;
end;
:: SF_MASTR:def 9
theorem
for b1 being finite programmed Element of sproduct the Object-Kind of SCM+FSA
for b2 being FinSeq-Location holds
b2 = First*NotUsed b1
iff
ex b3 being finite Element of bool FinSeq-Locations st
b3 = UsedInt*Loc b1 & b2 = First*NotIn b3;
:: SF_MASTR:th 61
theorem
for b1 being finite programmed Element of sproduct the Object-Kind of SCM+FSA holds
not First*NotUsed b1 in UsedInt*Loc b1;
:: SF_MASTR:th 62
theorem
for b1, b2 being Int-Location
for b3 being FinSeq-Location
for b4 being finite programmed Element of sproduct the Object-Kind of SCM+FSA
st (b1 :=(b3,b2) in proj2 b4 or (b3,b2):= b1 in proj2 b4)
holds First*NotUsed b4 <> b3;
:: SF_MASTR:th 63
theorem
for b1 being Int-Location
for b2 being FinSeq-Location
for b3 being finite programmed Element of sproduct the Object-Kind of SCM+FSA
st (b1 :=len b2 in proj2 b3 or b2 :=<0,...,0> b1 in proj2 b3)
holds First*NotUsed b3 <> b2;
:: SF_MASTR:th 64
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
for b2 being Element of NAT holds
proj1 b1 misses proj1 Start-At insloc b2;
:: SF_MASTR:th 65
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
for b2 being Element of NAT holds
IC SCM+FSA in proj1 (b1 +* Start-At insloc b2);
:: SF_MASTR:th 66
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
for b2 being Element of NAT holds
(b1 +* Start-At insloc b2) . IC SCM+FSA = insloc b2;
:: SF_MASTR:th 67
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
for b2 being Element of NAT
for b3 being Element of product the Object-Kind of SCM+FSA
st b1 +* Start-At insloc b2 c= b3
holds IC b3 = insloc b2;
:: SF_MASTR:th 68
theorem
for b1 being Int-Location
for b2 being Element of the Instructions of SCM+FSA
for b3 being Element of product the Object-Kind of SCM+FSA
st not b1 in UsedIntLoc b2
holds (Exec(b2,b3)) . b1 = b3 . b1;
:: SF_MASTR:th 69
theorem
for b1 being Int-Location
for b2 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
for b3 being Element of NAT
for b4 being Element of product the Object-Kind of SCM+FSA
st b2 +* Start-At insloc 0 c= b4 &
(for b5 being Element of NAT
st b5 < b3
holds IC Computation(b4,b5) in proj1 b2) &
not b1 in UsedIntLoc b2
holds (Computation(b4,b3)) . b1 = b4 . b1;
:: SF_MASTR:th 70
theorem
for b1 being FinSeq-Location
for b2 being Element of the Instructions of SCM+FSA
for b3 being Element of product the Object-Kind of SCM+FSA
st not b1 in UsedInt*Loc b2
holds (Exec(b2,b3)) . b1 = b3 . b1;
:: SF_MASTR:th 71
theorem
for b1 being FinSeq-Location
for b2 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
for b3 being Element of NAT
for b4 being Element of product the Object-Kind of SCM+FSA
st b2 +* Start-At insloc 0 c= b4 &
(for b5 being Element of NAT
st b5 < b3
holds IC Computation(b4,b5) in proj1 b2) &
not b1 in UsedInt*Loc b2
holds (Computation(b4,b3)) . b1 = b4 . b1;
:: SF_MASTR:th 72
theorem
for b1 being Element of the Instructions of SCM+FSA
for b2, b3 being Element of product the Object-Kind of SCM+FSA
st b2 | UsedIntLoc b1 = b3 | UsedIntLoc b1 & b2 | UsedInt*Loc b1 = b3 | UsedInt*Loc b1 & IC b2 = IC b3
holds IC Exec(b1,b2) = IC Exec(b1,b3) &
(Exec(b1,b2)) | UsedIntLoc b1 = (Exec(b1,b3)) | UsedIntLoc b1 &
(Exec(b1,b2)) | UsedInt*Loc b1 = (Exec(b1,b3)) | UsedInt*Loc b1;
:: SF_MASTR:th 73
theorem
for b1 being finite programmed initial Element of sproduct the Object-Kind of SCM+FSA
for b2 being Element of NAT
for b3, b4 being Element of product the Object-Kind of SCM+FSA
st b1 +* Start-At insloc 0 c= b3 &
b1 +* Start-At insloc 0 c= b4 &
b3 | UsedIntLoc b1 = b4 | UsedIntLoc b1 &
b3 | UsedInt*Loc b1 = b4 | UsedInt*Loc b1 &
(for b5 being Element of NAT
st b5 < b2
holds IC Computation(b3,b5) in proj1 b1)
holds (for b5 being Element of NAT
st b5 < b2
holds IC Computation(b4,b5) in proj1 b1) &
(for b5 being Element of NAT
st b5 <= b2
holds IC Computation(b3,b5) = IC Computation(b4,b5) &
(for b6 being Int-Location
st b6 in UsedIntLoc b1
holds (Computation(b3,b5)) . b6 = (Computation(b4,b5)) . b6) &
(for b6 being FinSeq-Location
st b6 in UsedInt*Loc b1
holds (Computation(b3,b5)) . b6 = (Computation(b4,b5)) . b6));