Full Proceedings (PDF)

RAMiCS 2015

15th Int. Conf. on Relational and Algebraic Methods in Computer Science

Proceedings of the PhD/MSc Student Track Short papers / Extended abstracts

RAMiCS 2015, Hotel do Parque, Bom Jesus, Braga, 28 Sep–01 Oct, 2015

Local Organization by

HASLab / INESC TEC and University of Minho

Edited by

Wolfram Kahl, Michael Winter and Jos´e N. Oliveira

Preface

T

he RAMiCS conference series is the main forum for Relational and Alge- braic Methods in Computer Science. Special focus lies on formal methods for software engineering, logics of programs and links with neighbouring dis- ciplines.

This conference series finds its origins in the 38th Banach Semester on Alge- braic Methods in Logic and their Computer Science Application in Warsaw, Poland, September and October 1991. Adapting essentially a one-and-a-half year rhythm, the first eleven RelMiCS conferences were held from 1994 to 2009 on all inhabited continents except Australia. Starting with RelMiCS 7, these were were held as joint events with Applications of Kleene Algebras (AKA) conferences. At RelMiCS 11 / AKA 6 in Doha, Qatar, it was decided to con- tinue the series under the unifying name Relational and Algebraic Methods in Computer Science (RAMiCS). The next events, RAMiCS 12-14, were then held in Rotterdam, Netherlands, in 2011, Cambridge, UK, in 2012 and Marienstatt, Germany, in 2014.

The 15th International Conference on Relational and Algebraic Methods in Computer Science (RAMiCS 2015) was held in Braga, Portugal from September 28 to October 1, 2015. Further to invited and regular contributions, whose pro- ceedings will be published as volume 9348 in the Lecture Notes in Computer Science (LNCS) series by Springer Verlag, the call for papers also invited re- searchers doing a PhD or an MSc in the areas of the RAMiCS conference to sub- mit a short description of their ongoing work for presentation at the conference, in the form of extended abstracts not published nor submitted for publication elsewhere.

This was intended as an excellent opportunity for students to discuss their on-going work with leading experts in this field. This technical report includes the 8 contributions accepted by this “student track” of RAMiCS 2015.

September 2015

Wolfram Kahl Michael Winter Jos´e N. Oliveira

iv RAMiCS 2015 – Student Track

Acknowledgments

