:: Subsets of Complex Numbers
:: by Andrzej Trybulec
::
:: Copyright (c) 2003-2011 Association of Mizar Users

begin

Lm1: omega c= ( { [c,d] where c, d is Element of omega : ( c,d are_relative_prime & d <> {} ) } \ { [k,1] where k is Element of omega : verum } ) \/ omega
by XBOOLE_1:7;

notation
synonym NAT for omega ;
synonym 0 for {} ;
end;

Lm2: 1 = succ 0
;

definition
func REAL -> set equals :: NUMBERS:def 1
() \ ;
coherence
() \ is set
;
end;

:: deftheorem defines REAL NUMBERS:def 1 :

Lm3: REAL+ c= REAL
proof end;

registration
cluster REAL -> non empty ;
coherence
not REAL is empty
by ;
end;

definition
func COMPLEX -> set equals :: NUMBERS:def 2
((Funcs ({0,1},REAL)) \ { x where x is Element of Funcs ({0,1},REAL) : x . 1 = 0 } ) \/ REAL;
coherence
((Funcs ({0,1},REAL)) \ { x where x is Element of Funcs ({0,1},REAL) : x . 1 = 0 } ) \/ REAL is set
;
func RAT -> set equals :: NUMBERS:def 3
() \ ;
coherence
() \ is set
;
func INT -> set equals :: NUMBERS:def 4
() \ ;
coherence
() \ is set
;
:: original: NAT
redefine func NAT -> Subset of REAL;
coherence
NAT is Subset of REAL
by ;
end;

:: deftheorem defines COMPLEX NUMBERS:def 2 :
COMPLEX = ((Funcs ({0,1},REAL)) \ { x where x is Element of Funcs ({0,1},REAL) : x . 1 = 0 } ) \/ REAL;

:: deftheorem defines RAT NUMBERS:def 3 :
RAT = () \ ;

:: deftheorem defines INT NUMBERS:def 4 :
INT = () \ ;

Lm4: RAT+ c= RAT
proof end;

Lm5: NAT c= INT
proof end;

registration
cluster COMPLEX -> non empty ;
coherence
not COMPLEX is empty
;
cluster RAT -> non empty ;
coherence
not RAT is empty
by ;
cluster INT -> non empty ;
coherence
not INT is empty
by ;
end;

Lm6: for x, y, z being set st [x,y] = {z} holds
( z = {x} & x = y )
proof end;

Lm7: for a, b being Element of REAL holds not (0,one) --> (a,b) in REAL
proof end;

definition
:: original: 0
redefine func 0 -> Element of NAT ;
coherence
0 is Element of NAT
by ORDINAL1:def 12;
end;

theorem Th1: :: NUMBERS:1
proof end;

Lm8: RAT c= REAL
proof end;

Lm9: for i, j being ordinal Element of RAT+ st i in j holds
i < j
proof end;

Lm10: for i, j being ordinal Element of RAT+ st i c= j holds
i <=' j
proof end;

Lm11: 2 = succ 1
.= () \/ {1} by ORDINAL1:def 1
.= () \/ {1} by ORDINAL1:def 1
.= {0,1} by ENUMSET1:41 ;

Lm12: for i, k being natural Ordinal st i *^ i = 2 *^ k holds
ex k being natural Ordinal st i = 2 *^ k
proof end;

1 in omega
;

then reconsider a9 = 1 as Element of RAT+ by Lm1;

2 in omega
;

then reconsider two = 2 as ordinal Element of RAT+ by Lm1;

Lm13: one + one = two
proof end;

Lm14: for i being Element of RAT+ holds i + i = two *' i
proof end;

theorem Th2: :: NUMBERS:2
proof end;

theorem Th3: :: NUMBERS:3

Lm15: INT c= RAT
proof end;

theorem Th4: :: NUMBERS:4
proof end;

theorem Th5: :: NUMBERS:5
INT c< REAL by ;

theorem Th6: :: NUMBERS:6

theorem Th7: :: NUMBERS:7
proof end;

theorem Th8: :: NUMBERS:8
NAT c< RAT by ;

theorem Th9: :: NUMBERS:9
NAT c< REAL by ;

theorem Th10: :: NUMBERS:10

begin

theorem :: NUMBERS:11

theorem :: NUMBERS:12

theorem :: NUMBERS:13

theorem :: NUMBERS:14

theorem :: NUMBERS:15

theorem :: NUMBERS:16

theorem :: NUMBERS:17
NAT c= INT by Lm5;

theorem Th18: :: NUMBERS:18

theorem Th19: :: NUMBERS:19

theorem Th20: :: NUMBERS:20

theorem :: NUMBERS:21

theorem :: NUMBERS:22
RAT <> REAL by Th2;

theorem :: NUMBERS:23
RAT <> COMPLEX by ;

theorem :: NUMBERS:24
INT <> RAT by Th4;

theorem :: NUMBERS:25
INT <> REAL by ;

theorem :: NUMBERS:26
INT <> COMPLEX by ;

theorem :: NUMBERS:27
NAT <> INT by Th7;

theorem :: NUMBERS:28
NAT <> RAT by ;

theorem :: NUMBERS:29
NAT <> REAL by ;

theorem :: NUMBERS:30
NAT <> COMPLEX by ;

definition
func ExtREAL -> set equals :: NUMBERS:def 5
REAL \/ ;
coherence ;
end;

:: deftheorem defines ExtREAL NUMBERS:def 5 :

registration
cluster ExtREAL -> non empty ;
coherence
not ExtREAL is empty
;
end;

theorem Th31: :: NUMBERS:31

theorem Th32: :: NUMBERS:32
proof end;

theorem :: NUMBERS:33

registration
cluster INT -> infinite ;
coherence
not INT is finite
by ;
cluster RAT -> infinite ;
coherence
not RAT is finite
by ;
cluster REAL -> infinite ;
coherence
not REAL is finite
by ;
cluster COMPLEX -> infinite ;
coherence
not COMPLEX is finite
by ;
end;