The length of each appearing bit N sequence equals the length of the data sequence

Chapter 3 Bit Sequence Representation

In our approach, the information in the data sequence is stored as the form of bit

sequences. According to this representation, the frequencies of candidate patterns

could be checked more efficiently during the mining process.

In this chapter, chapter 3.1 will introduce the appearing bit sequence and the bit

index table. How to apply the appearing bit sequences of patterns to compute the

“frequency” of candidate patterns with fault tolerance quickly is introduced in chapter

3.2 and 3.3.

3.1 Appearing Bit Sequences

For each kind of data item N in the data sequence, N has a corresponding

appearing bit sequence (denoted asAppear ). The length of each appearing bit _N

sequence equals the length of the data sequence. The leftmost bit is numbered as bit

1 and the numbering increases to the rightmost bit. In other words, if some data item

appears on the ith position of the data sequence, bit i in the appearance bit sequence of

this data item is set to be 1; otherwise, it is set to be 0. A bit index table is used to

store the appearing bit sequences for all the data items in the data sequence. Take

DSeq = ABCDABCACDEEABCCDEAC as an example. Its corresponding bit index

table is shown as Table 3.1.

Table 3.1: The bit index table of “ABCDABCACDEEABCCDEAC”

Data Item Appearing Bit Sequence (Appear ) _N

A 10001001000010000010

B 01000100000001000000

C 00100010100000110001

D 00010000010000001000

E 00000000001100000100

From the bit index table, the number of bits with value 1 inAppear for a data _N

item N equals to freq(N) in DSeq. Therefore, the frequency of a data item can be

obtained without needing to scan the data sequence repeatedly. The idea is also

applicable for a longer pattern of a data sequence. We use the following example to

show this idea.

Example 3.1 The bit index table of “ABCDABCACDEEABCCDEAC” is given as

shown in Table 3.1.

(1) Suppose we would like to getAppear_AB. If bit i inAppear_AB contains value 1,

it denotes a position where “AB” appears. Therefore, “A” must appear on

position i and the next position i+1 must contain “B”. The relative

information about the positions where “A” and “B” appears is stored in

AppearA and Appear_B , respectively. So can use the following steps to getAppear_AB.

Step1. Get the appearing bit sequence of the data item “B” from Table 1, 0001000000

0100010000

B =

Appear .

Step2. Perform the left shift operation one (= AB −1) bit on Appear_B(shift

bit (i+1) to bit i, where1≤ i<19 , and set bit 20 to be 0),

0010000000 1000100000

) 1 , (

_shift Appear_B =

l .

Step3. Perform an and operation on the result of Step2 and Appear_A to

getAppear_AB. Thus the resultant bit sequence:

0010000000 1000100000

) 1 , (

_ =

∧ _B

A l shift Appear

Appear .

(2) After gettingAppear_AB, suppose we would like to getAppear_ABC. When

“AB” appears on position i and “C” appears on position i+2, it implies pattern

“ABC” appears on position i. Therefore, we can get Appear_ABC by

performing the following steps.

Step1. Obtain the appearing bit sequence of the last note “C” from Table 1, 0000110001

0010001010

C =

Appear .

Step2. Perform the left shift operation two (= ABC −1) bits onAppear , _C

0011000100 1000101000

) 2 , (

_shift Appear_C = l

Step3. Perform an and operation on the result of Step2 and Appear_AB to

getAppear_ABC. Thus the resultant bit sequence:

The bits with value 1 in Appear_AB implies those positions where “AB” begins to

appear. Therefore, the number of these bits equals the frequency of “AB” in DSeq,

that is 3. Similarly, fromAppear_ABC, the frequency of “ABC” in DSeq, 3, could be

obtained efficiently.

Observing Example 3.1 carefully, we can get the following rules to getAppear_P

for a pattern P. Suppose a pattern P=P1P2KP_m (m≥2)is given, where P _i

) , , 1

(i= K m is a data item. Let P′=P₁P₂KP_m−1 and P be denoted by X. Then _m

AppearP can be deducted fromAppear_P'andAppear_X according to the following recursive formula, where l_shift(b,n,c)means to perform left shift n bits on b, and

the rightmost bit on b is filled with constant c(c=0 or 1). If the parameter c is omitted

from the function, the default value of c is set to be 0.







−

∧

=

= =

. ),