The RAMiCS conference was organized by HASLab – High Assurance Soft- ware Laboratory (http://haslab.uminho.pt), a research unit of the INESC TEC Associated Laboratory located at the University of Minho in Braga. All facilities granted byDepartamento de Inform´aticaandEscola de Engenharia are grate- fully acknowledged. We also thank FCT (Fundac¸˜ao para a Ciˆencia e Tecnologia) for their sponsorship.

This tecnical report was type-set in L^ATEX using Springer-Verlag’s class pack- agellncs.cls.

Preface v

Table of Contents

Preface

. . . iii

Contents

. . . vi Decision Methods for Concurrent Kleene Algebra with Tests: Based on

Derivative(Yoshiki Nakamura) . . . 1 RLE-based Algorithm for Testing Biorders(Oliver Lanzerath). . . 9 Relational Equality in the Intensional Theory of Types(Victor Miraldo). . . 15 Loop Analysis and Repair(Nafi Diallo). . . 23 Monoid Modules and Structured Document Algebra(Andreas Zelend) . . . 33 On a Monadic Encoding of Continuous Behaviour(Renato Neves) . . . 43 Relational Approximation of Maximum Independent Sets(Insa Stucke) . . 53 A Generic Matrix Manipulator(Dylan Killingbeck). . . 61

Decision Methods for Concurrent Kleene Algebra with Tests : Based on Derivative

Yoshiki Nakamura

Tokyo Instutute of Technology, Oookayama, Meguroku, Japan, [email protected]

Abstract. Concurrent Kleene Algebra with Tests(CKAT) were introduced by Peter Jipsen[Jip14]. We give derivatives forCKATto decide word prob- lems, for example emptiness, equivalence, containment problems. These derivative methods are expanded from derivative methods for Kleene Al- gebra and Kleene Algebra with Tests[Brz64][Koz08][ABM12]. Addition- ally, we show that the equivalence problem ofCKATis in EXPSPACE.

Keywords: concurrent kleene algebras with tests, series-parallel strings, Brzozowski derivative, computational complexity

1 Introduction

In this paper, we assume [Jip14, theorem 1] and we useCKATterms as expres- sions of guarded series-parallel language.

LetΣbe a set ofbasic programsymbolsp₁,p₂, . . .andT a set ofbasic boolean test symbolst₁,t₂,· · ·, where we assume thatΣ∩T =∅. Eachα₁, α₂, . . . de- notes a subset ofT.Boolean termbandCKATtermpoverT andΣare defined by the following grammar, respectively.

b:=0|1|t∈T |b₁+b₂|b₁b₂|b₁

p:=b|p∈Σ|p₁+p₂|p₁p₂|p^∗₁|p₁∥p₂

The guarded series-parallel strings setGS_Σ,T overΣandT is a smallest set such that follows

– α∈GS_Σ,T for anyα⊆T

– α₁pα₂∈GS_Σ,T for anyα₁, α₂⊆T and any basic programp∈Σ – ifw₁α, αw₂∈GS_Σ,T, thenw₁αw₂∈GS_Σ,T.

– ifα₁w₁α₂, α₁w₂α₂∈GS_Σ,T, thenα₁{|w₁, w₂|}α₂∈GS_Σ,T.

Definition 1 (guarded series-parallel language).Let⋄and∥be binary operators overGS_Σ,T, respectably. They are defined as follows.

w₁⋄w₂= {

w₁^′αw^′₂ (w₁=w^′₁αandw₂=αw^′₂) undef ined (o.w.)

In particular, ifw₁=w₂=α, thenw₁⋄w₂=α.

2 Y. Nakamura

w₁∥w₂=







α₁{|w₁^′, w^′₂|}α₂ (w₁=α₁w^′₁α₂andw₂=α₁w^′₂α₂) α (w₁=w₂=α)

undef ined (o.w.)

Lis a map fromCKATterms overΣandT to this concrete model by – L(0) =∅,L(1) = 2^T

– L(t) ={α⊆T |t∈α}fort∈T – L(b) = 2^T\L(b)

– L(p) ={α₁pα₂|α₁, α₂⊆T}forp∈Σ – L(p₁+p₂) =L(p₁)∪L(p₂)

– L(p₁p₂) ={w₁⋄w₂| w₁∈G(p₁)andw₂∈L(p₂)andw₁⋄w₂is defined} – L(p^∗) = ∪

n<ω

{α₀⋄w₁⋄ · · · ⋄w_n|α₀⊆T andw₁, . . . , w_n∈L(p)andα₀⋄w₁· · · ⋄w_nis defined} – L(p₁∥p₂) ={w₁∥w₂|w₁∈L(p₁)andw₂∈L(p₂)and w₁∥w₂is defined}

We expandLtoL(P) =∪

p∈PL(p), whereP is a set ofCKATterms. Furthermore, letL_α(p) ={αw|αw∈L(p)}.

In guarded series-parallel strings,α₁{|w₁, w₂|}α₂has commutative(i.e.α₁{|w₁, w₂|}α₂= α₁{|w₂, w₁|}α₂). We definep₁= p₂for twoCKATtermsp₁andp₂asL(p₁) =

L(p₂)(by means of [Jip14, Theorem 1]).

2 The Brzozowski derivative for CKAT

Now, we give the naive derivative forCKAT. Derivative has applications to many language theoretic problems (e.g. membership problem, emptiness prob- lem, equivalence problem, and so on).

Definition 2 (Naive Derivative). We define E_α andD_w. They are maps from a CKATterm to a set ofCKATterms, respectively.E_α is inductively defined as fol- lows. We expandE_αandD_wtoE_α(P) =∪

p∈PE_α(p)andD_w(P) =∪

p∈PD_w(p), whereP is a set ofCKATterms, respectively.

– E_α(0) =E_α(p) =∅ – E_α(1) =E_α(p^∗₁) ={1} – E_α(t) =

{{1} (t∈α)

∅ (o.w.) – E_α(b) ={1} \E_α(b)

– E_α(p₁+p₂) =E_α(p₁)∪E_α(p₂)

– E_α(p₁p₂) =E_α(p₁∥p₂) =E_α(p₁)E_α(p₂) D_wis inductively defined as follows.

Forw=q| {|w^′₁, w₂^′|}and any series-parallel stringw^′, – D_αwα′w^′α^′′(p) =D_α′w^′α^′′(D_αwα′(p))

– D_αwα′(p₁+p₂) =D_αwα′(p₁)∪D_αwα′(p₂)

– D_αwα′(p₁p₂) =D_αwα′(p₁){p₂} ∪E_α(p₁)D_αwα′(p₂)

CKAT is in EXPSPACE 3

– D_αwα′(p^∗₁) =D_αwα′(p₁){p^∗₁} – D_αwα′(b) =∅for any boolean termb – D_αqα′(p) =

{{1} (p=q)

∅ (o.w.) – D_αqα′(p₁∥p₂) =∅ – D_{α{|w1,w2|}α}′(p) =∅

– D_{α{|w1,w2|}α}′(p₁ ∥ p₂) = E_α′((D_αw1α′(p₁) ∥ D_αw2α′(p₂))∪(D_αw1α′(p₂) ∥ D_αw2α′(p₁)))

Theleft-quotientofL⊆GS_Σ,T with regard tow∈GS_Σ,T is the setw⁻¹L= {w^′|w⋄w^′∈L}.

Lemma 1. For any series-parallel stringαwα^′, 1. 1∈E_α(p) ⇐⇒ α∈L_α(p)

2. (αwα^′)⁻¹L_α(p) =L_α′(D_αwα′(p))

Proof (Sketch). 1. is proved by induction on the size ofp.

2. is proved by double induction on the size ofwand the size ofp.

We can decide whetherαwα^′∈L(p)to check1∈E_α′(D_αwα′(p))by Lemma 1. We now define efficient derivative. This derivative is another definition of derivative forCKAT. This derivative is useful for giving more efficient algo- rithm than naive derivative in computational complexity. (In naive derivative, we should memorizew₁andw₂to getD_{α{|w1,w2|}α}′(p). In particular, the size of w₁andw₂can be double exponential size of input size in equivalence problem.) We expandCKATterms to express efficient derivative. We say these termsin- termediateCKATterms.IntermediateCKATtermis defined as following.

Definition 3 (intermediate CKAT term).IntermediateCKATtermis defined by the following grammar.

q:=b|p∈Σ|q₁+q₂|q₁q₂|q^∗₁|q₁∥q₂|D_x(q₁) We callxaderivative variableofD_x(q₁).

The efficient derivative d_pr(q) is defined in Definition 4, whereq is an in- termediateCKATterm,pr is a sequence of assignments formedx += αpor x+=αT (The sequence of assignmentspris formedx₁+=term₁;. . .;x_m+=

term_m.) and T is formed by the following grammar. T := {|x_lTl, x_rTr|} | {|x_lTl,p_rx_r|} | {|p_lx_l, x_rTr|} | {|p_lx_l,p_rx_r|}. Intuitively,d_x+=αw(. . . D_x(q). . .) means(. . . D_x( ˘D_αw(join_α(q))). . .).

Definition 4. Theefficient derivatived_pr(q)is inductively defined as follows, where we assume that any derivative variable occurred inT are different. To defined_pr(q), we also defineD˘_αwand join_α. We expandd_prtod_pr(Q) =∪

q∈Qd_pr(q), whereQis a set of intermediateCKATterms. We also expand join_αtojoin_α(Q) =∪

q∈Qjoin_α(q).

4 Y. Nakamura

– d_x+=αw;pr′(q) =d_pr′(d_x+=αw(q)) – d_x+=αw(b) ={b}

– d_x+=αw(p) ={p}

– d_x+=αw(q₁+q₂) =d_x+=αw(q₁)∪d_x+=αw(q₂) – d_x+=αw(q₁q₂) =d_x+=αw(q₁)d_x+=αw(q₂) – d_x+=αw(q₁^∗) =d_x+=αw(q₁)^∗

(={q^′∗|q^′∈d_x:=αw(q₁)})

– d_x+=αw(q₁∥q₂) =d_x+=αw(q₁)∥d_x+=αw(q₂) (={q^′₁∥q₂^′ |q₁^′ ∈d_x+=αw(q₁), q₂^′ ∈d_x+=αw(q₂)}) – d_x+=αw(D_y(q₁)) =D_y(d_x+=αw(q₁))

– d_x+=αw(D_x(q₁)) =D_x( ˘D_αw(join_α(q₁))) – D˘_αp(q) =D_αp(q)

– D˘_αT(b) = ˘D_αT(p) =∅

– D˘_αT(q₁+q₂) = ˘D_αT(q₁)∪D˘_αT(q₂)

– D˘_αT(q₁q₂) = ˘D_αT(q₁){q₂} ∪E_α(q₁) ˘D_αT(q₂) – D˘_αT(q₁^∗) = ˘D_αT(q₁){q₁^∗}

– D˘_αT(q₁∥q₂) =































(D_xl( ˘D_αpl(q₁))∥D_xr( ˘D_αpr(q₂)))

∪(D_xr( ˘D_αpr(q₁))∥D_xl( ˘D_αpl(q₂))) (T ={|p_lx_l,p_rx_r|}) (D_xl( ˘D_αTl(q₁))∥D_xr( ˘D_αpr(q₂)))

∪(D_xr( ˘D_αpr(q₁))∥D_xl( ˘D_αTl(q₂))) (T ={|Tlx_l,p_rx_r|}) (D_xl( ˘D_αpl(q₁))∥D_xr( ˘D_αTr(q₂)))

∪(D_xr( ˘D_αTr(q₁))∥D_xl( ˘D_αpl(q₂))) (T ={|p_lx_l,Trx_r|}) (D_xl( ˘D_αTl(q₁))∥D_xr( ˘D_αTr(q₂)))

∪(D_xr( ˘D_αTr(q₁))∥D_xl( ˘D_αTl(q₂))) (T ={|Tlx_l,Trx_r|}) – join_α(b) ={b}, join_α(p) ={p}

– join_α(q₁+q₂) =join_α(q₁)∪join_α(q₂), join_α(q₁q₂) =join_α(q₁)join_α(q₂) – join_α(q₁∥q₂) =join_α(q₁)∥join_α(q₂)

– join_α(q^∗₁) =join_α(q₁)^∗ – join_α(D_y(q)) =E_α(join_α(q))

Efficient derivative is essentially equal to the derivative of Definition 1. Let

sp_x(pr)be the string corresponded toxofpr. (For example,sp_x0(x₀+=α{p₁x₁,p₂x₂};x₁+=

α^′p₃;x₀ += α^′′p₄) = α{p₁α^′p₃,p₂}α^′′p₄.sp_x1(x₀ += α{p₁x₁,p₂x₂};x₁ +=

α^′p₃;x₀+=α^′′p₄) =αp₁α^′p₃)

Lemma 2. join_α′(d_pr(D_x(p))) =E_α′(D_spx(pr)α′(p))

By Lemma 1 and Lemma 2,sp_x(pr)α^′ ∈L(p) ⇐⇒ 1∈join_α′(d_pr(D_x(p))). Therefore, we can use effective derivative instead of naive derivative.

Next, we define thesizeof a intermediateCKATtermq, denoted by|q|as follows.

– |0|=|1|=|t|=|p|= 1 – |b|= 1 +|b|

– |q₁^∗|=|D_x(q₁)|= 1 +|q₁|

CKAT is in EXPSPACE 5

– |q₁+q₂|=|q₁q₂|=|q₁∥q₂|= 1 +|q₁|+|q₂|

Definition 5 (Closure).Cl_Xis a map from a intermediateCKATterm to a set of in- termediateCKATterms, whereXis a set of intersection variables.Cl_Xis inductively defined as follows.

– Cl_X(a) ={a}fora=0|1|t

– Cl_X(b) ={b} ∪Cl_X(b)for any boolean termb – Cl_X(p) ={p,1}

– Cl_X(q₁+q₂) ={q₁+q₂} ∪Cl_X(q₁)∪Cl_X(q₂) – Cl_X(q₁q₂) ={q₁q₂} ∪Cl_X(q₁){q₂} ∪Cl_X(q₂) – Cl_X(q^∗₁) ={q₁^∗} ∪Cl_X(q₁){q^∗₁}

– Cl_X(q₁ ∥ q₂) = {q₁ ∥ q₂} ∪ {D_x1(q₁^′) ∥ D_x2(q₂^′) | q₁^′ ∈ Cl_X(q₁), q₂^′ ∈ Cl_X(q₂), x₁, x₂∈X}

– Cl_X(D_x(q₁)) ={D_x(q₁)} ∪D_x(Cl_X(q₁)) We expandCl_X toCl_X(Q) = ∪

q∈QCl_X(q), whereQis a set of intermediate CKATterms.Cl_X is a closed operator. In other words,Cl_X satisfies (1)Q ⊆ Cl_X(Q), (2)Q₁⊆Q₂⇒Cl_X(Q₁)⊆Cl_X(Q₂)and (3)Cl_X(Cl_X(Q)) =Cl_X(Q).

We also define the intersection widthiw(q)over intermediateCKATterms and iw(w)overGI_Σ,T as follows.

– iw(b) =iw(p) = 1for any boolean termband any basic programp∈Σ – iw(q₁+q₂) =iw(q₁q₂) = max(iw(q₁), iw(q₂))

– iw(q₁^∗) =iw(D_x(q₁)) =iw(q₁) – iw(q₁∥q₂) = 1 +iw(q₁) +iw(q₂) – iw(α) = 1for anyα⊆T

– iw(α₁pα₂) = 1

– iw(w₁αw₂) = max(iw(w₁α), iw(αw₂)) – iw(α₁{|w₁, w₂|}α₂) = 1 +iw(w₁) +iw(w₂)

Lemma 3 (closure is bounded).For any intermediateCKATtermq and any se- quence of program prand any set of derivative variablesX, whereX contains any derivative variables inpr,

|Cl_X(q)| ≤2∗ |X|^2∗iw(q)∗ |q|^iw(q)

Proof (Sketch). This is proved by induction on the structure ofq. We only consider the case ofq=q₁∥q₂.

|Cl_X(q₁∥q₂)| ≤1 +|X| ∗ |Cl_X(q₁)| ∗ |X| ∗ |Cl_X(q₂)|

≤1 +|X|²∗2∗ |q₁|^iw(q1)∗ |X|^2∗iw(q1)∗2∗ |q₂|^iw(q2)∗ |X|^2∗iw(q2)

= 1 + 4∗ |X|^{2∗iw(q1∥q2)}∗ |q₁|^iw(q1)∗ |q₂|^iw(q2)

≤2∗ |X|^{2∗iw(q1∥q2)}∗(|q₁|+|q₂|)^{iw(q1)+iw(q2)}

≤2∗ |X|^{2∗iw(q1∥q2)}∗ |q₁∥q₂|^iw(q1∥q2)

Lemma 4 (derivative is closed).For any intermediateCKATtermqand any se- quence of program prand any set of derivative variablesX, whereX contains any derivative variables inpr,

d_pr(q)⊆Cl_X(q)

Proof (Sketch). This is proved by double induction on the size ofprand the size ofq.

6 Y. Nakamura

3 CKAT equational theory is in EXPSPACE

By Lemma 1 and Lemma 2,L(p₁) =L(p₂)iff join_α′(d_pr(D_x(p₁))) =join_α′(d_pr(D_x(p₂))) for anypr and anyα^′. Thus we find somepr such that join_α′(d_pr(D_x(p₁))) ̸= join_α′(d_pr(D_x(p₂)))to decidep₁̸=p₂. We must consider all the patterns ofprat first glance. But, we need not to check ifpris too long. We are enough to check the cases ofiw(sp(pr))≤max(iw(p₁), iw(p₂))(≤l)by the following Lemma 5.

Lemma 5. Ifiw(sp(pr))> iw(q),d_pr(q) =∅.

By Lemma 5, we are enough to check the case ofiw(sp(pr))≤max(iw(p₁), iw(p₂))≤ l. Byiw(sp(pr))≤ l, We are enough to prepare1 + 3∗(l−1)derivative vari- ables. By Lemma 3,|Cl_X(q)| ≤2∗ |q|^iw(q)∗ |X|^2∗iw(q)≤2∗l^l∗(1 + 3∗(l−1))^2∗l. Therefore,|Cl_X(D_x(p₁))|=O(2^p(l))and|Cl_X(D_x(p₂))| =O(2^p(l)), wherep(l) is a polynomial function ofl.

We can give a nondeterministic algorithm. We nondeterministically select the syntax ofpr. (prisx+=αporx+=αT.) If there exists a sequent of assign- mentspr andα^′such that join_α′(d_pr(D_x(p₁))) ̸=join_α′(d_pr(D_x(p₂))),p₁ ̸=p₂. Otherwise,p₁=p₂. (See Algorithm 1 if you know more details.)

It holds the Theorem 1 by this algorithm.

Theorem 1. CKATequivalence problem is in EXPSPACE.

Corollary 1. ifiw(p)is a fixed parameter, thenCKATequivalence problem is PSPACE- complete.

Note that PSPACE-hardness is derived by [Hun73].

4 Concluding Remarks

We have given the derivative forCKATand shown thatCKATequational the- ory is in EXPSPACE. We finish with the following some of our future works.

– Is this equivalence problem EXPSPACE-complete? (We expect that this claim isT rue.)

– If we allow ϵ(for example, α{|p, ϵ|}α), can we give efficient derivative?

(It become a little difficult because we have to memorizeαin the case of x += α{|p₁x₁, ϵ|}. We should give another derivative to show the result like Corollary 1.)

A Pseudo Code

REFERENCES 7

Algorithm 1Decidep₁=p₂, given two CKAT termsp₁andp₂ Ensure: Whetherp1̸=p2or not?(True or False)

step⇐0,P1⇐ {Dx₀(p1)},P2⇐ {Dx₀(p2)}

whilestep≤2^{|ClX(Dx0(p1))|}∗2^{|ClX(Dx0(p2))|}do

Letαbe a subset ofT, which is picked up nondeterministically.

ifjoinα(P1)̸=joinα(P2)then return T rue

end if

Letprbex +=αporx +=αT, which is picked up nondeterministically, where iw(pr)≤max(iw(p1), iw(p2)).

step⇐step+ 1,P1⇐dpr(P1),P2⇐dpr(P2) end while

return F alse

References

[ABM12] Ricardo Almeida, Sabine Broda, and Nelma Moreira. “Deciding KAT and Hoare Logic with Derivatives”. In: Proceedings Third Interna- tional Symposium on Games, Automata, Logics and Formal Verification, GandALF 2012, Napoli, Italy, September 6-8, 2012.2012, pp. 127–140.

[Brz64] Janusz A Brzozowski. “Derivatives of regular expressions”. In:Jour- nal of the ACM (JACM)11.4 (1964), pp. 481–494.

[Hun73] Harry B Hunt III. “On the time and tape complexity of languages I”. In:Proceedings of the fifth annual ACM symposium on Theory of com- puting. ACM. 1973, pp. 10–19.

[Jip14] Peter Jipsen. “Concurrent Kleene algebra with tests”. In:Relational and Algebraic Methods in Computer Science. Springer, 2014, pp. 37–48.

[Koz08] Dexter Kozen.On the Coalgebraic Theory of Kleene Algebra with Tests.

Tech. rep.http://hdl.handle.net/1813/10173. Computing and Information Science, Cornell University, Mar. 2008.

8 RAMiCS 2015 – Student Track

RLE-based Algorithm for Testing Biorders

Oliver Lanzerath

Department of Computer Sciences, Bonn-Rhein-Sieg University of Applied Sciences, Grantham-Allee 20, 53757 Sankt Augustin, Germany

[email protected] http://www.inf.h-brs.de

Abstract. Binary relations with certain properties such as biorders, equiv- alences or difunctional relations can be represented as particular matri- ces. In order for these properties to be identified usually a rearrange- ment of rows and columns is required in order to reshape it into a recog- nisable normal form. Most algorithms performing these transformations are working on binary matrix representations of the underlying relations.

This paper presents an approach to use the RLE-compressed matrix rep- resentation as a data structure for storing relations to test whether they are biorders in a hopefully more efficient way.

Keywords: RLE-XOR·RLE-permutation·biorder

1 Introduction

The matrix representation of a binary relation can be interpreted as a bitmap image, that is, a bit sequence. In many cases the usage of arun length encoding (RLE) technique results in a smaller representation of such pictures by shorter codes for lengthy bit strings. Hence, algorithms which use RLE-compressed binary matrices as input may have better runtime complexity on average. A bitvectorxconsists of alternating series of0- and1-sequences. Referring to [3], a bitvector can be represented by the lengths of the single sequences as follows.

Run Length Encoding. Letseq_i∈

0^j|j∈N ∪

1^j|j∈N ,i∈N,be a sequence withvalue(seq_i) = 0, seq_i∈

0^j|j∈N andvalue(seq_i) = 1, seq_i∈

1^j|j∈N . Then, a bitvectorx=x₀...xn−1∈ {0,1}ⁿcan be represented asx=seq₁...seq_k, 1≤k≤n, value(seq_i)6=value(seq_i+1),Pk

i=1|seq_i|=n. The RLE-compression of a vectorxis given by the vector

x^rle=x₀[|seq₁|, ...,|seq_k|] (1) Figure 1 shows an example for the RLE-compression of a bitvector. Further- more we make use of a notation similar to arrays for accessing elements of the RLE-compressed vector, wherex^rle[0]refers to the leading elementx₀and x^rle[i],1≤i≤k, to the following length specifications.¹

1E.g. the RLE-compression of the vectorx= 1100001is given byx^rle= 1 [2,4,1]with x^rle[0] = 1,x^rle[1] = 2,x^rle[2] = 4andx^rle[3] = 1.

10 O. Lanzerath

11111

| {z }

5

000

|{z}

3

11111111111

| {z }

11

| {z }

1[5,3,11]

Fig. 1.Example for the RLE-compression of a bitvector.

Biorders. Biorderscan be defined in different ways. First we introduce the for- mal definition[4]: LetR⊆X×Xbe a homogeneous binary relation.Ris called biorder (or: Ferrers relation in heterogeneous cases), iff

aRb∧cRd∧ ¬aRd→cRb holds∀a, b, c, d∈X.

In the context of this paper the following definiton is helpful. A binary rela- tion is called a biorder, iff the matrix can be represented in (upper left)echelon block form²by rearranging rows and columns independently [4]. Thus, it is suffi- cient to test relations for being biorders by using an algorithm that computes the echelon block form if possible and returns an error otherwise. Figure 2 shows the results of the group stage of group B during the recent FIFA World Cup, whereARB, iffAwon the match againstB,A, B ∈ {ESP,CHL,NLD,AUS}, A6= B. By rearranging rows and then columns the matrix for the relationR

R ESP CHL NLD AUS ESP 0 0 0 1 CHL 1 0 0 1 NLD1 1 0 1 AUS0 0 0 0

R ESP CHL NLD AUS NLD1 1 0 1 CHL 1 0 0 1 ESP 0 0 0 1 AUS 0 0 0 0

R AUS ESP CHL NLD NLD1 1 1 0 CHL1 1 0 0 ESP 1 0 0 0 AUS0 0 0 0 Fig. 2.Group stage FIFA World Cup 2014 (group B).

is transformed into echelon block form proving thatRis a biorder.³If a given relation is a biorder, the echelon block form can be achieved in two steps [1]:

1. Sort the rows by theirHamming weight⁴in descending order.

2. Sort the columns by their Hamming weight in descending order.

A corresponding algorithm would perform these two steps and check if the result is in echelon block form. The time complexity of such an algorithm is inO(2nlogn+n²) ⊆ O(n²). The following lemma states, that with respect to biorder tests the second step is not needed.

2Visually speaking, a binary matrix is in upper left echelon block form, if all 1-entries are placed in the upper left corner and the cardinality of the 1-entries monotonically decreases from top to bottom.

3Soccer results do not induce biorders in general. The example is well-chosen here.

4We use the notationkxk=Pn−1

i=0 xito note the Hamming weight of a bitvectorx(cf.

[2]).

RLE-based Algorithm for Testing Biorders 11 Lemma 1. LetAbe a binaryn×n-matrix, and letA⁰be the result of sorting the rows ofAby their Hamming weights in descending order.Ais a biorder if and only ifA⁰is exclusively composed of column vectorsx∗i∈ {0ⁿ,1ⁿ} ∪

1^j0^n−j|1≤j≤n . Proof. First, we show the if-part by contradiction. Assume that a givenn×n- matrix resp. binary relation is a biorder, and after having sorted the rows by their Hamming weights there exists a column vector that does not fulfil the condition. Then there exists at least one column vector in which a1-sequence follows a0-sequence, i.e. there exists at least onei,1≤i≤n, such thatx_∗i ∈ n

υ01ω|υ∈ {0,1}^j, ω∈ {0,1}^n−j−2,0≤j≤n−2 o

. Now we sort the columns by their Hamming weights. Letx_ki = 0andx_li = 1withk < l, thenkxk∗k ≥ kxl∗k. After having sorted rows and columns the matrix should be in echelon block form because it is a biorder. Thenx_l0 =x_l1 =· · · = x_li = 1andx_k0 = x_k1=· · ·=x_ki= 1because ofkxk∗k ≥ kxl∗k. This contradicts the assumption.

The other direction is obvious. If the rows are ordered by Hamming weight and all column vectors are of the desired type, there must be an ordering hx∗j1,x∗j2, ...,x∗jni, j_i ∈ {0, ..., n−1}of the column vectors with kx∗j1k ≥ kx∗j2k≥ ... ≥ kx∗jnk. The echelon block form is accomplished by sorting the columns according to this ordering.

2 Algorithm

The complexity of checking all column vectors of a binary matrix for a certain form is still inO(n²). If the column vectors are RLE-compressed, the checking can be done in linear time. We only need to verify that all RLE-compressed col- umn vectors have a length of 1 or 2 and start with a1-sequence. We assume the relation is represented in RLE-compressed form, i.e. column vectors as well as row vectors are RLE-compressed (c.f. running example in Fig. 3). A biorder-

ESP CHL NLD AUS ESP 0 0 0 1 CHL 1 0 0 1 NLD1 1 0 1 AUS0 0 0 0

ESP0[3,1]

CHL1[1,2,1]

NLD1[2,1,1]

AUS0[4]

ESP CHL NLD AUS 0[1,2,1] 0[2,1,1] 0[4] 1[3,1]

Fig. 3.RLE-compressed rows and columns

checking algorithm is defined as follows. First one adjusts the definition of the Hamming weight for RLE-compressed vectors with respect to the new sorting algorithm. If the leading elementx^rle[0]is 1, all odd positions in the follow- ing array refer to 1-entries in the corresponding binary matrix, and vice versa.

12 O. Lanzerath

Hence, the Hamming weight for RLE-compressed vectors can be defined as:⁵

kx^rlek=















|x^rle|

P

i=1,i∈O+

x^rle[i], x^rle[0] = 1

|x^rle|

P

i=2,i∈E+

x^rle[i], x^rle[0] = 0

(2)

whereO+andE+are the positive odd and even numbers, respectively.

Sorting RLE-compressed row vectors by the Hamming weight causes changes in the column vectors, too. In binary-coded cases this is no point of interest because this change occurs automatically. But, if the vectors are RLE- compressed, it is much more complicated. A permutation of the row vectors x^rle_j∗ can have effects on all column vectorsx^rle_∗i. Assumex_j∗andx_k∗are swapped thenx_jiandx_kimust be inverted iffx_ji6=x_ki. Algorithm 1 implements a bit- compare function for RLE-compressed vectors.

Data: A RLE-compressedn-bitvectorx^rleand two integers j, k,1≤j≤n,1≤k≤n, j < k

Result: Boolean:xk6=xj

dist:= 0;

counter:=x^rle[1]; fori:= 2to|x^rle|do

ifcounter≥j && counter≤kthen dist+ +;

end

counter+ =x^rle[i]; end

ifdist== 1 mod 2then returntrue;

else

returnf alse; end

Algorithm 1:bitCompare-function for RLE-compressedn-bitvectors

To ensure that in casex_ji 6= x_kithe corresponding bits must be switched, we use an XOR-operation with a special bit mask:

xx₁· · ·xj−1x_jx_j+1· · ·xk−1x_kx_k+1· · ·x_n mask 0 · · · 0 1 0 · · · 0 1 0 · · · 0

XORx₁· · ·xj−1x_jx_j+1· · ·xk−1x_kx_k+1· · ·x_n

The logical XOR is the essential part of the whole procedure. Algorithm 2 shows how the XOR-operation can be computed on RLE-compressed vectors.

5|x^rle|is the length of the array or the RLE-compressed vector, respectively.

RLE-based Algorithm for Testing Biorders 13 First the biorder checking algorithm sorts the row vectorsx^rle_j∗ by their Ham- ming weights. For each pairwise permutation of rows all column vectorsx^rle_∗i must be adjusted if necessary. After that the resulting column vectors must be checked for meeting the conditions of Lemma 1. If each column vector meets the conditions, the underlying relation is a biorder.

3 Examination

As is well known, sorting row vectors of a binary matrix by the Hamming weight is inO(nlogn), as well as sorting RLE-compressed vectors. But, to check the conditions of Lemma 1 in later process, the column vectors need to be adjusted, too. In the worst case all n column vectors must be modified for each change of rows and, therefore,nXOR-operations have to be computed.

The required time for each XOR-operation depends on the length of the RLE- compressed vectors. Hence, the time complexity of the sorting procedure is bounded from above byO(n³logn). Now, the test for meeting the conditions of Lemma 1 can be done inO(n).

Data: Two RLE-compressed copies ofn-bitvectorsx^rle,y^rle Result: Result of the XORz^rle

xpointer:= 1;

ypointer:= 1; zpointer:= 1;

z^rle[0] :=|x^rle[0]−y^rle[0]|; while

zpointer

P

i:=1

z^rle[i]< ndo

ifx^rle[xpointer] ==y^rle[ypointer]then z^rle[zpointer]+ =x^rle[xpointer]; xpointer+ +;

ypointer+ +;

else ifx^rle[xpointer]<y^rle[ypointer]then z^rle[zpointer]+ =x^rle[xpointer];

y^rle[ypointer]−=x^rle[xpointer]; xpointer+ +;

zpointer+ +; else

z^rle[zpointer]+ =y^rle[ypointer]; x^rle[xpointer]−=y^rle[ypointer];

ypointer+ +; zpointer+ +; end

Algorithm 2: XOR on RLE-compressedn-bitvectors