cam_girls

I've posted 10,000 posts on discrete Vs continuous Infinity if you want to check sci.math and ask!

S is a set of lists of reals
w,x,y,z are Lists
y is a permutation of w that contains all the same reals, r
z is a permutation of x that contains all the same reals, r
A new infix operator el would be useful here:

INDEPENDENT(S, c) <=> Aw Ax Ey Ez (w e S) ^ (x e S) ^
((r el w) <-> (r el y)) ^ ((r el x) <-> (r el z)) ^ (c(y) = c(z))
Defn of el (Element of List)
(r el L) <=> (Ei r = L(i))

AXIOM OF INDEPENDENCE in standard notation:
INDEPENDENT(S, c) <=>
Aw Ax Ey Ez (w e S) ^ (x e S) ^
((Ei r=w(i)) <-> (Ej r=y(j))) ^ ((Ei r=x(i)) <-> (Ej r=z(j))) ^
(c(y) = c(z))

CONTNS 1 2 3 4 5
- - -+------------> ...
SET1 ! Y Y Y Y Y
SET2 ! n n n n n
SET3 ! Y n Y n Y
SET4 ! n Y n Y n
SET5 ! n n Y Y n
v
...

SET1 = {1,2,3,4,5...}
SET2 = (}
SET3 = {1,3,5...}
SET4 = {2,4...}
SET5 = {3,4, ...}
D = {x in A | x not in f(x)}
D = {2,5...}
DIAGONAL = <YnYYn...> <=> {1,3,4...}
ANTIDIAG = <nYnnY...> <=> {2,5...}
MISSING SUBSET = ANTIDIAGONAL
*****************************

f1, f2, ... is a set S of discrete functions f(N)->X
c is a function (construction) over the function fi
e.g. fi = {1,2,3,..i}
f1 = {1}
f2 = {1,2}
f3 = {1,2,3}
c(fi) = SMALLEST(fi)
FUNCTION SMALLEST(fi)
smallest_so_far = oo
j = 0
WHILE j < LEN(fi)
j++
IF fi(j) < smallest_so_far
smallest_so_far = fi(j)
ENDIF
WEND
RETURN smallest_so_far
ENDF

c(f1) = SMALLEST({1}) = 1
c(f2) = SMALLEST({1,2}) = 1
c(f3) = SMALLEST({1,2,3}) = 1
...
A(f1 e S) A(f2 e S) c(f1)=c(f2)
<=>
c is DIRECTLY_INDEPENDENT of the set S {f1, f2, f3,...}