1 , (

_

, 1 ,

'

' Appear l shift Appear P otherwise Appear

P if Appear

Appear

X P

X P

P P

(3.1)

3.2 Appearing Bit Sequences of Insertion Fault Tolerance

By extending the representations of appearing bit sequence, the fault-tolerant

appearing bit sequences are designed to represent the appearing positions of a pattern

with fault tolerance. Given a fault-tolerance δ (δ_Iorδ_D), the appearing bit sequence

of a pattern P in a data sequence, denoted asFT-Appear_P⁺(δ)/FT-Appear_P⁻(δ),

represents the positions where the data sequence IFT/DFT-contains P under fault

tolerance δ . The methods for getting FT-Appear_P⁺(δ_I) and FT-Appear_P⁻(δ_D)

systematically are described in this chapter and the next chapter separately.

Considering the insertion fault tolerance, we define the appearing bit sequence of

a pattern P with E numbers of insertion errors, denoted as Appear_P⁺(E). The bits

with value 1 in Appear_P⁺(E)represent those positions where the data sequence

FT-contains P with E insertion errors. According to [Def. 2.4], there are (δ_I +1)

situations that a pattern P IFT-appears in DSeq under fault toleranceδ_I. That is,

DSeq FT-contains P with 0, 1, 2,…,δ_I insertion errors. In other words, performing

δI or operations on (δ_I +1) appearing bit sequences: Appear_P⁺(0),Appear_P⁺(1), )

( and

, ), 2

( _{P I}

P Appear

Appear⁺ _K ⁺ δ , )FT-Appear_P⁺(δ_I could be obtained. Figure 3.1

illustrates the relationship between FT-Appear_P⁺(δ_I)andAppear_P⁺(E)when δ_I= 2

for example patterns “A”, “AB”, “ABC”, “ABCD”, and “ABCDE” .

Figure 3.1 Example of the relationship between FT-Appear_P⁺(δ_I)andAppear_P⁺(E)

In Figure 3.1, note that FT-Appear_A⁺(2)equals toAppear_A⁺(0)directly because it

is not possible to insert 1 or 2 data items in the “middle” of pattern “A” to get a

sub-pattern of the data sequence. Therefore, we can conclude the following rule.

[Rule 3.1] Whenever a given pattern P such that P =1 and insertion fault-tolerance

isδ_I, then P = A

FT-Appear_A⁺(2)= Appear_A⁺(0)∨Appear_A⁺(1)∨Appear_A⁺(2)

P = AB

FT-Appear_AB⁺ (2)= Appear_AB⁺ (0)∨ Appear_AB⁺ (1)∨ Appear_AB⁺ (2)

P = ABC

FT-Appear_ABC⁺ (2)= Appear_ABC⁺ (0)∨ Appear_ABC⁺ (1)∨Appear_ABC⁺ (2)

P = ABCD

) 2 ( )

1 ( )

0 ( )

2 (

-Appear_ABCD⁺ = Appear_ABCD⁺ ∨Appear_ABCD⁺ ∨ Appear_ABCD⁺ FT

P = ABCDE

) 2 ( )

1 ( )

0 ( )

2 (

-Appear_ABCDE⁺ = Appear_ABCDE⁺ ∨Appear_ABCDE⁺ ∨ Appear_ABCDE⁺ FT

E≤δI

≤

∀ 1 , 0Appear_P⁺(E)= (represented byDSeq numbers of bits with 0s)

(3.2)

The remaining problem is how to get eachAppear_P⁺(E) , where P >1and

E≤δI

≤

0 . SinceAppear_P⁺(0) represents the locations where DSeq FT-contains P with zero insertion error, it implies the same information represented inAppear_P.

Therefore, the way of getting Appear_P⁺(0) is the same as getting Appear_P(described

in the previous chapter).

When1≤E≤δ_I, )Appear_P⁺(E also can be obtained by performing the left shift

and and operations on appearing bit sequences of sub-pattern of P according to the

following lemma.

[Lemma 3.1]

Given a patternP=P1P2KP_m, where P _i (i=1,K,m)is a data item. Let P′

denote the sub-pattern P₁P₂KP_m−1 of P and X denote theP . DSeq FT-contains _m

pattern P with E insertion errors on position i, iff DSeq FT-contains pattern P′ with k

insertion errors on position i (0≤k ≤E) and X appears on position i+( P +E)− . 1

Proof. P′ appears in DSeq from position i to (i+ P′ −1)+k (with k insertion errors).

So there exists E−k insertion errors between P′ and X. It implies X must appear on

position i+( P +E) 1− , because (i+ P′ −1+k) + (E−k) + 1 = i+(P′+1)+E−1 +

= i ( P +E) 1− (QP′ 1+ = P ). ＃

In other words, X must appear on the ( P + E−1)th position on the right hand

side of position i. Therefore, the way of gettingAppear_P⁺(E)can be expressed as the

following recursive formula for0< E≤δ_I.







− +

∧

=

= ₊

=

+ ⁽∨ ^{( )) _ ( , 1), .}

