Pre-Processing What is the best amount of amortized preprocessing? E.g., for the 16x16 spatial dataset at right? Note that there is no count measurement associated with each point and similarity is simple spatial closeness. In a real image (say with 1 million pixels and the three RGB attributes in which we are interested in spectral closeness in R,G and B, not spatial closeness in x and y (horizontal and vertical positions) then the number of attributes is k=1..nbk where bk=log2(MaxValue(Ak)). x y z A B C D E N F G H I J K L M t u r s q n o l m j k h i p O P Q R S T U v d e f g 9 a b c 5 6 7 8 1 2 3 4 w

Pre-processing costs? Pairs within attributes first (what Taufik does). rc(a3^a2') no^ required = rc(a3) - rc(a3^a2) = 7-5=2 rc(a3^a0') no^ required = rc(a3) - rc(a3^a0) = 7-3=4 rc(a3^a1') no^ required = rc(a3) - rc(a3^a1) = 7-7=0 rc(a3'^a0) ^ req, (but just count black-0 red-1 combos = 19) rc(a3'^a1) ^ req, (but just count black-0 red-1 combos = 27) rc(a3'^a2) ^ req, (but just count black-0 red-1 combos = 18) ( a3^a2 and a3'^a2 in 1 instr or in || ?) rc(a3'^a0') no ^ req, = rc(a3') - rc(a3'^a0) = 49 - 19 = 30 rc(a3'^a2') no ^ req, = rc(a3') - rc(a3'^a2) = 49 - 18 = 31 (so far: 4 rc's out of 2 ANDs) rc(a3'^a1') no ^ req, = rc(a3') - rc(a3'^a1) = 49 - 27 = 22 a 1 3 4 a 3 1 7 a 3 1 7 a 1 2 a 3 1 7 a 2 1 3 k 1 2 5 6 3 4 7 8 9 a d e b c f g h j i l n m o U S T P Q p R O w v I J K L M G E C x y N H F z A D B q r s t u a 3 1 7 a 2 1 3 a 1 3 4 a 1 2 b 3 1 2 b 2 1 3 4 b 1 3 5 b 1 3 So far, 12 rootcounts are yielded by 6 AND operations. Note that the ANDs are all with Pa,3 or P'a,3 so parallelism and/or pipelining is possible (e.g., think about a future quantum computer in which (almost magically) multiple state values can be recorded (e.g., multple parallel AND results may be retained or at least the 4 result states of black/red 0/1 can be retained in register simaltaneously???)). 7 23 34 22 35 33 49 21 56 31 22 30 a3 a2 a1 a0 b3 b2 b1 b0 a3' a2' a1' a0' b3' b2' b1' b0' 19 27 18 5 7 3 2 4 a3 a2 a1 a0 b3 b2 b1 b0 a3' a2' a1' a0' b3' b2' b1' b0'

Pre-processing costs? rc(a2^a0') no^ required = rc(a2) - rc(a2^a0) = 23-7=16 rc(a2^a1') no^ required = rc(a2) - rc(a2^a1) = 23-13=10 rc(a2'^a1) ^ req, (but just count black-0 red-1 combos = 21) rc(a2'^a0) ^ req, (but just count black-0 red-1 combos = 15) rc(a2'^a0') no ^ req, = rc(a2') - rc(a2'^a0) = 33 - 15 = 18 rc(a2'^a1') no ^ req, = rc(a2') - rc(a2'^a1) = 33 - 21 = 12 a 2 1 3 a 1 2 a 1 3 4 a 2 1 3 k 1 2 5 6 3 4 7 8 9 a d e b c f g h j i l n m o U S T P Q p R O w v I J K L M G E C x y N H F z A D B q r s t u a 3 1 7 a 2 1 3 a 1 3 4 a 1 2 b 3 1 2 b 2 1 3 4 b 1 3 5 b 1 3 7 23 34 22 35 33 49 21 56 12 18 31 22 30 a3 a2 a1 a0 b3 b2 b1 b0 a3' a2' a1' a0' b3' b2' b1' b0' 19 15 27 21 13 7 18 10 16 5 7 3 2 4 a3 a2 a1 a0 b3 b2 b1 b0 a3' a2' a1' a0' b3' b2' b1' b0'

Pre-processing costs? rc(a1^a0') no^ required = rc(a1) - rc(a1^a0) = 34-12=22 rc(a1'^a0) ^ req, (but just count black-0 red-1 combos = 10) rc(a1'^a0') no ^ req, = rc(a1') - rc(a1'^a0) = 22 - 10 = 12 (total of 12 ANDs so far. a 1 3 4 a 1 2 k 1 2 5 6 3 4 7 8 9 a d e b c f g h j i l n m o U S T P Q p R O w v I J K L M G E C x y N H F z A D B q r s t u a 3 1 7 a 2 1 3 a 1 3 4 a 1 2 b 3 1 2 b 2 1 3 4 b 1 3 5 b 1 3 At this point we can note that we have all the a-attribute rootcounts (12 AND and RootCount operations required) preprocessed that are needed for TV analysis. We also note that it may be possible to produce this preprocessing information with 6 steps (since we humans can pick it off with the 6 AND/RC steps involving a3^a2, a3^a1, a3^a0, a2^a1, a2^a0, a1^a0. In fact, on the next slide, I will do it that way for those needed for the b-attribute). 7 23 34 22 35 33 49 21 56 12 12 18 31 22 30 a3 a2 a1 a0 b3 b2 b1 b0 a3' a2' a1' a0' b3' b2' b1' b0' 19 15 10 12 27 21 22 13 7 18 10 16 5 7 3 2 4 a3 a2 a1 a0 b3 b2 b1 b0 a3' a2' a1' a0' b3' b2' b1' b0'

Pre-processing costs? b 1 3 5 b 3 1 2 b 1 3 b 3 1 2 b 3 1 2 b 2 1 3 4 3 5 b 3 1 2 b 1 3 b 3 1 2 b 3 1 2 b 2 1 3 4 k 1 2 5 6 3 4 7 8 9 a d e b c f g h j i l n m o U S T P Q p R O w v I J K L M G E C x y N H F z A D B q r s t u a 3 1 7 a 2 1 3 a 1 3 4 a 1 2 b 3 1 2 b 2 1 3 4 b 1 3 5 b 1 3 7 23 34 22 35 33 49 21 56 17 16 16 12 12 18 31 22 30 a3 a2 a1 a0 b3 b2 b1 b0 a3' a2' a1' a0' b3' b2' b1' b0' 18 18 17 17 17 17 5 5 7 19 15 10 12 27 21 22 13 7 18 10 16 5 7 3 2 4 a3 a2 a1 a0 b3 b2 b1 b0 a3' a2' a1' a0' b3' b2' b1' b0'

Pre-processing costs? Pre-processing for TV-analysis is now complete . It took 24 AND/RC operation steps (or possibly only 12 if we had quadra-stable registers inwhich to do our ANDs and Counts???). Which operation steps are required to generate the information needed for 1-hi grid cell counts? (next slides). b 1 3 b 1 3 5 b 2 1 3 4 b 1 3 5 b 2 1 3 4 b 1 3 k 1 2 5 6 3 4 7 8 9 a d e b c f g h j i l n m o U S T P Q p R O w v I J K L M G E C x y N H F z A D B q r s t u a 3 1 7 a 2 1 3 a 1 3 4 a 1 2 b 3 1 2 b 2 1 3 4 b 1 3 5 b 1 3 7 23 34 22 35 33 49 21 56 9 9 8 17 16 16 12 12 18 31 22 30 a3 a2 a1 a0 b3 b2 b1 b0 a3' a2' a1' a0' b3' b2' b1' b0' 18 14 14 21 18 13 12 22 19 17 12 15 17 17 17 5 5 7 19 15 10 12 27 21 22 13 7 18 10 16 5 7 3 2 4 a3 a2 a1 a0 b3 b2 b1 b0 a3' a2' a1' a0' b3' b2' b1' b0'

rc(a3^b3') = rc(a3) - rc(a3^b3) = 7-5 = 2 Pre-processing costs? rc(a3^b3') = rc(a3) - rc(a3^b3) = 7-5 = 2 rc(a3'^b3) = rc(b3) - rc(a3^b3) = 22-5 = 17 rc(a3'^b3') = total - rc(a3^b3)-rc(a3^b3'(-rc(a3'^b3)=56-5-2-17=32 a 3 1 7 b 3 1 2 b 1 3 a 3 1 7 b 2 1 3 4 a 3 1 7 a 3 1 7 b 1 3 5 k 1 2 5 6 3 4 7 8 9 a d e b c f g h j i l n m o U S T P Q p R O w v I J K L M G E C x y N H F z A D B q r s t u a 3 1 7 a 2 1 3 a 1 3 4 a 1 2 b 3 1 2 b 2 1 3 4 b 1 3 5 b 1 3 similarly, rc(a3^b2)=6 rc(a3^b2')=1 rc(a3'^b2)=28 rc(a3'^b2')=21 similarly, rc(a3^b1)=6 rc(a3^b1')=1 rc(a3'^b1)=29 rc(a3'^b1')=20 similarly, rc(a3^b0)=4 rc(a3^b0')=3 rc(a3'^b0)=29 rc(a3'^b0')=20 Note that these 4 cells require 1 AND/RC op and that suffices to do 1-hi grid cell (smoothing) core analysis. 1-hi smoothing yields the counts: 5 2 17 32 7 23 34 22 35 33 49 21 56 9 9 8 17 16 16 12 12 18 31 22 30 32 21 20 20 a3 a2 a1 a0 b3 b2 b1 b0 a3' a2' a1' a0' b3' b2' b1' b0' 29 18 14 14 21 29 18 13 12 22 19 28 17 12 15 17 17 17 17 5 5 7 19 15 10 12 27 21 22 13 7 18 10 16 5 7 3 5 6 6 4 2 4 2 1 1 3 a3 a2 a1 a0 b3 b2 b1 b0 a3' a2' a1' a0' b3' b2' b1' b0'

similarly, rc(a2^b0)=15 rc(a2'^b0)=18 rc(a2^b0')=8 rc(a2'^b0')=15 Pre-processing costs? similarly, rc(a2^b0)=15 rc(a2'^b0)=18 rc(a2^b0')=8 rc(a2'^b0')=15 similarly, rc(a2^b2)=19 rc(a2'^b2)=15 rc(a2^b2')=4 rc(a2'^b2')=18 similarly, rc(a2^b3)=14 rc(a2'^b3)=8 rc(a2^b3')=9 rc(a2'^b3')=25 similarly, rc(a2^b1)=16 rc(a2'^b1)=19 rc(a2^b1')=7 rc(a2'^b1')=14 a 2 1 3 b 1 3 5 b 3 1 2 b 2 1 3 4 b 1 3 k 1 2 5 6 3 4 7 8 9 a d e b c f g h j i l n m o U S T P Q p R O w v I J K L M G E C x y N H F z A D B q r s t u a 3 1 7 a 2 1 3 a 1 3 4 a 1 2 b 3 1 2 b 2 1 3 4 b 1 3 5 b 1 3 7 23 34 22 35 33 49 21 56 9 9 8 17 16 16 12 12 18 25 18 18 15 31 22 30 32 21 20 20 a3 a2 a1 a0 b3 b2 b1 b0 a3' a2' a1' a0' b3' b2' b1' b0' 29 18 18 14 14 21 29 19 18 13 12 22 19 28 15 17 12 15 17 17 17 17 8 5 5 7 19 15 10 12 27 21 22 13 7 14 19 16 15 18 10 16 9 4 14 8 5 7 3 5 6 6 4 2 4 2 1 1 3 a3 a2 a1 a0 b3 b2 b1 b0 a3' a2' a1' a0' b3' b2' b1' b0'

similarly, rc(a0^b0)=9 rc(a0'^b0)=24 rc(a0^b0')=13 rc(a0'^b0')=10 Pre-processing costs? similarly, rc(a0^b0)=9 rc(a0'^b0)=24 rc(a0^b0')=13 rc(a0'^b0')=10 (16 additional AND operations were required for the mixed attribute pairs. The total was 28 ANDs) similarly, rc(a0^b1)=15 rc(a0'^b1)=20 rc(a0^b1')=7 rc(a0'^b1')=14 similarly, rc(a0^b2)=12 rc(a0'^b2)=22 rc(a0^b2')=10 rc(a0'^b2')=12 similarly, rc(a0^b3)=7 rc(a0'^b3)=15 rc(a0^b3')=15 rc(a0'^b3')=19 similarly, rc(a1^b1)=22 rc(a1'^b1)=13 rc(a1^b1')=12 rc(a1'^b1')=9 similarly, rc(a1^b0)=20 rc(a1'^b0)=13 rc(a1^b0')=14 rc(a1'^b0')=9 similarly, rc(a1^b3)=17 rc(a1'^b3)=5 rc(a1^b3')=17 rc(a1'^b3')=17 similarly, rc(a1^b2)=22 rc(a1'^b2)=12 rc(a1^b2')=12 rc(a1'^b2')=10 a 1 2 b 1 3 5 b 3 1 2 a 1 3 4 b 1 3 b 1 3 5 b 2 1 3 4 b 3 1 2 b 2 1 3 4 b 1 3 k 1 2 5 6 3 4 7 8 9 a d e b c f g h j i l n m o U S T P Q p R O w v I J K L M G E C x y N H F z A D B q r s t u a 3 1 7 a 2 1 3 a 1 3 4 a 1 2 b 3 1 2 b 2 1 3 4 b 1 3 5 b 1 3 7 23 34 22 35 33 49 21 56 9 9 8 17 16 16 19 12 14 10 12 17 10 9 9 12 18 25 18 18 15 31 22 30 32 21 20 20 a3 a2 a1 a0 b3 b2 b1 b0 a3' a2' a1' a0' b3' b2' b1' b0' 29 18 13 24 18 14 14 21 29 19 13 20 18 13 12 22 19 28 15 12 22 17 12 15 17 17 17 17 8 5 15 5 5 7 7 12 15 9 19 15 10 15 10 7 13 12 17 22 22 20 27 21 22 17 12 12 14 13 7 14 19 16 15 18 10 16 9 4 14 8 5 7 3 5 6 6 4 2 4 2 1 1 3 a3 a2 a1 a0 b3 b2 b1 b0 a3' a2' a1' a0' b3' b2' b1' b0'

For TV analysis, we need to preprocess the 24 red AND/RC operation steps. k 1 2 5 6 3 4 7 8 9 a d e b c f g h j i l n m o U S T P Q p R O w v I J K L M G E C x y N H F z A D B q r s t u a 3 1 7 a 2 1 3 a 1 3 4 a 1 2 b 3 1 2 b 2 1 3 4 b 1 3 5 b 1 3 a3 a2 a1 a0 b3 b2 b1 b0 a3' a2' a1' a0' b3' b2' b1' b0' 5 2 18 7 23 34 22 35 33 49 21 56 31 27 3 4 19 30 13 10 12 16 15 17 9 14 8 32 6 28 1 29 20 25 24

We can think of the preprocessing as filling RoloDex cards (Note that this RoloDex is built to fit TV-analysis - i.e., 2-D cards with the primary one containing the needed dual-AND P-tree rootcounts needed for TV analysis) dual rc card A+A' Attributes and Complements (e.g., for 1-hi data) a b a' b' a3 a2 a1 a0 b3 b2 b1 b0 a3' a2' a1' a0' b3' b2' b1' b0' 5 2 18 7 23 34 22 35 33 49 21 56 31 27 3 4 19 30 13 10 12 16 15 17 9 14 8 32 6 28 1 29 20 25 24 1 1 A+A' e.g., a3-tri-Ptree rc slice card A+A' e.g., a3b2-tri-Ptree rc slice card

For 1-hi grid analysis, need total count, 56, the rc of the singles rc(Pa,3)=7 rc(Pb,3)=22 the rc of the dual rc(Pa,3^Pb,3) = 5 n o l m j k h i v x y z A B C D E N F G H I J K L M q p O P Q R S T U d e f g 9 a b c 5 6 7 8 1 2 3 4 t u r s w b,3=1 rc(Pa3^Pb3) = 5 7 23 34 22 35 33 49 21 56 rc(Pb,3) - rc(Pa3^Pb3) =22 -5 = 17 9 9 8 17 16 16 19 12 14 10 rc(Pa,3) - rc(Pa3^Pb3) = 7-5 = 2 b,3=0 12 17 10 9 9 56 - 5 - 17 - = 32 12 18 25 18 18 15 31 22 30 32 21 20 20 a,3=0 a,3=1 a3 a2 a1 a0 b3 b2 b1 b0 a3' a2' a1' a0' b3' b2' b1' b0' The lower left 1-hi cell is half full and therefore the most core of the 4. Upper left is over 1/4th full and is next most core The other two are not very dense (as 1-hi cells). The way to view 1-hi smoothing is to consider the space to still have 56 points but to have 5 points at (11.5, 11.5) 2 points at (11.5, 3.5) 17 points at ( 3.5, 11.5) and 32 points at ( 3.5, 11.5) 5 2 17 32 29 18 13 24 18 14 14 21 29 19 13 20 18 13 12 22 19 28 15 12 22 17 12 15 17 17 17 17 8 5 15 5 5 7 7 12 15 9 19 15 10 15 10 7 13 12 17 22 22 20 27 21 22 17 12 12 14 13 7 14 19 16 15 18 10 16 9 4 14 8 5 7 3 5 6 6 4 2 4 2 1 1 3 a3 a2 a1 a0 b3 b2 b1 b0 a3' a2' a1' a0' b3' b2' b1' b0'

To drill into a j-hi cell. Theorem: In R(A1 To drill into a j-hi cell? Theorem: In R(A1..Ad), the j-hi Cell identified by p=(p1..pd) where pk=pk,bk-1 ..pk,bk-j and pi,j{0,1} (i.e., identified by the common j-hi bits of its content points in each dimension), we only need Ppattern for all super-(j+1)-patterns of p formed by appending 1-bits. For n=2 we have already shown it. For n=3 the following may convince ;-) Within the j-hi cell identified by a fixed pattern of j-high-order bits in all dimensions, p, we need only the P-tree masks for the following 8 objects So we have the following done In general, for n dimensions, we must have: n n n + + ... + P-trees rootcounted 1 2 n This - transparent ones gives aj=0 bj=1 cj=0 same for aj=0 bj=1 cj=1 aj=1 bj=1 cj=1 aj=1 bj=1 cj=1 same for aj=1 bj=1 cj=0 bj=1 aj=1 bj=1 Of course to drill down one more bit level, we need, not only the rc of that j+1-hi cell but its Ptree Mask plus the Ptree masks of each sub- rectangle generated by adding 1-bits (as shown on this slide). So if we are planning to drill further we might as well generate all cell Ptrees, not just their rcs. Another thought: If we approach it from top down, since we are limiting the j-level of the j-hi cell analysis, why not also limit the bit granularity of the TV-analysis in the same way (i.e., as preprocessing calculate Ptrees for all patterns down to a given j-hi level, then, use only those Ptrees (with their rootcounts) to compute TV contour nbrhds and grid cell 'contours" bj=1 cj=1 cj=1 aj=1 cj=1 - aj=1 bj=0 cj=1 = This - transparent ones gives aj=0 bj=0 cj=1 aj=1 Total - transparent ones gives aj=0 bj=0 cj=0 This - transparent ones gives aj=1 bj=0 cj=0 b c a

R(A1..An) TV(a)=xR(x-a)o(x-a) = xRd=1..n(xd2 - 2adxd + ad2) = xRd=1..n(k2kxdk)2 - 2xRd=1..nad(k2kxdk) + xRd=1..nad2 = xd(i2ixdi)(j2jxdj) - 2xRd=1..nad(k2kxdk) + xRd=1..nad2 = xdi,j 2i+jxdixdj - 2 k2k dad xxdk + x|a|2 = i,j 2i+j dxxdixdj - |R||a|2 So, 2 k2k dad |Pdk| + TV(a) = i,j2i+j d|Pdi^dj| - |R||a|2 k2k+1 dad |Pdk| +

d=2, i,j,k=3..0. With 1-hi smoothing, becomes TV(a) = i,j2i+j d|Pdi^dj| - |R||a|2 k2k+1 dad |Pdk| + 26 d |Pd3^d3| - 24 d ad |Pd3| + 56|a|2 So TV1hi(a) = 64*(7+22) - 16*(7a1+22a2) + 56|a|2 = 1856 - 112a1 - 352a2 - 56|a|2 = 1856 - 112a1 - 352a2 + 56(a12+a22) n o l m j k h i v x y z A B C D E N F G H I J K L M q p O P Q R S T U d e f g 9 a b c 5 6 7 8 1 2 3 4 t u r s w 23' 34 13' 49 32 23 22 17 13 7 5 2 56 13 23 13' 23'

= xRd=1..n(xd2 - 2adxd + ad2) i,j,k bit slices indexes R(A1..An) TV(a)=xR(x-a)o(x-a) If we use d for a index variable over the dimensions, = xRd=1..n(xd2 - 2adxd + ad2) i,j,k bit slices indexes = xRd=1..n(k2kxdk)2 - 2xRd=1..nad(k2kxdk) + |R||a|2 = xd(i2ixdi)(j2jxdj) - 2xRd=1..nad(k2kxdk) + |R||a|2 = xdi,j 2i+jxdixdj - 2 k2k dad xxdk + |R||a|2 = i,j,d 2i+j xxdixdj - |R||a|2 So, 2 k2k dad |Pdk| + TV(a) = i,j,d 2i+j |Pdi^dj| - |R||a|2 k2k+1 dad |Pdk| + or collecting all truly single predicates: TV(a) = i>j,d 2i+j+1 |Pdi^dj| + |R| (a12+..+an2) k,d (22k- 2k+1ad) |Pdk| + I note that the first term (the only one involving dual bitslice predicates) does not depend upon a at all! That means whatever the first term value is, it can be subtracted from the derived attr values, TV(a), giving a new derived attribute with the very same contours as TV and which can be calculated simply from the basic Ptree rootcounts alone!!!! Can that be right? If so, then the preprocessing for SMART-TV is zero! (given we have basic P-trees).