1 Set(s)
& Set(p)
& ALL(c):[c e p <=> Set(c) & ALL(d):[d e c => d e s]]
Premise
Split premise
2 Set(s)
Split, 1
3 Set(p)
Split, 1
4 ALL(c):[c e p <=> Set(c) & ALL(d):[d e c => d e s]]
Split, 1
Let f be a function mapping s to every element of p.
5 ALL(x):[x e s => f(x) e p]
& ALL(x):[x e p => EXIST(x'):[x' e s & f(x')=x]]
Premise
6 ALL(x):[x e s => f(x) e p]
Split, 5
7 ALL(x):[x e p => EXIST(x'):[x' e s & f(x')=x]]
Split, 5
Construct set k
8 EXIST(a):[Set(a) & ALL(b):[b e a <=> b e s & ~b e f(b)]]
Subset, 2
9 Set(k) & ALL(b):[b e k <=> b e s & ~b e f(b)]
E Spec, 8
Define: k, the subset of s that is not a element of its image under f
[DOMAIN]
SOME EXTRA CRITERIA OF INFINITE POWERSETS
[1] all natural numbers n are elements of some subset in the powerset
ALL(n): (n e s) => EXIST(m):n e f(m)
[2] there is always 1 more of each instance of a natural number n
in an infinite supply of subsets
ALL(n):ALL(m): n e f(m) => EXIST(i): i>m & n e f(i)
[3] similarly there is an infinite supply of subsets that are missing
each natural number
ALL(n): (n e s) => EXIST(m): ~(n e f(m))
ALL(n):ALL(m): ~(n e f(m)) => EXIST(i): i>m & ~(n e f(i))
---
[GENERAL APPROACH]
k is a subset missing in any image of f
[4] Set(k) & ALL(b):[b e k <=> b e s & ~b e f(b)]
but k' is not in the image of f'
and k' is also not in the image of g'
for any arbitrary powerset functions f & g and some permutations f'
and g'
Hence k is not dependent on the selection of members of the powerset
but merely the ordering of the subsets.
---
[PROOF]
Consider POWERSET(N) where s = N
then k C {1,2,3,4...}
There is a permutation of f, f' such that the following holds
[5] ALL(u):EXIST(v):f(u)=f'(v) & ALL(v):EXIST(u):f(u)=f'(v)
Range( f ) = Range( f' )
and similarly for any arbitrary powerset function g
Range( g ) = Range( g' )
---
[MISSING SET COMBINATION ALGORITHM]
POWERSET MISSING SUBSETS COMBINATION ALGORITHM
A combination of the "missing sets" k off f & g
that is "missing from both" arbitrary f & g
MSC (f, g, m)
1 BEGIN
2
3 f' = ARRAY[] //all values initially f'(n)=NULL
4 g' = ARRAY[]
5
6 h = 2 //harvest rows from h onwards
7
8 FOR n = 1 TO m //max rows to demonstrate matching k
9
10 rw = '0' // if f' or g' row is populated do not overwrite
11 if ( f'(n) != NULL ) then rw="f"
12 if ( g'(n) != Null ) then rw="g"
13
14 kf = not ( n e f(n) ) //kf is TRUE if n is a member of k for f
15 kg = not ( n e g(n) )
16
17 if ( rw == "f" ) then
18 kf = not ( n e f'(n) ) //use new k from f'
19 endif
20 if ( rw == "g" ) then
21 kg = not ( n e g'(n) ) //use new k from g'
22 endif
23
24 if ( kf == kg ) then //both k's agree
25 if ( f'(n) == NULL ) then f'(n) = f(n) //transfer subset to
permutation
26 if ( g'(n) == NULL ) then g'(n) = g(n)
27 else
28 if ( rw == "f" ) then //select g to modify
29 i = find( g, h, kf ) //scan down g until (i e g)!=kf ..by
[2]&[3]
30 f'(n) = f(n)
31 g'(n) = g(i) //swap g(n) with new subset so both
k's agree
32 g'(i) = g(n)
33 h = i+1 //harvest new subsets where g' is
unmodified
34 else
35 i = find( f, h, kg ) //modify f
36 g'(n) = g(n)
37 f'(n) = f(i)
38 f'(i) = f(n)
39 h = i+1
40 endif
41 endif
42 next
END
---
[SMALL EXAMPLE]
Given 2 arbitrary (Infinite) Powerset Functions f, g
f(1) = {3} 1 e f(1) => 1 e k1
f(2) = (1, 3} 2 ~e f(2) => 2 e k1
f(3) = {2, 5} 3 e k1
f(4) = {4} 4 ~e k1
f(5) = {1,2,3,4,5} 5 ~e k1
g(1) = {1} 1 ~e k2
g(2) = {1, 3} 2 e k2
g(3) = {1, 2} 3 e k2
g(4) = {3, 4} 4 ~e k2
g(5) = {1,2,3,4} 5 e k2
k_f = {1, 2, 3}
k_g = {2, 3, 4, 5}
---
TRACE MSC ( f, g, 5 )
n=1
14 kf = not ( n e f(n) ) =TRUE
15 kg = not ( n e g(n) ) =FALSE
24 if ( kf == kg ) then FALSE
35 i = find( f, h, kf ) =2 //modify f
36 g'(n) = g(n)
37 f'(n) = f(i)
38 f'(i) = f(n)
f'(1) = {1, 3}
f'(2) = {3}
g'(1) = {1}
k = {} // 1 ~e k both f(1) & g(1) have element '1'
--------------------------------------------------
n=2
11 if ( f'(n) != NULL ) then rw="f" rw="f"
14 kf = not ( n e f(n) ) =TRUE //obsolete row
15 kg = not ( n e g(n) ) =TRUE
17 if ( rw == "f" ) then TRUE
18 kf = not ( n e f'(n) ) =TRUE //use new k from
f'
24 if ( kf == kg ) then TRUE
25 if (f'(n)=NULL) then f'(n) = f(n) //transfer subset
26 if (g'(n)=NULL) then g'(n) = g(n)
f'(1) = {1, 3}
f'(2) = {3}
g'(1) = {1}
g'(2) = {1, 3}
k = {2, } // 2 e k, both f(2) & g(2) miss element '2'
--------------------------------------------------
n = 3,4,5
f'(1) = {1, 3}
f'(2) = {3}
f'(3) = {2, 5}
f'(4) = {4}
f'(5) = {1, 2, 3, 4, 5}
g'(1) = {1}
g'(2) = {1, 3}
g'(3) = {1, 2}
g'(4) = {3, 4}
g'(5) = {5}
COMMON k = {2,3, ...}

CLA1 = A(n): E(m): Rm = ANTI (Rn)

CLA2 = A(p): A(d) d e {0,1,2..9}: E(i): Ri_p = d
& A(p): A(n): E(m) m>n: A(d) (Rn_p = d) -> (Rm_p = d)

CLA3 = A(n): A(d1): A(d2): A(d3): ... A(dn) d1..dn e {0,1,2..9}:
E(i): Ri_1=d1 & Ri_2=d2 ... Ri_n=dn