, 1 0s)

with bits of numbers by

ed (represent 0

) (

' 0

otherwise E

P Appear shift

l k Appear

P if DSeq

E Appear

X P

E

k

P (3.3)

To combine Formulas (3.1) and (3.3), a recursive function of gettingAppear_P⁺(E),

where0≤E≤δ_Iis defined as follows.

[Def. 3.1] (Recursive function of getting Appear_P⁺(E) ) Suppose a pattern

Pm

P P

P= 1 2K is given. Let P′ denote the sub-pattern P₁P₂KP_m−1 of P and X

denote the last data item P_m . When insertion fault tolerance δ_I is

given, Appear_P⁺(E), where0≤E≤δ_I , is obtained from the following recursive

function.

If P =1, then

P

P Appear

Appear⁺(0)= ;

∀ 1≤ E≤δ_I, 0Appear_P⁺(E)= (represented byDSeq numbers of bits with 0s);

Else

( ) ( _'( )) _ ( , 1)

0

− +

∧

= ⁺

=

+ ^E ∨ ^{Appear k l shift Appear P E}

Appear _{p X}

E k P

Example 3.2 Given the bit index table of “ABCDABCACDEEABCCDEAC” as

shown in Table 1. Assume δ_I =1 , the process of getting Appear_AB⁺ (1)

andAppear_ABC⁺ (1) is shown as follows.

(1) )Appear_AB⁺ (1

Step1. GetAppear_B =01000100000001000000from the bit index table.

Step2. Perform an or operation onAppear_A⁺(0)andAppear_A⁺(1). According

to formula (3.2), Appear_A⁺(1)=0, andAppear_A⁺(0)= Appear_A. The

result of the or operation is assigned to temporal variable s.

0010000010 1000100100

) 1 ( )

0

( ∨ =

= Appear_A⁺ Appear_A⁺ s

Step3. Perform the left shift operation two (= AB +1−1) bits onAppear_B,

0100000000 0001000000

) 2 , (

_ =

=l shift Appear_B t

Step4. Perform an and operation on s and t to getAppear_AB⁺ (1). Thus the

resultant bit sequence: s∧ t =00000000000000000000.

(2) Appear_ABC⁺ (1)

Step1. GetAppear_C =00100010100000110001 from the bit index table.

Step2. Perform an or operation onAppear_AB⁺ (0)andAppear_AB⁺ (1), then assign

it to s. SinceAppear_AB⁺ (0) is gotten based on formula (3.1) and

) 1

+ (

AppearAB is known from the previous result of this example, the resultant appearing bit sequence s= Appear_AB⁺ (0)∨Appear_AB⁺ (1)

0010000000 1000100000

= .

Step3. Perform the left shift operation three (= ABC +1−1) bits

onAppear , 0110001000_C t =l_shift(Appear_C,3)=0001010000 .

Step4. Perform an and operation on s and t to getAppear_ABC⁺ (1). Thus the

resultant bit sequence: s∧ t =00000000000010000000.

Figure 3.2 illustrates the process to get Appear_P⁺(E)recursively for a sample

pattern “ABCDE”, whereδ_I =2.

Figure 3.2 Example of the way of gettingAppear_ABCDE⁺ (E)recursively P = A

A

A Appear

Appear⁺(0)=

000 000 ) 1

( = K

+

AppearA

000 000 ) 2

( = K

+

AppearA

P = AB

) 1 , (

_ ) 0 ( )

0

( _{A B}

AB Appear l shift Appear

Appear⁺ = ⁺ ∧

) 2 , (

_ )) 1 ( )

0 ( (

) 1

( _{A A B}

AB Appear Appear l shift Appear

Appear⁺ = ⁺ ∨ ⁺ ∧

) 3 , (

_ )) 2 ( )

1 ( )

0 ( (

) 2

( _{A A A B}

AB Appear Appear Appear l shift Appear

Appear⁺ = ⁺ ∨ ⁺ ∨ ⁺ ∧

P = ABC

) 2 , (

_ ) 0 ( )

0

( _{AB C}

ABC Appear l shift Appear

Appear⁺ = ⁺ ∧

) 3 , (

_ )) 1 ( )

0 ( (

) 1

( _{AB AB C}

ABC Appear Appear l shift Appear

Appear⁺ = ⁺ ∨ ⁺ ∧

) 4 , (

_ )) 2 ( )

