Article IDEA_1, MML version 4.99.1005
:: IDEA_1:th 1
theorem
for b1, b2, b3 being Element of NAT
st b2 is prime & b1 < b2 & b3 < b2 & b1 <> 0
holds ex b4 being Element of NAT st
(b4 * b1) mod b2 = b3 & b4 < b2;
:: IDEA_1:th 2
theorem
for b1, b2, b3 being Element of NAT
st b1 <> 0 & b2 mod b1 = b3 mod b1 & b2 <= b3
holds ex b4 being Element of NAT st
b3 - b2 = b1 * b4;
:: IDEA_1:th 3
theorem
for b1, b2 being Element of NAT holds
b1 - b2 <= b1;
:: IDEA_1:th 4
theorem
for b1, b2, b3 being Element of NAT
st b2 <= b3
holds b2 - b1 <= b3;
:: IDEA_1:th 5
theorem
for b1, b2, b3 being Element of NAT
st 0 < b1 & 0 < b2 & b1 < b3 & b2 < b3 & b3 is prime
holds (b1 * b2) mod b3 <> 0;
:: IDEA_1:funcnot 1 => IDEA_1:func 1
definition
let a1 be Element of NAT;
func ZERO A1 -> Element of a1 -tuples_on BOOLEAN equals
a1 |-> FALSE;
end;
:: IDEA_1:def 1
theorem
for b1 being Element of NAT holds
ZERO b1 = b1 |-> FALSE;
:: IDEA_1:funcnot 2 => IDEA_1:func 2
definition
let a1 be Element of NAT;
let a2, a3 be Element of a1 -tuples_on BOOLEAN;
func A2 'xor' A3 -> Element of a1 -tuples_on BOOLEAN means
for b1 being Element of NAT
st b1 in Seg a1
holds it /. b1 = (a2 /. b1) 'xor' (a3 /. b1);
end;
:: IDEA_1:def 2
theorem
for b1 being Element of NAT
for b2, b3, b4 being Element of b1 -tuples_on BOOLEAN holds
b4 = b2 'xor' b3
iff
for b5 being Element of NAT
st b5 in Seg b1
holds b4 /. b5 = (b2 /. b5) 'xor' (b3 /. b5);
:: IDEA_1:th 7
theorem
for b1 being Element of NAT
for b2 being Element of b1 -tuples_on BOOLEAN holds
b2 'xor' b2 = ZERO b1;
:: IDEA_1:th 8
theorem
for b1 being Element of NAT
for b2, b3 being Element of b1 -tuples_on BOOLEAN holds
b2 'xor' b3 = b3 'xor' b2;
:: IDEA_1:funcnot 3 => IDEA_1:func 3
definition
let a1 be Element of NAT;
let a2, a3 be Element of a1 -tuples_on BOOLEAN;
redefine func a2 'xor' a3 -> Element of a1 -tuples_on BOOLEAN;
commutativity;
:: for a1 being Element of NAT
:: for a2, a3 being Element of a1 -tuples_on BOOLEAN holds
:: a2 'xor' a3 = a3 'xor' a2;
end;
:: IDEA_1:th 9
theorem
for b1 being Element of NAT
for b2 being Element of b1 -tuples_on BOOLEAN holds
(ZERO b1) 'xor' b2 = b2;
:: IDEA_1:th 10
theorem
for b1 being Element of NAT
for b2, b3, b4 being Element of b1 -tuples_on BOOLEAN holds
(b2 'xor' b3) 'xor' b4 = b2 'xor' (b3 'xor' b4);
:: IDEA_1:prednot 1 => IDEA_1:pred 1
definition
let a1, a2 be Element of NAT;
pred A2 is_expressible_by A1 means
a2 < 2 to_power a1;
end;
:: IDEA_1:dfs 3
definiens
let a1, a2 be Element of NAT;
To prove
a2 is_expressible_by a1
it is sufficient to prove
thus a2 < 2 to_power a1;
:: IDEA_1:def 3
theorem
for b1, b2 being Element of NAT holds
b2 is_expressible_by b1
iff
b2 < 2 to_power b1;
:: IDEA_1:th 11
theorem
for b1 being Element of NAT holds
b1 -BinarySequence 0 = ZERO b1;
:: IDEA_1:funcnot 4 => IDEA_1:func 4
definition
let a1, a2, a3 be Element of NAT;
func ADD_MOD(A2,A3,A1) -> Element of NAT equals
(a2 + a3) mod (2 to_power a1);
end;
:: IDEA_1:def 4
theorem
for b1, b2, b3 being Element of NAT holds
ADD_MOD(b2,b3,b1) = (b2 + b3) mod (2 to_power b1);
:: IDEA_1:funcnot 5 => IDEA_1:func 5
definition
let a1, a2 be Element of NAT;
assume a2 is_expressible_by a1;
func NEG_N(A2,A1) -> Element of NAT equals
(2 to_power a1) - a2;
end;
:: IDEA_1:def 5
theorem
for b1, b2 being Element of NAT
st b2 is_expressible_by b1
holds NEG_N(b2,b1) = (2 to_power b1) - b2;
:: IDEA_1:funcnot 6 => IDEA_1:func 6
definition
let a1, a2 be Element of NAT;
func NEG_MOD(A2,A1) -> Element of NAT equals
(NEG_N(a2,a1)) mod (2 to_power a1);
end;
:: IDEA_1:def 6
theorem
for b1, b2 being Element of NAT holds
NEG_MOD(b2,b1) = (NEG_N(b2,b1)) mod (2 to_power b1);
:: IDEA_1:th 12
theorem
for b1, b2 being Element of NAT
st b1 is_expressible_by b2
holds ADD_MOD(b1,NEG_MOD(b1,b2),b2) = 0;
:: IDEA_1:th 13
theorem
for b1, b2, b3 being Element of NAT holds
ADD_MOD(b1,b2,b3) = ADD_MOD(b2,b1,b3);
:: IDEA_1:th 14
theorem
for b1, b2 being Element of NAT
st b1 is_expressible_by b2
holds ADD_MOD(0,b1,b2) = b1;
:: IDEA_1:th 15
theorem
for b1, b2, b3, b4 being Element of NAT holds
ADD_MOD(ADD_MOD(b1,b2,b3),b4,b3) = ADD_MOD(b1,ADD_MOD(b2,b4,b3),b3);
:: IDEA_1:th 16
theorem
for b1, b2, b3 being Element of NAT holds
ADD_MOD(b1,b2,b3) is_expressible_by b3;
:: IDEA_1:th 17
theorem
for b1, b2 being Element of NAT holds
NEG_MOD(b1,b2) is_expressible_by b2;
:: IDEA_1:funcnot 7 => IDEA_1:func 7
definition
let a1, a2 be Element of NAT;
func ChangeVal_1(A2,A1) -> Element of NAT equals
2 to_power a1
if a2 = 0
otherwise a2;
end;
:: IDEA_1:def 7
theorem
for b1, b2 being Element of NAT holds
(b2 = 0 implies ChangeVal_1(b2,b1) = 2 to_power b1) &
(b2 = 0 or ChangeVal_1(b2,b1) = b2);
:: IDEA_1:th 18
theorem
for b1, b2 being Element of NAT
st b1 is_expressible_by b2
holds ChangeVal_1(b1,b2) <= 2 to_power b2 & 0 < ChangeVal_1(b1,b2);
:: IDEA_1:th 19
theorem
for b1, b2, b3 being Element of NAT
st b2 is_expressible_by b1 & b3 is_expressible_by b1 & ChangeVal_1(b2,b1) = ChangeVal_1(b3,b1)
holds b2 = b3;
:: IDEA_1:funcnot 8 => IDEA_1:func 8
definition
let a1, a2 be Element of NAT;
func ChangeVal_2(A2,A1) -> Element of NAT equals
0
if a2 = 2 to_power a1
otherwise a2;
end;
:: IDEA_1:def 8
theorem
for b1, b2 being Element of NAT holds
(b2 = 2 to_power b1 implies ChangeVal_2(b2,b1) = 0) &
(b2 = 2 to_power b1 or ChangeVal_2(b2,b1) = b2);
:: IDEA_1:th 20
theorem
for b1, b2 being Element of NAT
st b1 is_expressible_by b2
holds ChangeVal_2(b1,b2) is_expressible_by b2;
:: IDEA_1:th 21
theorem
for b1, b2, b3 being Element of NAT
st b2 <> 0 & b3 <> 0 & ChangeVal_2(b2,b1) = ChangeVal_2(b3,b1)
holds b2 = b3;
:: IDEA_1:funcnot 9 => IDEA_1:func 9
definition
let a1, a2, a3 be Element of NAT;
func MUL_MOD(A2,A3,A1) -> Element of NAT equals
ChangeVal_2(((ChangeVal_1(a2,a1)) * ChangeVal_1(a3,a1)) mod ((2 to_power a1) + 1),a1);
end;
:: IDEA_1:def 9
theorem
for b1, b2, b3 being Element of NAT holds
MUL_MOD(b2,b3,b1) = ChangeVal_2(((ChangeVal_1(b2,b1)) * ChangeVal_1(b3,b1)) mod ((2 to_power b1) + 1),b1);
:: IDEA_1:funcnot 10 => IDEA_1:func 10
definition
let a1 be non empty Element of NAT;
let a2 be Element of NAT;
assume a2 is_expressible_by a1 & (2 to_power a1) + 1 is prime;
func INV_MOD(A2,A1) -> Element of NAT means
MUL_MOD(a2,it,a1) = 1 & it is_expressible_by a1;
end;
:: IDEA_1:def 10
theorem
for b1 being non empty Element of NAT
for b2 being Element of NAT
st b2 is_expressible_by b1 & (2 to_power b1) + 1 is prime
for b3 being Element of NAT holds
b3 = INV_MOD(b2,b1)
iff
MUL_MOD(b2,b3,b1) = 1 & b3 is_expressible_by b1;
:: IDEA_1:th 22
theorem
for b1, b2, b3 being Element of NAT holds
MUL_MOD(b1,b2,b3) = MUL_MOD(b2,b1,b3);
:: IDEA_1:th 23
theorem
for b1, b2 being Element of NAT
st b1 is_expressible_by b2
holds MUL_MOD(1,b1,b2) = b1;
:: IDEA_1:th 24
theorem
for b1, b2, b3, b4 being Element of NAT
st (2 to_power b1) + 1 is prime & b2 is_expressible_by b1 & b3 is_expressible_by b1 & b4 is_expressible_by b1
holds MUL_MOD(MUL_MOD(b2,b3,b1),b4,b1) = MUL_MOD(b2,MUL_MOD(b3,b4,b1),b1);
:: IDEA_1:th 25
theorem
for b1, b2, b3 being Element of NAT holds
MUL_MOD(b1,b2,b3) is_expressible_by b3;
:: IDEA_1:th 26
theorem
for b1, b2 being Element of NAT
st ChangeVal_2(b1,b2) = 1
holds b1 = 1;
:: IDEA_1:funcnot 11 => IDEA_1:func 11
definition
let a1 be Element of NAT;
let a2, a3 be FinSequence of NAT;
func IDEAoperationA(A2,A3,A1) -> FinSequence of NAT means
len it = len a2 &
(for b1 being Element of NAT
st b1 in dom a2
holds (b1 = 1 implies it . b1 = MUL_MOD(a2 . 1,a3 . 1,a1)) &
(b1 = 2 implies it . b1 = ADD_MOD(a2 . 2,a3 . 2,a1)) &
(b1 = 3 implies it . b1 = ADD_MOD(a2 . 3,a3 . 3,a1)) &
(b1 = 4 implies it . b1 = MUL_MOD(a2 . 4,a3 . 4,a1)) &
(b1 <> 1 & b1 <> 2 & b1 <> 3 & b1 <> 4 implies it . b1 = a2 . b1));
end;
:: IDEA_1:def 11
theorem
for b1 being Element of NAT
for b2, b3, b4 being FinSequence of NAT holds
b4 = IDEAoperationA(b2,b3,b1)
iff
len b4 = len b2 &
(for b5 being Element of NAT
st b5 in dom b2
holds (b5 = 1 implies b4 . b5 = MUL_MOD(b2 . 1,b3 . 1,b1)) &
(b5 = 2 implies b4 . b5 = ADD_MOD(b2 . 2,b3 . 2,b1)) &
(b5 = 3 implies b4 . b5 = ADD_MOD(b2 . 3,b3 . 3,b1)) &
(b5 = 4 implies b4 . b5 = MUL_MOD(b2 . 4,b3 . 4,b1)) &
(b5 <> 1 & b5 <> 2 & b5 <> 3 & b5 <> 4 implies b4 . b5 = b2 . b5));
:: IDEA_1:funcnot 12 => IDEA_1:func 12
definition
let a1 be non empty Element of NAT;
let a2, a3 be FinSequence of NAT;
func IDEAoperationB(A2,A3,A1) -> FinSequence of NAT means
len it = len a2 &
(for b1 being Element of NAT
st b1 in dom a2
holds (b1 = 1 implies it . b1 = Absval ((a1 -BinarySequence (a2 . 1)) 'xor' (a1 -BinarySequence MUL_MOD(ADD_MOD(MUL_MOD(Absval ((a1 -BinarySequence (a2 . 1)) 'xor' (a1 -BinarySequence (a2 . 3))),a3 . 5,a1),Absval ((a1 -BinarySequence (a2 . 2)) 'xor' (a1 -BinarySequence (a2 . 4))),a1),a3 . 6,a1)))) &
(b1 = 2 implies it . b1 = Absval ((a1 -BinarySequence (a2 . 2)) 'xor' (a1 -BinarySequence ADD_MOD(MUL_MOD(Absval ((a1 -BinarySequence (a2 . 1)) 'xor' (a1 -BinarySequence (a2 . 3))),a3 . 5,a1),MUL_MOD(ADD_MOD(MUL_MOD(Absval ((a1 -BinarySequence (a2 . 1)) 'xor' (a1 -BinarySequence (a2 . 3))),a3 . 5,a1),Absval ((a1 -BinarySequence (a2 . 2)) 'xor' (a1 -BinarySequence (a2 . 4))),a1),a3 . 6,a1),a1)))) &
(b1 = 3 implies it . b1 = Absval ((a1 -BinarySequence (a2 . 3)) 'xor' (a1 -BinarySequence MUL_MOD(ADD_MOD(MUL_MOD(Absval ((a1 -BinarySequence (a2 . 1)) 'xor' (a1 -BinarySequence (a2 . 3))),a3 . 5,a1),Absval ((a1 -BinarySequence (a2 . 2)) 'xor' (a1 -BinarySequence (a2 . 4))),a1),a3 . 6,a1)))) &
(b1 = 4 implies it . b1 = Absval ((a1 -BinarySequence (a2 . 4)) 'xor' (a1 -BinarySequence ADD_MOD(MUL_MOD(Absval ((a1 -BinarySequence (a2 . 1)) 'xor' (a1 -BinarySequence (a2 . 3))),a3 . 5,a1),MUL_MOD(ADD_MOD(MUL_MOD(Absval ((a1 -BinarySequence (a2 . 1)) 'xor' (a1 -BinarySequence (a2 . 3))),a3 . 5,a1),Absval ((a1 -BinarySequence (a2 . 2)) 'xor' (a1 -BinarySequence (a2 . 4))),a1),a3 . 6,a1),a1)))) &
(b1 <> 1 & b1 <> 2 & b1 <> 3 & b1 <> 4 implies it . b1 = a2 . b1));
end;
:: IDEA_1:def 12
theorem
for b1 being non empty Element of NAT
for b2, b3, b4 being FinSequence of NAT holds
b4 = IDEAoperationB(b2,b3,b1)
iff
len b4 = len b2 &
(for b5 being Element of NAT
st b5 in dom b2
holds (b5 = 1 implies b4 . b5 = Absval ((b1 -BinarySequence (b2 . 1)) 'xor' (b1 -BinarySequence MUL_MOD(ADD_MOD(MUL_MOD(Absval ((b1 -BinarySequence (b2 . 1)) 'xor' (b1 -BinarySequence (b2 . 3))),b3 . 5,b1),Absval ((b1 -BinarySequence (b2 . 2)) 'xor' (b1 -BinarySequence (b2 . 4))),b1),b3 . 6,b1)))) &
(b5 = 2 implies b4 . b5 = Absval ((b1 -BinarySequence (b2 . 2)) 'xor' (b1 -BinarySequence ADD_MOD(MUL_MOD(Absval ((b1 -BinarySequence (b2 . 1)) 'xor' (b1 -BinarySequence (b2 . 3))),b3 . 5,b1),MUL_MOD(ADD_MOD(MUL_MOD(Absval ((b1 -BinarySequence (b2 . 1)) 'xor' (b1 -BinarySequence (b2 . 3))),b3 . 5,b1),Absval ((b1 -BinarySequence (b2 . 2)) 'xor' (b1 -BinarySequence (b2 . 4))),b1),b3 . 6,b1),b1)))) &
(b5 = 3 implies b4 . b5 = Absval ((b1 -BinarySequence (b2 . 3)) 'xor' (b1 -BinarySequence MUL_MOD(ADD_MOD(MUL_MOD(Absval ((b1 -BinarySequence (b2 . 1)) 'xor' (b1 -BinarySequence (b2 . 3))),b3 . 5,b1),Absval ((b1 -BinarySequence (b2 . 2)) 'xor' (b1 -BinarySequence (b2 . 4))),b1),b3 . 6,b1)))) &
(b5 = 4 implies b4 . b5 = Absval ((b1 -BinarySequence (b2 . 4)) 'xor' (b1 -BinarySequence ADD_MOD(MUL_MOD(Absval ((b1 -BinarySequence (b2 . 1)) 'xor' (b1 -BinarySequence (b2 . 3))),b3 . 5,b1),MUL_MOD(ADD_MOD(MUL_MOD(Absval ((b1 -BinarySequence (b2 . 1)) 'xor' (b1 -BinarySequence (b2 . 3))),b3 . 5,b1),Absval ((b1 -BinarySequence (b2 . 2)) 'xor' (b1 -BinarySequence (b2 . 4))),b1),b3 . 6,b1),b1)))) &
(b5 <> 1 & b5 <> 2 & b5 <> 3 & b5 <> 4 implies b4 . b5 = b2 . b5));
:: IDEA_1:funcnot 13 => IDEA_1:func 13
definition
let a1 be FinSequence of NAT;
func IDEAoperationC A1 -> FinSequence of NAT means
len it = len a1 &
(for b1 being Element of NAT
st b1 in dom a1
holds it . b1 = IFEQ(b1,2,a1 . 3,IFEQ(b1,3,a1 . 2,a1 . b1)));
end;
:: IDEA_1:def 13
theorem
for b1, b2 being FinSequence of NAT holds
b2 = IDEAoperationC b1
iff
len b2 = len b1 &
(for b3 being Element of NAT
st b3 in dom b1
holds b2 . b3 = IFEQ(b3,2,b1 . 3,IFEQ(b3,3,b1 . 2,b1 . b3)));
:: IDEA_1:th 27
theorem
for b1 being Element of NAT
for b2, b3 being FinSequence of NAT
st 4 <= len b2
holds (IDEAoperationA(b2,b3,b1)) . 1 is_expressible_by b1 & (IDEAoperationA(b2,b3,b1)) . 2 is_expressible_by b1 & (IDEAoperationA(b2,b3,b1)) . 3 is_expressible_by b1 & (IDEAoperationA(b2,b3,b1)) . 4 is_expressible_by b1;
:: IDEA_1:th 28
theorem
for b1, b2 being FinSequence of NAT
for b3 being non empty Element of NAT
st 4 <= len b1
holds (IDEAoperationB(b1,b2,b3)) . 1 is_expressible_by b3 & (IDEAoperationB(b1,b2,b3)) . 2 is_expressible_by b3 & (IDEAoperationB(b1,b2,b3)) . 3 is_expressible_by b3 & (IDEAoperationB(b1,b2,b3)) . 4 is_expressible_by b3;
:: IDEA_1:th 29
theorem
for b1 being Element of NAT
for b2 being FinSequence of NAT
st 4 <= len b2 & b2 . 1 is_expressible_by b1 & b2 . 2 is_expressible_by b1 & b2 . 3 is_expressible_by b1 & b2 . 4 is_expressible_by b1
holds (IDEAoperationC b2) . 1 is_expressible_by b1 & (IDEAoperationC b2) . 2 is_expressible_by b1 & (IDEAoperationC b2) . 3 is_expressible_by b1 & (IDEAoperationC b2) . 4 is_expressible_by b1;
:: IDEA_1:th 30
theorem
for b1 being non empty Element of NAT
for b2, b3, b4 being FinSequence of NAT
st (2 to_power b1) + 1 is prime & 4 <= len b2 & b2 . 1 is_expressible_by b1 & b2 . 2 is_expressible_by b1 & b2 . 3 is_expressible_by b1 & b2 . 4 is_expressible_by b1 & b3 . 1 is_expressible_by b1 & b3 . 2 is_expressible_by b1 & b3 . 3 is_expressible_by b1 & b3 . 4 is_expressible_by b1 & b4 . 1 = INV_MOD(b3 . 1,b1) & b4 . 2 = NEG_MOD(b3 . 2,b1) & b4 . 3 = NEG_MOD(b3 . 3,b1) & b4 . 4 = INV_MOD(b3 . 4,b1)
holds IDEAoperationA(IDEAoperationA(b2,b3,b1),b4,b1) = b2;
:: IDEA_1:th 31
theorem
for b1 being non empty Element of NAT
for b2, b3, b4 being FinSequence of NAT
st (2 to_power b1) + 1 is prime & 4 <= len b2 & b2 . 1 is_expressible_by b1 & b2 . 2 is_expressible_by b1 & b2 . 3 is_expressible_by b1 & b2 . 4 is_expressible_by b1 & b3 . 1 is_expressible_by b1 & b3 . 2 is_expressible_by b1 & b3 . 3 is_expressible_by b1 & b3 . 4 is_expressible_by b1 & b4 . 1 = INV_MOD(b3 . 1,b1) & b4 . 2 = NEG_MOD(b3 . 3,b1) & b4 . 3 = NEG_MOD(b3 . 2,b1) & b4 . 4 = INV_MOD(b3 . 4,b1)
holds IDEAoperationA(IDEAoperationC IDEAoperationA(IDEAoperationC b2,b3,b1),b4,b1) = b2;
:: IDEA_1:th 32
theorem
for b1 being non empty Element of NAT
for b2, b3, b4 being FinSequence of NAT
st (2 to_power b1) + 1 is prime & 4 <= len b2 & b2 . 1 is_expressible_by b1 & b2 . 2 is_expressible_by b1 & b2 . 3 is_expressible_by b1 & b2 . 4 is_expressible_by b1 & b3 . 5 is_expressible_by b1 & b3 . 6 is_expressible_by b1 & b4 . 5 = b3 . 5 & b4 . 6 = b3 . 6
holds IDEAoperationB(IDEAoperationB(b2,b3,b1),b4,b1) = b2;
:: IDEA_1:th 33
theorem
for b1 being FinSequence of NAT
st 4 <= len b1
holds IDEAoperationC IDEAoperationC b1 = b1;
:: IDEA_1:funcnot 14 => IDEA_1:func 14
definition
func MESSAGES -> set equals
NAT *;
end;
:: IDEA_1:def 14
theorem
MESSAGES = NAT *;
:: IDEA_1:funcreg 1
registration
cluster MESSAGES -> non empty;
end;
:: IDEA_1:funcreg 2
registration
cluster MESSAGES -> functional;
end;
:: IDEA_1:condreg 1
registration
cluster -> FinSequence-like (Element of MESSAGES);
end;
:: IDEA_1:funcnot 15 => IDEA_1:func 15
definition
let a1 be non empty Element of NAT;
let a2 be FinSequence of NAT;
func IDEA_P(A2,A1) -> Function-like quasi_total Relation of MESSAGES,MESSAGES means
for b1 being FinSequence of NAT holds
it . b1 = IDEAoperationA(IDEAoperationC IDEAoperationB(b1,a2,a1),a2,a1);
end;
:: IDEA_1:def 15
theorem
for b1 being non empty Element of NAT
for b2 being FinSequence of NAT
for b3 being Function-like quasi_total Relation of MESSAGES,MESSAGES holds
b3 = IDEA_P(b2,b1)
iff
for b4 being FinSequence of NAT holds
b3 . b4 = IDEAoperationA(IDEAoperationC IDEAoperationB(b4,b2,b1),b2,b1);
:: IDEA_1:funcnot 16 => IDEA_1:func 16
definition
let a1 be non empty Element of NAT;
let a2 be FinSequence of NAT;
func IDEA_Q(A2,A1) -> Function-like quasi_total Relation of MESSAGES,MESSAGES means
for b1 being FinSequence of NAT holds
it . b1 = IDEAoperationB(IDEAoperationA(IDEAoperationC b1,a2,a1),a2,a1);
end;
:: IDEA_1:def 16
theorem
for b1 being non empty Element of NAT
for b2 being FinSequence of NAT
for b3 being Function-like quasi_total Relation of MESSAGES,MESSAGES holds
b3 = IDEA_Q(b2,b1)
iff
for b4 being FinSequence of NAT holds
b3 . b4 = IDEAoperationB(IDEAoperationA(IDEAoperationC b4,b2,b1),b2,b1);
:: IDEA_1:funcnot 17 => IDEA_1:func 17
definition
let a1, a2 be Element of NAT;
let a3 be non empty Element of NAT;
let a4 be Matrix of a2,6,NAT;
func IDEA_P_F(A4,A3,A1) -> Relation-like Function-like FinSequence-like set means
len it = a1 &
(for b1 being Element of NAT
st b1 in dom it
holds it . b1 = IDEA_P(Line(a4,b1),a3));
end;
:: IDEA_1:def 17
theorem
for b1, b2 being Element of NAT
for b3 being non empty Element of NAT
for b4 being Matrix of b2,6,NAT
for b5 being Relation-like Function-like FinSequence-like set holds
b5 = IDEA_P_F(b4,b3,b1)
iff
len b5 = b1 &
(for b6 being Element of NAT
st b6 in dom b5
holds b5 . b6 = IDEA_P(Line(b4,b6),b3));
:: IDEA_1:funcreg 3
registration
let a1, a2 be Element of NAT;
let a3 be non empty Element of NAT;
let a4 be Matrix of a2,6,NAT;
cluster IDEA_P_F(a4,a3,a1) -> Relation-like Function-like Function-yielding FinSequence-like;
end;
:: IDEA_1:funcnot 18 => IDEA_1:func 18
definition
let a1, a2 be Element of NAT;
let a3 be non empty Element of NAT;
let a4 be Matrix of a2,6,NAT;
func IDEA_Q_F(A4,A3,A1) -> Relation-like Function-like FinSequence-like set means
len it = a1 &
(for b1 being Element of NAT
st b1 in dom it
holds it . b1 = IDEA_Q(Line(a4,(a1 -' b1) + 1),a3));
end;
:: IDEA_1:def 18
theorem
for b1, b2 being Element of NAT
for b3 being non empty Element of NAT
for b4 being Matrix of b2,6,NAT
for b5 being Relation-like Function-like FinSequence-like set holds
b5 = IDEA_Q_F(b4,b3,b1)
iff
len b5 = b1 &
(for b6 being Element of NAT
st b6 in dom b5
holds b5 . b6 = IDEA_Q(Line(b4,(b1 -' b6) + 1),b3));
:: IDEA_1:funcreg 4
registration
let a1, a2 be Element of NAT;
let a3 be non empty Element of NAT;
let a4 be Matrix of a2,6,NAT;
cluster IDEA_Q_F(a4,a3,a1) -> Relation-like Function-like Function-yielding FinSequence-like;
end;
:: IDEA_1:funcnot 19 => IDEA_1:func 19
definition
let a1 be FinSequence of NAT;
let a2 be Element of NAT;
func IDEA_PS(A1,A2) -> Function-like quasi_total Relation of MESSAGES,MESSAGES means
for b1 being FinSequence of NAT holds
it . b1 = IDEAoperationA(b1,a1,a2);
end;
:: IDEA_1:def 19
theorem
for b1 being FinSequence of NAT
for b2 being Element of NAT
for b3 being Function-like quasi_total Relation of MESSAGES,MESSAGES holds
b3 = IDEA_PS(b1,b2)
iff
for b4 being FinSequence of NAT holds
b3 . b4 = IDEAoperationA(b4,b1,b2);
:: IDEA_1:funcnot 20 => IDEA_1:func 20
definition
let a1 be FinSequence of NAT;
let a2 be Element of NAT;
func IDEA_QS(A1,A2) -> Function-like quasi_total Relation of MESSAGES,MESSAGES means
for b1 being FinSequence of NAT holds
it . b1 = IDEAoperationA(b1,a1,a2);
end;
:: IDEA_1:def 20
theorem
for b1 being FinSequence of NAT
for b2 being Element of NAT
for b3 being Function-like quasi_total Relation of MESSAGES,MESSAGES holds
b3 = IDEA_QS(b1,b2)
iff
for b4 being FinSequence of NAT holds
b3 . b4 = IDEAoperationA(b4,b1,b2);
:: IDEA_1:funcnot 21 => IDEA_1:func 21
definition
let a1 be non empty Element of NAT;
let a2 be FinSequence of NAT;
func IDEA_PE(A2,A1) -> Function-like quasi_total Relation of MESSAGES,MESSAGES means
for b1 being FinSequence of NAT holds
it . b1 = IDEAoperationA(IDEAoperationB(b1,a2,a1),a2,a1);
end;
:: IDEA_1:def 21
theorem
for b1 being non empty Element of NAT
for b2 being FinSequence of NAT
for b3 being Function-like quasi_total Relation of MESSAGES,MESSAGES holds
b3 = IDEA_PE(b2,b1)
iff
for b4 being FinSequence of NAT holds
b3 . b4 = IDEAoperationA(IDEAoperationB(b4,b2,b1),b2,b1);
:: IDEA_1:funcnot 22 => IDEA_1:func 22
definition
let a1 be non empty Element of NAT;
let a2 be FinSequence of NAT;
func IDEA_QE(A2,A1) -> Function-like quasi_total Relation of MESSAGES,MESSAGES means
for b1 being FinSequence of NAT holds
it . b1 = IDEAoperationB(IDEAoperationA(b1,a2,a1),a2,a1);
end;
:: IDEA_1:def 22
theorem
for b1 being non empty Element of NAT
for b2 being FinSequence of NAT
for b3 being Function-like quasi_total Relation of MESSAGES,MESSAGES holds
b3 = IDEA_QE(b2,b1)
iff
for b4 being FinSequence of NAT holds
b3 . b4 = IDEAoperationB(IDEAoperationA(b4,b2,b1),b2,b1);
:: IDEA_1:th 34
theorem
for b1 being non empty Element of NAT
for b2, b3, b4 being FinSequence of NAT
st (2 to_power b1) + 1 is prime & 4 <= len b2 & b2 . 1 is_expressible_by b1 & b2 . 2 is_expressible_by b1 & b2 . 3 is_expressible_by b1 & b2 . 4 is_expressible_by b1 & b3 . 1 is_expressible_by b1 & b3 . 2 is_expressible_by b1 & b3 . 3 is_expressible_by b1 & b3 . 4 is_expressible_by b1 & b3 . 5 is_expressible_by b1 & b3 . 6 is_expressible_by b1 & b4 . 1 = INV_MOD(b3 . 1,b1) & b4 . 2 = NEG_MOD(b3 . 3,b1) & b4 . 3 = NEG_MOD(b3 . 2,b1) & b4 . 4 = INV_MOD(b3 . 4,b1) & b4 . 5 = b3 . 5 & b4 . 6 = b3 . 6
holds ((IDEA_Q(b4,b1)) * IDEA_P(b3,b1)) . b2 = b2;
:: IDEA_1:th 35
theorem
for b1 being non empty Element of NAT
for b2, b3, b4 being FinSequence of NAT
st (2 to_power b1) + 1 is prime & 4 <= len b2 & b2 . 1 is_expressible_by b1 & b2 . 2 is_expressible_by b1 & b2 . 3 is_expressible_by b1 & b2 . 4 is_expressible_by b1 & b3 . 1 is_expressible_by b1 & b3 . 2 is_expressible_by b1 & b3 . 3 is_expressible_by b1 & b3 . 4 is_expressible_by b1 & b4 . 1 = INV_MOD(b3 . 1,b1) & b4 . 2 = NEG_MOD(b3 . 2,b1) & b4 . 3 = NEG_MOD(b3 . 3,b1) & b4 . 4 = INV_MOD(b3 . 4,b1)
holds ((IDEA_QS(b4,b1)) * IDEA_PS(b3,b1)) . b2 = b2;
:: IDEA_1:th 36
theorem
for b1 being non empty Element of NAT
for b2, b3, b4 being FinSequence of NAT
st (2 to_power b1) + 1 is prime & 4 <= len b2 & b2 . 1 is_expressible_by b1 & b2 . 2 is_expressible_by b1 & b2 . 3 is_expressible_by b1 & b2 . 4 is_expressible_by b1 & b3 . 1 is_expressible_by b1 & b3 . 2 is_expressible_by b1 & b3 . 3 is_expressible_by b1 & b3 . 4 is_expressible_by b1 & b3 . 5 is_expressible_by b1 & b3 . 6 is_expressible_by b1 & b4 . 1 = INV_MOD(b3 . 1,b1) & b4 . 2 = NEG_MOD(b3 . 2,b1) & b4 . 3 = NEG_MOD(b3 . 3,b1) & b4 . 4 = INV_MOD(b3 . 4,b1) & b4 . 5 = b3 . 5 & b4 . 6 = b3 . 6
holds ((IDEA_QE(b4,b1)) * IDEA_PE(b3,b1)) . b2 = b2;
:: IDEA_1:th 37
theorem
for b1 being non empty Element of NAT
for b2 being Element of NAT
for b3 being Matrix of b2,6,NAT
for b4 being Element of NAT holds
IDEA_P_F(b3,b1,b4 + 1) = (IDEA_P_F(b3,b1,b4)) ^ <*IDEA_P(Line(b3,b4 + 1),b1)*>;
:: IDEA_1:th 38
theorem
for b1 being non empty Element of NAT
for b2 being Element of NAT
for b3 being Matrix of b2,6,NAT
for b4 being Element of NAT holds
IDEA_Q_F(b3,b1,b4 + 1) = <*IDEA_Q(Line(b3,b4 + 1),b1)*> ^ IDEA_Q_F(b3,b1,b4);
:: IDEA_1:th 39
theorem
for b1 being non empty Element of NAT
for b2 being Element of NAT
for b3 being Matrix of b2,6,NAT
for b4 being Element of NAT holds
IDEA_P_F(b3,b1,b4) is Relation-like Function-like FinSequence-like FuncSeq-like set;
:: IDEA_1:th 40
theorem
for b1 being non empty Element of NAT
for b2 being Element of NAT
for b3 being Matrix of b2,6,NAT
for b4 being Element of NAT holds
IDEA_Q_F(b3,b1,b4) is Relation-like Function-like FinSequence-like FuncSeq-like set;
:: IDEA_1:th 41
theorem
for b1 being non empty Element of NAT
for b2 being Element of NAT
for b3 being Matrix of b2,6,NAT
for b4 being Element of NAT
st b4 <> 0
holds IDEA_P_F(b3,b1,b4) is FuncSequence of MESSAGES,MESSAGES;
:: IDEA_1:th 42
theorem
for b1 being non empty Element of NAT
for b2 being Element of NAT
for b3 being Matrix of b2,6,NAT
for b4 being Element of NAT
st b4 <> 0
holds IDEA_Q_F(b3,b1,b4) is FuncSequence of MESSAGES,MESSAGES;
:: IDEA_1:th 43
theorem
for b1 being non empty Element of NAT
for b2, b3, b4 being FinSequence of NAT
st b2 = (IDEA_P(b4,b1)) . b3 & 4 <= len b3
holds 4 <= len b2 & b2 . 1 is_expressible_by b1 & b2 . 2 is_expressible_by b1 & b2 . 3 is_expressible_by b1 & b2 . 4 is_expressible_by b1;
:: IDEA_1:th 44
theorem
for b1 being non empty Element of NAT
for b2 being Element of NAT
for b3 being Matrix of b2,6,NAT
for b4 being Element of NAT holds
proj2 compose(IDEA_P_F(b3,b1,b4),MESSAGES) c= MESSAGES &
proj1 compose(IDEA_P_F(b3,b1,b4),MESSAGES) = MESSAGES;
:: IDEA_1:th 45
theorem
for b1 being non empty Element of NAT
for b2 being Element of NAT
for b3 being Matrix of b2,6,NAT
for b4 being Element of NAT holds
proj2 compose(IDEA_Q_F(b3,b1,b4),MESSAGES) c= MESSAGES &
proj1 compose(IDEA_Q_F(b3,b1,b4),MESSAGES) = MESSAGES;
:: IDEA_1:th 47
theorem
for b1 being non empty Element of NAT
for b2 being Element of NAT
for b3 being Matrix of b2,6,NAT
for b4 being Element of NAT
for b5, b6 being FinSequence of NAT
st b5 = (compose(IDEA_P_F(b3,b1,b4),MESSAGES)) . b6 &
4 <= len b6 &
b6 . 1 is_expressible_by b1 &
b6 . 2 is_expressible_by b1 &
b6 . 3 is_expressible_by b1 &
b6 . 4 is_expressible_by b1
holds 4 <= len b5 & b5 . 1 is_expressible_by b1 & b5 . 2 is_expressible_by b1 & b5 . 3 is_expressible_by b1 & b5 . 4 is_expressible_by b1;
:: IDEA_1:th 48
theorem
for b1 being non empty Element of NAT
for b2 being Element of NAT
for b3, b4 being Matrix of b2,6,NAT
for b5 being Element of NAT
for b6 being FinSequence of NAT
st b5 <= b2 &
(2 to_power b1) + 1 is prime &
4 <= len b6 &
b6 . 1 is_expressible_by b1 &
b6 . 2 is_expressible_by b1 &
b6 . 3 is_expressible_by b1 &
b6 . 4 is_expressible_by b1 &
(for b7 being Element of NAT
st b7 <= b5
holds b3 *(b7,1) is_expressible_by b1 &
b3 *(b7,2) is_expressible_by b1 &
b3 *(b7,3) is_expressible_by b1 &
b3 *(b7,4) is_expressible_by b1 &
b3 *(b7,5) is_expressible_by b1 &
b3 *(b7,6) is_expressible_by b1 &
b4 *(b7,1) is_expressible_by b1 &
b4 *(b7,2) is_expressible_by b1 &
b4 *(b7,3) is_expressible_by b1 &
b4 *(b7,4) is_expressible_by b1 &
b4 *(b7,5) is_expressible_by b1 &
b4 *(b7,6) is_expressible_by b1 &
b4 *(b7,1) = INV_MOD(b3 *(b7,1),b1) &
b4 *(b7,2) = NEG_MOD(b3 *(b7,3),b1) &
b4 *(b7,3) = NEG_MOD(b3 *(b7,2),b1) &
b4 *(b7,4) = INV_MOD(b3 *(b7,4),b1) &
b3 *(b7,5) = b4 *(b7,5) &
b3 *(b7,6) = b4 *(b7,6))
holds (compose((IDEA_P_F(b3,b1,b5)) ^ IDEA_Q_F(b4,b1,b5),MESSAGES)) . b6 = b6;
:: IDEA_1:th 49
theorem
for b1 being non empty Element of NAT
for b2 being Element of NAT
for b3, b4 being Matrix of b2,6,NAT
for b5 being Element of NAT
for b6, b7, b8, b9, b10 being FinSequence of NAT
st b5 <= b2 &
(2 to_power b1) + 1 is prime &
4 <= len b10 &
b10 . 1 is_expressible_by b1 &
b10 . 2 is_expressible_by b1 &
b10 . 3 is_expressible_by b1 &
b10 . 4 is_expressible_by b1 &
(for b11 being Element of NAT
st b11 <= b5
holds b3 *(b11,1) is_expressible_by b1 &
b3 *(b11,2) is_expressible_by b1 &
b3 *(b11,3) is_expressible_by b1 &
b3 *(b11,4) is_expressible_by b1 &
b3 *(b11,5) is_expressible_by b1 &
b3 *(b11,6) is_expressible_by b1 &
b4 *(b11,1) is_expressible_by b1 &
b4 *(b11,2) is_expressible_by b1 &
b4 *(b11,3) is_expressible_by b1 &
b4 *(b11,4) is_expressible_by b1 &
b4 *(b11,5) is_expressible_by b1 &
b4 *(b11,6) is_expressible_by b1 &
b4 *(b11,1) = INV_MOD(b3 *(b11,1),b1) &
b4 *(b11,2) = NEG_MOD(b3 *(b11,3),b1) &
b4 *(b11,3) = NEG_MOD(b3 *(b11,2),b1) &
b4 *(b11,4) = INV_MOD(b3 *(b11,4),b1) &
b3 *(b11,5) = b4 *(b11,5) &
b3 *(b11,6) = b4 *(b11,6)) &
b6 . 1 is_expressible_by b1 &
b6 . 2 is_expressible_by b1 &
b6 . 3 is_expressible_by b1 &
b6 . 4 is_expressible_by b1 &
b7 . 1 = INV_MOD(b6 . 1,b1) &
b7 . 2 = NEG_MOD(b6 . 2,b1) &
b7 . 3 = NEG_MOD(b6 . 3,b1) &
b7 . 4 = INV_MOD(b6 . 4,b1) &
b8 . 1 is_expressible_by b1 &
b8 . 2 is_expressible_by b1 &
b8 . 3 is_expressible_by b1 &
b8 . 4 is_expressible_by b1 &
b8 . 5 is_expressible_by b1 &
b8 . 6 is_expressible_by b1 &
b9 . 1 = INV_MOD(b8 . 1,b1) &
b9 . 2 = NEG_MOD(b8 . 2,b1) &
b9 . 3 = NEG_MOD(b8 . 3,b1) &
b9 . 4 = INV_MOD(b8 . 4,b1) &
b9 . 5 = b8 . 5 &
b9 . 6 = b8 . 6
holds ((((((IDEA_PS(b6,b1)) * compose(IDEA_P_F(b3,b1,b5),MESSAGES)) * IDEA_PE(b8,b1)) * IDEA_QE(b9,b1)) * compose(IDEA_Q_F(b4,b1,b5),MESSAGES)) * IDEA_QS(b7,b1)) . b10 = b10;