:: SCMRING4 semantic presentation

Lemma1: for b1, b2 being set holds
( b2 /\ {b1} <> {} implies b1 in b2 )
proof end;

Lemma2: for b1, b2, b3 being set holds
not b3 in b1 \ ({b3} \/ b2)
proof end;

theorem Th1: :: SCMRING4:1
for b1 being with_non-empty_elements set
for b2 being non empty non void IC-Ins-separated definite standard AMI-Struct of b1 holds NAT ,the Instruction-Locations of b2 are_equipotent
proof end;

registration
let c1 be with_non-empty_elements set ;
let c2 be non empty non void IC-Ins-separated definite standard AMI-Struct of c1;
cluster the Instruction-Locations of a2 -> infinite ;
coherence
not the Instruction-Locations of c2 is finite
proof end;
end;

theorem Th2: :: SCMRING4:2
for b1, b2 being natural number
for b3 being with_non-empty_elements set
for b4 being non empty non void IC-Ins-separated definite standard AMI-Struct of b3 holds (il. b4,b1) + b2 = il. b4,(b1 + b2)
proof end;

definition
let c1 be with_non-empty_elements set ;
let c2 be non empty non void IC-Ins-separated definite standard AMI-Struct of c1;
let c3 be Instruction-Location of c2;
let c4 be natural number ;
func c3 -' c4 -> Instruction-Location of a2 equals :: SCMRING4:def 1
il. a2,((locnum a3) -' a4);
coherence
il. c2,((locnum c3) -' c4) is Instruction-Location of c2
;
end;

:: deftheorem Def1 defines -' SCMRING4:def 1 :
for b1 being with_non-empty_elements set
for b2 being non empty non void IC-Ins-separated definite standard AMI-Struct of b1
for b3 being Instruction-Location of b2
for b4 being natural number holds b3 -' b4 = il. b2,((locnum b3) -' b4);

theorem Th3: :: SCMRING4:3
for b1 being with_non-empty_elements set
for b2 being non empty non void IC-Ins-separated definite standard AMI-Struct of b1
for b3 being Instruction-Location of b2 holds b3 -' 0 = b3
proof end;

theorem Th4: :: SCMRING4:4
for b1 being natural number
for b2 being with_non-empty_elements set
for b3 being non empty non void IC-Ins-separated definite standard AMI-Struct of b2
for b4 being Instruction-Location of b3 holds (locnum b4) -' b1 = locnum (b4 -' b1) by AMISTD_1:def 13;

theorem Th5: :: SCMRING4:5
for b1 being natural number
for b2 being with_non-empty_elements set
for b3 being non empty non void IC-Ins-separated definite standard AMI-Struct of b2
for b4 being Instruction-Location of b3 holds (b4 + b1) -' b1 = b4
proof end;

theorem Th6: :: SCMRING4:6
for b1, b2 being natural number
for b3 being with_non-empty_elements set
for b4 being non empty non void IC-Ins-separated definite standard AMI-Struct of b3 holds (il. b4,b1) -' b2 = il. b4,(b1 -' b2) by AMISTD_1:def 13;

theorem Th7: :: SCMRING4:7
for b1 being with_non-empty_elements set
for b2 being non empty non void IC-Ins-separated definite AMI-Struct of b1
for b3 being FinPartState of b2 holds dom (DataPart b3) c= the carrier of b2 \ ({(IC b2)} \/ the Instruction-Locations of b2)
proof end;

E7: now
let c1 be with_non-empty_elements set ;
let c2 be non empty AMI-Struct of c1;
set c3 = the carrier of c2;
set c4 = the Instruction-Locations of c2;
set c5 = the carrier of c2 \ ({(IC c2)} \/ the Instruction-Locations of c2);
thus the Instruction-Locations of c2 misses the carrier of c2 \ ({(IC c2)} \/ the Instruction-Locations of c2)
proof
assume the Instruction-Locations of c2 meets the carrier of c2 \ ({(IC c2)} \/ the Instruction-Locations of c2) ;
then consider c6 being set such that
E8: c6 in the Instruction-Locations of c2 and
E9: c6 in the carrier of c2 \ ({(IC c2)} \/ the Instruction-Locations of c2) by XBOOLE_0:3;
not c6 in {(IC c2)} \/ the Instruction-Locations of c2 by E9, XBOOLE_0:def 4;
hence not verum by E8, XBOOLE_0:def 2;
end;
end;