1 ( )

0 ( (

) 2

( _{AB AB AB C}

ABC Appear Appear Appear l shift Appear

Appear⁺ = ⁺ ∨ ⁺ ∨ ⁺ ∧

P = ABCD

) 3 , (

_ ) 0 ( )

0

( _{ABC D}

ABCD Appear l shift Appear

Appear⁺ = ⁺ ∧

) 4 , (

_ )) 1 ( )

0 ( (

) 1

( _{ABC ABC D}

ABCD Appear Appear l shift Appear

Appear⁺ = ⁺ ∨ ⁺ ∧

) 5 , (

_

)) 2 ( )

1 ( )

0 ( (

) 2 (

D

ABC ABC

ABC ABCD

Appear shift

l

Appear Appear

Appear Appear

∧

∨

∨

= ^{+ + +}

+

P = ABCDE

) 4 , (

_ ) 0 ( )

0

( _{ABCD E}

ABCDE Appear l shift Appear

Appear⁺ = ⁺ ∧

) 5 , (

_ )) 1 ( )

0 ( (

) 1

( _{ABCD ABCD E}

ABCDE Appear Appear l shift Appear

Appear⁺ = ⁺ ∨ ⁺ ∧

) 6 , (

_

)) 2 ( )

1 ( )

0 ( (

) 2 (

E

ABCD ABCD

ABCD ABCDE

Appear shift

l

Appear Appear

Appear Appear

∧

∨

∨

= ^{+ + +}

+

Finally, FT-Appear_P⁺(δ_I) can be obtained by performing ()

0

i Appear_P

i

I +

∨^δ= ^.

) ( -freq P

FT _DSeq equals to the number of bits with value 1 inFT-Appear_P⁺(δ_I).

Therefore the insertion fault-tolerant frequency of a pattern P could be counted

efficiently to evaluate whether P is a FT-RP or not.

Example 3.3 Follows the result shown in Example 3.1 and Example 3.2,

0010000000 1000100000

) 1 ( )

0 ( )

1 (

-Appear_ABC⁺ = Appear_ABC⁺ ∨Appear_ABC⁺ =

FT , thus

under insertion fault tolerance 1, FT-freq_DSeq("ABC")=3.

To avoid the duplicated computations of performing or and left shift operations

to get Appear_P⁺(E) for various E, we modify the recursive function of

getting Appear_P⁺(E) to show the recurrent relations between temp variables for

computing )Appear_P⁺(E andAppear_P⁺(E−1).

[Def. 3.2] (Modified recursive function of gettingAppear_P⁺(E)) Given a pattern

Pm

P P

P= 1 2K . Let P′ denote the sub-pattern P₁P₂KP_m−1 of P and X denote the

last data item P . When insertion fault tolerance _m δ_I is given, Appear_P⁺(E)

where0≤E≤δ_I, is obtained from the following recursive function.

If P =1, then

P

P Appear

Appear⁺(0)= ;

E≤δI

≤

∀ 1 , 0Appear_P⁺(E)= (represented byDSeq numbers of bits with 0s);

Else

IfE=0, then

) 0 ( )

( _'

1

= Appear_P+

E

temp ;

) 1 , (

_ )

2(E =l shift Appear P −

temp _X

Else

) ( )

1 ( )

( _{1 '}

1 E temp E Appear E

temp = − ∨ _P⁺ ;

) 1 ), 1 ( ( _ )

( ₂

2 E =l shift temp E−

temp ;

) ( )

( )

(E temp₁ E temp₂ E

Appear_P⁺ = ∧

Figure 3.3 shows the results after modifying Figure 3.2 based on [Def. 3.2].

Figure 3.3 Modification of Figure 3.2 P = A

A

A Appear

Appear⁺(0)=

000 000 ) 1

( = K

+

AppearA

000 000 ) 2

( = K

+

AppearA

P = AB

) 0 ( )

0

1(

= Appear_A+

temp

) 1 , (

_ ) 0

2( l shift AppearB

temp =

) 0 ( )

0 ( )

0

( temp₁ temp₂ Appear_AB⁺ = ∧

) 1 ( )

0 ( )

1

( ₁

1

∨ +

=temp Appear_A temp

) 1 ), 0 ( ( _ ) 1

( ₂

2 l shift temp temp =

) 1 ( )

1 ( )

1

( temp₁ temp₂ Appear_AB⁺ = ∧

) 2 ( )

1 ( )

2

( ₁

1

∨ +

=temp Appear_A temp

) 1 ), 1 ( (

_ ) 2

( ₂

2 l shift temp temp =

) 2 ( )

2 ( )

2

( temp₁ temp₂ Appear_AB⁺ = ∧ P = ABC

) 0 ( )

0

1(

= Appear_AB+

temp

) 2 , (

_ ) 0

2( l shift AppearC

temp =

) 0 ( )

0 ( )

0

( temp₁ temp₂ Appear_ABC⁺ = ∧

) 1 ( )

0 ( )

1

( ₁

1

∨ +

=temp Appear_AB temp

) 1 ), 0 ( ( _ ) 1

( ₂

2 l shift temp temp =

) 1 ( )

1 ( )

1

( temp₁ temp₂ Appear_ABC⁺ = ∧

) 2 ( )

1 ( )

2

( ₁

1

∨ +

=temp Appear_AB temp

) 1 ), 1 ( (

_ ) 2

( ₂

2 l shift temp temp =

) 2 ( )

2 ( )

2

( temp₁ temp₂ Appear_ABC⁺ = ∧

Figure 3.3 Modification of Figure 3.2 (Continue)

3.3 Appearing Bit Sequences of Deletion Fault Tolerance

Similar to the insertion fault tolerance, we define the appearing bit sequence of a P = ABCD

) 0 ( )

0

1(

= Appear_ABC+

temp

) 3 , (

_ ) 0

2( l shift AppearD

temp =

) 0 ( )

0 ( )

0

( temp₁ temp₂ Appear_ABCD⁺ = ∧

) 1 ( )

0 ( )

1

( ₁

1

∨ +

=temp Appear_ABC temp

) 1 ), 0 ( ( _ ) 1

( ₂

2 l shift temp temp =

) 1 ( )

1 ( )

1

( temp₁ temp₂ Appear_ABCD⁺ = ∧

) 2 ( )

1 ( )

2

( ₁

1

∨ +

=temp Appear_ABC temp

) 1 ), 1 ( ( _ ) 2

( ₂

2 l shift temp temp =

) 2 ( )

2 ( )

2

( temp₁ temp₂ Appear_ABCD⁺ = ∧ P = ABCDE

) 0 ( )

0

1(

= Appear_ABCD+

temp

) 4 , (

_ ) 0

2( l shift AppearE

temp =

) 0 ( )

0 ( )

0

( temp₁ temp₂ Appear_ABCDE⁺ = ∧

) 1 ( )

0 ( )

1

( ₁

1

∨ +

=temp Appear_ABCD temp

) 1 ), 0 ( ( _ ) 1

( ₂

2 l shift temp temp =

) 1 ( )

1 ( )

1

( temp₁ temp₂ Appear_ABCDE⁺ = ∧

) 2 ( )

1 ( )

2

( ₁

1

∨ +

=temp Appear_ABCD temp

) 1 ), 1 ( ( _ ) 2

( ₂

2 l shift temp temp =

) 2 ( )

2 ( )

2

( temp₁ temp₂ Appear_ABCDE⁺ = ∧

value 1 in Appear_P⁻(E)represent those positions where the data sequence FT-contains

P with E deletion errors.

Suppose a pattern P=P1P2KP_m is given. Let Y denote the first data item

and P ′′ denote the sub-pattern P2P3…Pm of P. Different fromFT-Appear_P⁺(δ_I) ,

) ( -Appear_{P D}

FT ⁻ δ represents the positions where Y appears and DSeq FT-contains P ′′

on the next positions with at most δ_D deletion errors. Therefore, when finding a

position j where DSeq FT-contains P ′′ with 0, 1, 2,…, or δ_D deletion errors, we can

find the position ( j−1) where DSeq DFT-contains P under fault tolerance δ_D if

position ( j−1) contains Y. In other words, after performing δ_D or operations on

(δ_D +1) appearing bit sequences:Appear_P⁻_′′(0),Appear_P⁻_′′(1), …,Appear_P⁻_′′(δ_D −1), and

) ( _D

AppearP⁻_′′ δ , then performing a left shift operation on the previous result, and finally performing an and operation with AppearY, )FT-Appear_P⁻(δ_D could be

obtained. Figure 3.4 illustrates the relationship between FT-Appear_P⁻(δ_D)

andAppear_P⁻_′′(E)when δ_D= 2 for example patterns “A”, “AB”, “ABC”, “ABCD”,

and “ABCDE”. Note that if |P| ≤δ_D+1, the rightmost bit is filled with 1 when

performing the left shift operation because the bit is considered as “don’t care” bit on

the next performed and operation. Otherwise, 0 is filled to the rightmost bit.