Lemma8: for b1, b2, b3 being set holds
( b1 c= b3 & b2 c= b3 \ b1 implies b3 = (b1 \/ (b3 \ (b1 \/ b2))) \/ b2 )
proof end;

Lemma9: for b1 being with_non-empty_elements set
for b2 being non empty non void IC-Ins-separated definite realistic AMI-Struct of b1 holds the Instruction-Locations of b2 c= the carrier of b2 \ {(IC b2)}
proof end;

theorem Th8: :: SCMRING4:8
for b1 being with_non-empty_elements set
for b2 being non empty non void IC-Ins-separated definite realistic AMI-Struct of b1
for b3 being FinPartState of b2 holds
( b3 is data-only iff dom b3 c= the carrier of b2 \ ({(IC b2)} \/ the Instruction-Locations of b2) )
proof end;

theorem Th9: :: SCMRING4:9
for b1 being natural number
for b2 being with_non-empty_elements set
for b3 being non empty non void IC-Ins-separated definite standard AMI-Struct of b2
for b4, b5 being Instruction-Location of b3 holds
( Start-At (b4 + b1) = Start-At (b5 + b1) iff Start-At b4 = Start-At b5 )
proof end;

theorem Th10: :: SCMRING4:10
for b1 being natural number
for b2 being with_non-empty_elements set
for b3 being non empty non void IC-Ins-separated definite standard AMI-Struct of b2
for b4, b5 being Instruction-Location of b3 holds
( Start-At b4 = Start-At b5 implies Start-At (b4 -' b1) = Start-At (b5 -' b1) )
proof end;

theorem Th11: :: SCMRING4:11
for b1 being natural number
for b2 being with_non-empty_elements set
for b3 being non empty non void IC-Ins-separated definite standard AMI-Struct of b2
for b4 being Instruction-Location of b3
for b5 being FinPartState of b3 holds
( b4 in dom b5 implies (Shift b5,b1) . (b4 + b1) = b5 . b4 )
proof end;

theorem Th12: :: SCMRING4:12
for b1 being natural number
for b2 being with_non-empty_elements set
for b3 being non empty non void IC-Ins-separated definite standard AMI-Struct of b2
for b4 being FinPartState of b3 holds dom (Shift b4,b1) = { (b5 + b1) where B is Instruction-Location of b3 : b5 in dom b4 }
proof end;

theorem Th13: :: SCMRING4:13
for b1 being with_non-empty_elements set
for b2 being non empty non void IC-Ins-separated steady-programmed definite realistic Exec-preserving AMI-Struct of b1
for b3 being State of b2
for b4 being Instruction of b2
for b5 being programmed FinPartState of b2 holds Exec b4,(b3 +* b5) = (Exec b4,b3) +* b5
proof end;

theorem Th14: :: SCMRING4:14
for b1 being good Ring holds the carrier of (SCM b1) = ({(IC (SCM b1))} \/ SCM-Data-Loc ) \/ SCM-Instr-Loc
proof end;

theorem Th15: :: SCMRING4:15
for b1 being good Ring
for b2 being Instruction-Location of (SCM b1) holds ObjectKind b2 = SCM-Instr b1
proof end;

theorem Th16: :: SCMRING4:16
for b1 being Nat
for b2 being good Ring holds dl. b2,b1 = (2 * b1) + 1
proof end;

theorem Th17: :: SCMRING4:17
for b1 being natural number
for b2 being good Ring holds il. (SCM b2),b1 = (2 * b1) + 2
proof end;

theorem Th18: :: SCMRING4:18
for b1 being good Ring
for b2 being Data-Location of b1 holds
ex b3 being Nat st b2 = dl. b1,b3
proof end;

theorem Th19: :: SCMRING4:19
for b1 being good Ring
for b2, b3 being Nat holds
not ( b2 <> b3 & not dl. b1,b2 <> dl. b1,b3 )
proof end;

theorem Th20: :: SCMRING4:20
for b1 being good Ring
for b2 being Data-Location of b1
for b3 being Instruction-Location of (SCM b1) holds
b2 <> b3
proof end;

E18: now
let c1 be good Ring;
thus the carrier of SCM = ({(IC (SCM c1))} \/ SCM-Data-Loc ) \/ SCM-Instr-Loc by AMI_3:4, AMI_5:23, SCMRING2:9
.= the carrier of (SCM c1) by Th14 ;
end;

E19: now
let c1 be State of SCM ;
let c2 be good Ring;
let c3 be State of (SCM c2);
thus dom c1 = the carrier of SCM by AMI_3:36
.= the carrier of (SCM c2) by Lemma18
.= dom c3 by AMI_3:36 ;
end;

theorem Th21: :: SCMRING4:21
for b1 being good Ring
for b2 being State of (SCM b1) holds SCM-Data-Loc c= dom b2
proof end;

theorem Th22: :: SCMRING4:22
for b1 being good Ring
for b2 being State of (SCM b1) holds dom (b2 | SCM-Data-Loc ) = SCM-Data-Loc
proof end;

theorem Th23: :: SCMRING4:23
for b1 being good Ring
for b2 being FinPartState of SCM b1
for b3 being FinPartState of SCM holds
( b2 = b3 implies DataPart b2 = DataPart b3 )
proof end;

theorem Th24: :: SCMRING4:24
for b1 being good Ring
for b2 being FinPartState of SCM b1 holds DataPart b2 = b2 | SCM-Data-Loc
proof end;

theorem Th25: :: SCMRING4:25
for b1 being good Ring
for b2 being FinPartState of SCM b1 holds
( b2 is data-only iff dom b2 c= SCM-Data-Loc )
proof end;

theorem Th26: :: SCMRING4:26
for b1 being good Ring
for b2 being FinPartState of SCM b1 holds dom (DataPart b2) c= SCM-Data-Loc
proof end;

theorem Th27: :: SCMRING4:27
for b1 being good Ring
for b2 being State of (SCM b1) holds SCM-Instr-Loc c= dom b2
proof end;

theorem Th28: :: SCMRING4:28
for b1 being good Ring
for b2 being FinPartState of SCM b1
for b3 being FinPartState of SCM holds
( b2 = b3 implies ProgramPart b2 = ProgramPart b3 )
proof end;

theorem Th29: :: SCMRING4:29
for b1 being good Ring
for b2 being FinPartState of SCM b1 holds dom (ProgramPart b2) c= SCM-Instr-Loc
proof end;

registration
let c1 be good Ring;
let c2 be Element of the Instructions of (SCM c1);
cluster InsCode a2 -> natural ;
coherence
InsCode c2 is natural
proof end;
end;

theorem Th30: :: SCMRING4:30
for b1 being good Ring
for b2 being Instruction of (SCM b1) holds InsCode b2 <= 7
proof end;

theorem Th31: :: SCMRING4:31
for b1 being natural number
for b2 being good Ring
for b3 being Instruction-Location of (SCM b2) holds IncAddr (goto b3),b1 = goto (b3 + b1)
proof end;

theorem Th32: :: SCMRING4:32
for b1 being natural number
for b2 being good Ring
for b3 being Data-Location of b2
for b4 being Instruction-Location of (SCM b2) holds IncAddr (b3 =0_goto b4),b1 = b3 =0_goto (b4 + b1)
proof end;

theorem Th33: :: SCMRING4:33
for b1 being good Ring
for b2 being Data-Location of b1
for b3 being Instruction-Location of (SCM b1)
for b4 being State of (SCM b1) holds b4 . b2 = (b4 +* (Start-At b3)) . b2
proof end;

theorem Th34: :: SCMRING4:34
for b1 being good Ring
for b2, b3 being State of (SCM b1) holds
( IC b2 = IC b3 & ( for b4 being Data-Location of b1 holds b2 . b4 = b3 . b4 ) & ( for b4 being Instruction-Location of (SCM b1) holds b2 . b4 = b3 . b4 ) implies b2 = b3 )
proof end;

theorem Th35: :: SCMRING4:35
for b1 being natural number
for b2 being good Ring
for b3 being State of (SCM b2) holds Exec (IncAddr (CurInstr b3),b1),(b3 +* (Start-At ((IC b3) + b1))) = (Following b3) +* (Start-At ((IC (Following b3)) + b1))
proof end;

theorem Th36: :: SCMRING4:36
for b1, b2 being natural number
for b3 being good Ring
for b4 being Instruction of (SCM b3)
for b5 being State of (SCM b3) holds
( IC b5 = il. (SCM b3),(b1 + b2) implies Exec b4,(b5 +* (Start-At ((IC b5) -' b2))) = (Exec (IncAddr b4,b2),b5) +* (Start-At ((IC (Exec (IncAddr b4,b2),b5)) -' b2)) )
proof end;

registration
let c1 be good Ring;
cluster autonomic non programmed FinPartState of SCM a1;
existence
ex b1 being FinPartState of SCM c1 st
( b1 is autonomic & not b1 is programmed )
proof end;
end;

definition
let c1 be good Ring;
let c2 be Data-Location of c1;
let c3 be Element of c1;
redefine func .--> as c2 .--> c3 -> FinPartState of SCM a1;
coherence
c2 .--> c3 is FinPartState of SCM c1
proof end;
end;

theorem Th37: :: SCMRING4:37
for b1 being good Ring holds
( not b1 is trivial implies for b2 being autonomic FinPartState of SCM b1 holds
( DataPart b2 <> {} implies IC (SCM b1) in dom b2 ) )
proof end;

theorem Th38: :: SCMRING4:38
for b1 being good Ring holds
( not b1 is trivial implies for b2 being autonomic non programmed FinPartState of SCM b1 holds IC (SCM b1) in dom b2 )
proof end;

theorem Th39: :: SCMRING4:39
for b1 being good Ring
for b2 being autonomic FinPartState of SCM b1 holds
( IC (SCM b1) in dom b2 implies IC b2 in dom b2 )
proof end;

theorem Th40: :: SCMRING4:40
for b1 being Nat
for b2 being good Ring
for b3 being State of (SCM b2) holds
( not b2 is trivial implies for b4 being autonomic non programmed FinPartState of SCM b2 holds
( b4 c= b3 implies IC ((Computation b3) . b1) in dom (ProgramPart b4) ) )
proof end;

theorem Th41: :: SCMRING4:41
for b1 being Nat
for b2 being good Ring
for b3, b4 being State of (SCM b2) holds
( not b2 is trivial implies for b5 being autonomic non programmed FinPartState of SCM b2 holds
( b5 c= b3 & b5 c= b4 implies ( IC ((Computation b3) . b1) = IC ((Computation b4) . b1) & CurInstr ((Computation b3) . b1) = CurInstr ((Computation b4) . b1) ) ) )
proof end;

theorem Th42: :: SCMRING4:42
for b1 being Nat
for b2 being good Ring
for b3, b4 being Data-Location of b2
for b5, b6 being State of (SCM b2) holds
( not b2 is trivial implies for b7 being autonomic non programmed FinPartState of SCM b2 holds
( b7 c= b5 & b7 c= b6 & CurInstr ((Computation b5) . b1) = b3 := b4 & b3 in dom b7 implies ((Computation b5) . b1) . b4 = ((Computation b6) . b1) . b4 ) )
proof end;

theorem Th43: :: SCMRING4:43
for b1 being Nat
for b2 being good Ring
for b3, b4 being Data-Location of b2
for b5, b6 being State of (SCM b2) holds
( not b2 is trivial implies for b7 being autonomic non programmed FinPartState of SCM b2 holds
( b7 c= b5 & b7 c= b6 & CurInstr ((Computation b5) . b1) = AddTo b3,b4 & b3 in dom b7 implies (((Computation b5) . b1) . b3) + (((Computation b5) . b1) . b4) = (((Computation b6) . b1) . b3) + (((Computation b6) . b1) . b4) ) )
proof end;

theorem Th44: :: SCMRING4:44
for b1 being Nat
for b2 being good Ring
for b3, b4 being Data-Location of b2
for b5, b6 being State of (SCM b2) holds
( not b2 is trivial implies for b7 being autonomic non programmed FinPartState of SCM b2 holds
( b7 c= b5 & b7 c= b6 & CurInstr ((Computation b5) . b1) = SubFrom b3,b4 & b3 in dom b7 implies (((Computation b5) . b1) . b3) - (((Computation b5) . b1) . b4) = (((Computation b6) . b1) . b3) - (((Computation b6) . b1) . b4) ) )
proof end;

theorem Th45: :: SCMRING4:45
for b1 being Nat
for b2 being good Ring
for b3, b4 being Data-Location of b2
for b5, b6 being State of (SCM b2) holds
( not b2 is trivial implies for b7 being autonomic non programmed FinPartState of SCM b2 holds
( b7 c= b5 & b7 c= b6 & CurInstr ((Computation b5) . b1) = MultBy b3,b4 & b3 in dom b7 implies (((Computation b5) . b1) . b3) * (((Computation b5) . b1) . b4) = (((Computation b6) . b1) . b3) * (((Computation b6) . b1) . b4) ) )
proof end;

theorem Th46: :: SCMRING4:46
for b1 being Nat
for b2 being good Ring
for b3 being Data-Location of b2
for b4 being Instruction-Location of (SCM b2)
for b5, b6 being State of (SCM b2) holds
( not b2 is trivial implies for b7 being autonomic non programmed FinPartState of SCM b2 holds
( b7 c= b5 & b7 c= b6 & CurInstr ((Computation b5) . b1) = b3 =0_goto b4 & b4 <> Next (IC ((Computation b5) . b1)) implies ( ((Computation b5) . b1) . b3 = 0. b2 iff ((Computation b6) . b1) . b3 = 0. b2 ) ) )
proof end;

definition
let c1 be with_non-empty_elements set ;
let c2 be non empty non void IC-Ins-separated definite standard regular AMI-Struct of c1;
let c3 be natural number ;
let c4 be FinPartState of c2;
func Relocated c4,c3 -> FinPartState of a2 equals :: SCMRING4:def 2
((Start-At ((IC a4) + a3)) +* (IncAddr (Shift (ProgramPart a4),a3),a3)) +* (DataPart a4);
coherence
((Start-At ((IC c4) + c3)) +* (IncAddr (Shift (ProgramPart c4),c3),c3)) +* (DataPart c4) is FinPartState of c2
;
end;

:: deftheorem Def2 defines Relocated SCMRING4:def 2 :
for b1 being with_non-empty_elements set
for b2 being non empty non void IC-Ins-separated definite standard regular AMI-Struct of b1
for b3 being natural number
for b4 being FinPartState of b2 holds Relocated b4,b3 = ((Start-At ((IC b4) + b3)) +* (IncAddr (Shift (ProgramPart b4),b3),b3)) +* (DataPart b4);

theorem Th47: :: SCMRING4:47
for b1 being natural number
for b2 being with_non-empty_elements set
for b3 being non empty non void IC-Ins-separated definite standard regular AMI-Struct of b2
for b4 being FinPartState of b3 holds DataPart (Relocated b4,b1) = DataPart b4
proof end;

theorem Th48: :: SCMRING4:48
for b1 being natural number
for b2 being with_non-empty_elements set
for b3 being non empty non void IC-Ins-separated definite standard regular AMI-Struct of b2
for b4 being FinPartState of b3 holds
( b3 is realistic implies ProgramPart (Relocated b4,b1) = IncAddr (Shift (ProgramPart b4),b1),b1 )
proof end;

theorem Th49: :: SCMRING4:49
for b1 being natural number
for b2 being with_non-empty_elements set
for b3 being non empty non void IC-Ins-separated definite standard regular AMI-Struct of b2
for b4 being FinPartState of b3 holds
( b3 is realistic implies dom (ProgramPart (Relocated b4,b1)) = { (il. b3,(b5 + b1)) where B is Nat : il. b3,b5 in dom (ProgramPart b4) } )
proof end;

theorem Th50: :: SCMRING4:50
for b1 being natural number
for b2 being with_non-empty_elements set
for b3 being non empty non void IC-Ins-separated definite standard regular AMI-Struct of b2
for b4 being FinPartState of b3
for b5 being Instruction-Location of b3 holds
( b3 is realistic implies ( b5 in dom b4 iff b5 + b1 in dom (Relocated b4,b1) ) )
proof end;

theorem Th51: :: SCMRING4:51
for b1 being natural number
for b2 being with_non-empty_elements set
for b3 being non empty non void IC-Ins-separated definite standard regular AMI-Struct of b2
for b4 being FinPartState of b3 holds IC b3 in dom (Relocated b4,b1)
proof end;

theorem Th52: :: SCMRING4:52
for b1 being natural number
for b2 being with_non-empty_elements set
for b3 being non empty non void IC-Ins-separated definite standard regular AMI-Struct of b2
for b4 being FinPartState of b3 holds
( b3 is realistic implies IC (Relocated b4,b1) = (IC b4) + b1 )
proof end;

theorem Th53: :: SCMRING4:53
for b1 being natural number
for b2 being with_non-empty_elements set
for b3 being non empty non void IC-Ins-separated definite standard regular AMI-Struct of b2
for b4 being programmed FinPartState of b3
for b5 being Instruction-Location of b3 holds
( b5 in dom b4 implies (IncAddr b4,b1) . b5 = IncAddr (pi b4,b5),b1 )
proof end;

theorem Th54: :: SCMRING4:54
for b1 being natural number
for b2 being with_non-empty_elements set
for b3 being non empty non void IC-Ins-separated definite standard regular AMI-Struct of b2
for b4 being programmed FinPartState of b3 holds Shift (IncAddr b4,b1),b1 = IncAddr (Shift b4,b1),b1
proof end;

theorem Th55: :: SCMRING4:55
for b1 being natural number
for b2 being with_non-empty_elements set
for b3 being non empty non void IC-Ins-separated definite standard regular AMI-Struct of b2
for b4 being FinPartState of b3
for b5 being Instruction-Location of b3 holds
( b3 is realistic implies for b6 being Instruction of b3 holds
( b5 in dom (ProgramPart b4) & b6 = b4 . b5 implies IncAddr b6,b1 = (Relocated b4,b1) . (b5 + b1) ) )
proof end;

theorem Th56: :: SCMRING4:56
for b1 being natural number
for b2 being with_non-empty_elements set
for b3 being non empty non void IC-Ins-separated definite standard regular AMI-Struct of b2
for b4 being FinPartState of b3 holds
( b3 is realistic implies Start-At ((IC b4) + b1) c= Relocated b4,b1 )
proof end;

theorem Th57: :: SCMRING4:57
for b1 being natural number
for b2 being with_non-empty_elements set
for b3 being non empty non void IC-Ins-separated definite standard regular AMI-Struct of b2
for b4 being FinPartState of b3 holds
( b3 is realistic implies for b5 being data-only FinPartState of b3 holds
( IC b3 in dom b4 implies Relocated (b4 +* b5),b1 = (Relocated b4,b1) +* b5 ) )
proof end;

theorem Th58: :: SCMRING4:58
for b1 being natural number
for b2 being good Ring
for b3, b4 being State of (SCM b2)
for b5 being autonomic FinPartState of SCM b2 holds
( b5 c= b3 & Relocated b5,b1 c= b4 implies b5 c= b3 +* (b4 | SCM-Data-Loc ) )
proof end;

theorem Th59: :: SCMRING4:59
for b1 being natural number
for b2 being good Ring
for b3, b4, b5 being State of (SCM b2) holds
( not b2 is trivial implies for b6 being autonomic FinPartState of SCM b2 holds
( IC (SCM b2) in dom b6 & b6 c= b3 & Relocated b6,b1 c= b4 & b5 = b3 +* (b4 | SCM-Data-Loc ) implies for b7 being Nat holds
( (IC ((Computation b3) . b7)) + b1 = IC ((Computation b4) . b7) & IncAddr (CurInstr ((Computation b3) . b7)),b1 = CurInstr ((Computation b4) . b7) & ((Computation b3) . b7) | (dom (DataPart b6)) = ((Computation b4) . b7) | (dom (DataPart (Relocated b6,b1))) & ((Computation b5) . b7) | SCM-Data-Loc = ((Computation b4) . b7) | SCM-Data-Loc ) ) )
proof end;

theorem Th60: :: SCMRING4:60
for b1 being natural number
for b2 being good Ring holds
( not b2 is trivial implies for b3 being autonomic FinPartState of SCM b2 holds
( IC (SCM b2) in dom b3 implies ( b3 is halting iff Relocated b3,b1 is halting ) ) )
proof end;

theorem Th61: :: SCMRING4:61
for b1 being natural number
for b2 being good Ring
for b3 being State of (SCM b2) holds
( not b2 is trivial implies for b4 being autonomic FinPartState of SCM b2 holds
( IC (SCM b2) in dom b4 & b4 c= b3 implies for b5 being Nat holds (Computation (b3 +* (Relocated b4,b1))) . b5 = (((Computation b3) . b5) +* (Start-At ((IC ((Computation b3) . b5)) + b1))) +* (ProgramPart (Relocated b4,b1)) ) )
proof end;

theorem Th62: :: SCMRING4:62
for b1 being natural number
for b2 being good Ring
for b3 being State of (SCM b2) holds
( not b2 is trivial implies for b4 being autonomic FinPartState of SCM b2 holds
( IC (SCM b2) in dom b4 & Relocated b4,b1 c= b3 implies for b5 being Nat holds (Computation b3) . b5 = ((((Computation (b3 +* b4)) . b5) +* (Start-At ((IC ((Computation (b3 +* b4)) . b5)) + b1))) +* (b3 | (dom (ProgramPart b4)))) +* (ProgramPart (Relocated b4,b1)) ) )
proof end;

theorem Th63: :: SCMRING4:63
for b1 being natural number
for b2 being good Ring
for b3 being FinPartState of SCM b2
for b4 being State of (SCM b2) holds
( not b2 is trivial & IC (SCM b2) in dom b3 & b3 c= b4 & Relocated b3,b1 is autonomic implies for b5 being Nat holds (Computation b4) . b5 = ((((Computation (b4 +* (Relocated b3,b1))) . b5) +* (Start-At ((IC ((Computation (b4 +* (Relocated b3,b1))) . b5)) -' b1))) +* (b4 | (dom (ProgramPart (Relocated b3,b1))))) +* (ProgramPart b3) )
proof end;

theorem Th64: :: SCMRING4:64
for b1 being natural number
for b2 being good Ring
for b3 being FinPartState of SCM b2 holds
( not b2 is trivial & IC (SCM b2) in dom b3 implies ( b3 is autonomic iff Relocated b3,b1 is autonomic ) )
proof end;

theorem Th65: :: SCMRING4:65
for b1 being natural number
for b2 being good Ring holds
( not b2 is trivial implies for b3 being autonomic halting FinPartState of SCM b2 holds
( IC (SCM b2) in dom b3 implies DataPart (Result b3) = DataPart (Result (Relocated b3,b1)) ) )
proof end;

theorem Th66: :: SCMRING4:66
for b1 being natural number
for b2 being good Ring
for b3 being FinPartState of SCM b2 holds
( not b2 is trivial implies for b4 being PartFunc of FinPartSt (SCM b2), FinPartSt (SCM b2) holds
( IC (SCM b2) in dom b3 & b4 is data-only implies ( b3 computes b4 iff Relocated b3,b1 computes b4 ) ) )
proof end;