11institutetext: Informatics Institute, Faculty of Science, University of
Amsterdam
Science Park 904, 1098 XH Amsterdam, the Netherlands
11email: [email protected]
Imperative Process Algebra with Abstraction
C.A. Middelburg
Abstract
This paper introduces an imperative process algebra based on ACP
(Algebra of Communicating Processes).
Like other imperative process algebras, this process algebra deals with
processes of the kind that arises from the execution of imperative
programs.
It distinguishes itself from already existing imperative process
algebras among other things by supporting abstraction from actions that
are considered not to be visible.
The support of abstraction of this kind opens interesting application
possibilities of the process algebra.
This paper goes briefly into the possibility of information-flow
security analysis of the kind that is concerned with the leakage of
confidential data.
For the presented axiomatization, soundness and semi-completeness
results with respect to a notion of branching bisimulation equivalence
are established.
mperative process algebra, abstraction, branching bisimulation,
information-flow security, data non-interference with interactions.
Generally speaking, process algebras focus on the main role of a
reactive system, namely maintaining a certain ongoing interaction with
its environment.
Reactive systems contrast with transformational systems.
A transformational system is a system whose main role is to produce,
without interruption by its environment, output data from input data.111The terms reactive system and transformational system are used here
with the meaning given in [26].
In general, early computer-based systems were transformational systems.
Nowadays, many systems are composed of both reactive components and
transformational components.
A process carried out by such a system is a process in which data are
involved.
Usually, the data change in the course of the process, the process
proceeds at certain stages in a way that depends on the changing data,
and the interaction of the process with other processes consists of
communication of data.
This paper introduces an extension of ACP [6] with features
that are relevant to processes of the kind referred to above.
The extension concerned is called -I.
Its additional features include assignment actions to change the data in
the course of a process, guarded commands to proceed at certain stages
of a process in a way that depends on the changing data, and data
parameterized actions to communicate data between processes.
The processes of the kind that -I is concerned with are
reminiscent of the processes that arise from the execution of imperative
programs.
In [33], the term imperative process algebra was coined for
process algebras like -I.
Other imperative process algebras are VPLA [27],
IPAL [33], CSPσ [16], AWN [19], and the
unnamed process algebra introduced in [13].
-I distinguishes itself from those imperative process algebras by
being the only one with the following three properties:
(1) it supports abstraction from actions that are considered not to be
visible;
(2) a verification of the equivalence of two processes in its semantics
is automatically valid in any semantics that is fully abstract with
respect to some notion of observable behaviour (cf. [41]);
(3) it offers the possibility of equational verification of process
equivalence.
CSPσ is the only one of the above-mentioned imperative process
algebras that has property (1) and none of them has property (2).
-I is probably unique in being the only imperative process
algebra with properties (1), (2) and (3).
Property (1) is achieved by providing a special constant (called the
silent step constant), special operators (called abstraction operators),
and an appropriate notion of equivalence of processes in the semantics
of -I.
Property (2) is achieved by using a notion of branching bisimulation
equivalence [41] for the equivalence of processes in the
semantics of -I.
Property (3) is achieved by providing an equational axiomatization of
the equivalence concerned.
Property (1) is essential for the verification of properties concerning
the external behaviour of a system.
Property (2) is desirable for such verifications in applications where
the final word on what exactly is observable behaviour has not been
pronounced.
This means that -I is an interesting process algebra for the
verification of properties concerning the external behaviour of a system
whose description calls for an imperative process algebra.
It makes -I, among other things, suitable for the verification of
properties concerning the information-flow security of a system in which
confidential and non-confidential data, contained in state components of
the system, are looked up and changed and an ongoing interaction with
the environment of the system is maintained.
A great part of the work done on information-flow security is concerned
with secure information flow in programs, where information flow in a
program is considered secure if information derivable from the
confidential data contained in its high-security variables cannot be
inferred from the non-confidential data contained in its low-security
variables (see e.g. [42, 40, 12, 34, 10]).
A notable exception is the work done in a process-algebra setting, where
the focus has shifted from programs to processes of the kind to which
programs in execution belong and where the information flow in a process
is usually considered secure if information derivable from confidential
actions cannot be inferred from non-confidential actions
(see e.g. [20, 36, 11, 31]).
Recent work done on information-flow security in a process-algebra
setting occasionally deals with the data-oriented notion of secure
information flow, but on such occasions program variables are always
mimicked by processes (see e.g. [21, 29]).
A suitable imperative process algebra would obviate the need to mimic
program variables.
This state of affairs motivated the development of -I.
This paper also shows how -I can be used for information-flow
security analysis of the kind that is concerned with the leakage of
confidential data.
The development of -I was primarily aimed at obtaining an
imperative process algebra with the properties that are designated above
as essential and desirable for the verification of properties concerning
the external behaviour of a system.
The starting point of the development of -I is
[3, Section 5.3], which is a non-imperative process
algebra with these properties.
This makes it a convenient starting point in view of the primary aim of
the development.
-I is closely related to -D [9].
The main differences between them can be summarized as follows:
(a) only the former supports abstraction from actions that are
considered not to be visible and
(b) only the latter has an iteration operator.
This paper introduces, in addition to -I, guarded linear recursion
in the setting of -I.
The set of processes that can be defined by means of the operators of
-I extended with the iteration operator is a proper subset of the
set of processes that can be defined by means of guarded linear
recursion in the setting of -I.
Therefore, (a) should be considered the important difference.
However, using the semantics of -D as presented in [9] as
the starting point of the semantics of -I turned out to result in a
semantics that is too complicated to establish the soundness and
semi-completeness results.
This paper is organized as follows.
First, a survey of the algebraic theory , which is the extension
of ACP with the empty process constant and the silent step
constant , is given (Section 2).
Next, the algebraic theory -I is introduced as an extension of
(Section 3) and guarded linear recursion in the
setting of -I is treated (Section 4).
After that, a structural operational semantics of -I is presented
and a notion of branching bisimulation equivalence based on this
semantics is defined (Section 5).
Following this, the reasons for two relatively uncommon choices made in
the preceding sections are clarified (Section 6).
Then, results concerning the soundness and (semi-)completeness of the
given axiomatization with respect to branching bisimulation equivalence
are established (Section 7).
Thereafter, it is explained how -I can be used for
information-flow security analysis of the kind that is concerned with
the leakage of confidential data (Section 8).
Finally, some concluding remarks are made
(Section 9).
There is also an appendix in which, for comparison, an alternative
structural operational semantics of -I is presented and a notion
of branching bisimulation equivalence based on this alternative
structural operational semantics is defined.
The alternative in question is the above-mentioned result of using the
structural operational semantics of -D as the starting point.
Section 2, Section 3, and the appendix
mainly extend the material in Section 2, Section 3, and Section 4,
respectively, of [9].
Portions of that material have been copied near verbatim or slightly
modified.
2 ACP with Empty Process and Silent Step
In this section, is presented.
is ACP [6] extended with the empty process constant
and the silent step constant as
in [3, Section 5.3].
In , it is assumed that a fixed but arbitrary finite set of
basic actions, with , and a fixed
but arbitrary commutative and associative communication function
,
such that and
for all , have been given.
Basic actions are taken as atomic processes.
The function is regarded to give the result of synchronously
performing any two basic actions for which this is possible, and to be
otherwise.
Henceforth, we write for .
The algebraic theory has one sort: the sort of
processes.
This sort is made explicit to anticipate the need for many-sortedness
later on.
The algebraic theory has the following constants and operators
to build terms of sort :
•
for each , the basic action constant
;
•
the silent step constant ;
•
the inaction constant ;
•
the empty process constant ;
•
the binary alternative composition operator
;
•
the binary sequential composition operator
;
•
the binary parallel composition operator
;
•
the binary left merge operator
;
•
the binary communication merge operator
;
•
for each and for ,
the unary encapsulation operator
;
•
for each ,
the unary abstraction operator
.
It is assumed that there is a countably infinite set of variables
of sort , which contains , and .
Terms are built as usual.
Infix notation is used for the binary operators.
The following precedence conventions are used to reduce the need for
parentheses: the operator binds stronger than all other
binary operators and the operator binds weaker than all
other binary operators.
The constants of can be explained as follows ():
•
denotes the process that performs the observable action and
after that terminates successfully;
•
denotes the process that performs the unobservable action
and after that terminates successfully;
•
denotes the process that terminates successfully without
performing any action;
•
denotes the process that cannot do anything, it cannot even
terminate successfully.
Let and be closed terms denoting processes and ,
respectively,
let or , and let .
Then the operators of can be explained as follows:
•
denotes the process that behaves either as or as ,
where the choice between the two is resolved at the instant that one of
them performs its first action or terminates successfully without
performing any action, and not before;
•
denotes the process that first behaves as and
following successful termination of behaves as ;
•
denotes the process that behaves as and in
parallel, by which is meant that, each time an action is performed,
either a next action of is performed or a next action of is
performed or a next action of and a next action of are
performed synchronously — successful termination may take place
at any time that both and can terminate successfully;
•
denotes the same process as , except that it
starts with performing an action of ;
•
denotes the same process as , except that it
starts with performing an action of and an action of
synchronously;
•
denotes the process that behaves the same as , except
that actions from are blocked from being performed;
•
denotes the process that behaves the same as , except
that actions from are turned into the unobservable action .
The operators and are of an auxiliary nature.
They make a finite axiomatization of possible.
The operator can also be explained as
follows:
denotes the process that behaves the same as
if denotes a process that has the option to behave the same as
and it denotes the process that behaves the same as otherwise.
In [3, Section 5.3], the symbol is used
instead of .
In these equations, , , and stand for arbitrary constants
of other than , stands for an arbitrary subset of
or the set , and stands for an arbitrary subset
of .
So, CM3, CM7, D0–D4, T0–T4, and BE are actually axiom schemas.
In this paper, axiom schemas will usually be referred to as axioms.
The occurrence of the strange-looking term
in axiom CM1E deserves
some explanation.
This term is needed to handle successful termination in the presence of
:
it stands for the process that behaves the same as if both and
stand for a process that has the option to behave the same as
and it stands for the process that behaves the same as
otherwise.
Notice that there are no operators for
with in .
If one or more of them were present, the equation
would be derivable from the axioms of .
In the sequel, the notation , where , will
be used for right-nested alternative compositions.
For each ,222We write for the set of
positive natural numbers.
the term is defined by induction on as
follows:
and
.
In addition, the convention will be used that
.
3 Imperative
In this section, -I, imperative , is presented.
This extension of has been inspired by [8].
It extends with features that are relevant to processes in which
data are involved, such as guarded commands (to deal with processes that
only take place if some data-dependent condition holds), data
parameterized actions (to deal with process interactions with data
transfer), and assignment actions (to deal with data that change in the
course of a process).
In -I, it is assumed that the following has been given with
respect to data:
•
a many-sorted signature that includes:
–
a sort of data and
a sort of booleans;
–
constants of sort and/or operators with result sort ;
–
constants and of sort and
operators with result sort ;
•
a minimal algebra of the signature in which
the carrier of sort has cardinality and
the equation does not hold.
We write for the set of all closed terms over the signature
that are of sort .
The sort is assumed to be given in order to make it possible for
operators to serve as predicates.
It is also assumed that a finite or countably infinite set of
flexible variables has been given.
A flexible variable is a variable whose value may change in the course
of a process.333The term flexible variable is used for this kind of variables in
e.g. [39, 30].
Typical examples of flexible variables are the program variables known
from imperative programming.
An evaluation map is a function from to .
We write for the set of all evaluation maps.
The algebraic theory -I has the following sorts:
the sort of processes,
the sort of conditions, and
the sorts from .
It is assumed that there are countably infinite sets of variables of
sort and and that the sets of variables of sort ,
, and are mutually disjoint and disjoint from .
Below, the constants and operators of -I are introduced.
The operators of -I include two variable-binding operators.
The formation rules for -I terms are the usual ones for the
many-sorted case (see e.g. [38, 43]) and in addition the
following rule:
•
if is a variable-binding operator
that binds a variable of sort ,
are terms of sorts , respectively, and
is a variable of sort , then is a term of
sort .
An extensive formal treatment of the phenomenon of variable-binding
operators can be found in [35].
-I has the constants and operators from to build
terms of the sorts from — which include the sort
and the sort — and in addition the following constants to
build terms of sort :
•
for each , the flexible variable constant
.
We write for the set of all closed -I terms of sort
.
Evaluation maps are intended to provide the data values assigned to
flexible variables when an -I term of sort is evaluated.
However, in order to fit better in an algebraic setting, they provide
closed terms over the signature that denote those data
values instead.
The requirement that is a minimal algebra guarantees that each
data value can be represented by a closed term.
-I has the following constants and operators to build terms of
sort :
•
the binary equality operator
;
•
the binary equality operator
;444The overloading of can be trivially resolved if is
without overloaded symbols.
•
the truth constant ;
•
the falsity constant ;
•
the unary negation operator ;
•
the binary conjunction operator
;
•
the binary disjunction operator
;
•
the binary implication operator
;
•
the unary variable-binding universal quantification operator
that binds a variable of sort ;
•
the unary variable-binding existential quantification operator
that binds a variable of sort .
We write for the set of all closed -I terms of sort
.
Each term from can be taken as a formula of a first-order
language with equality of by taking the flexible variable
constants as additional variables of sort .
The flexible variable constants are implicitly taken as additional
variables of sort wherever the context asks for a formula.
In this way, each term from can be interpreted as a
formula in .
-I has the constants and operators of and in addition the
following operators to build terms of sort :
•
the binary guarded command operator
;
•
for each , for each ,
the -ary data parameterized action operator
;
•
for each ,
a unary assignment action operator
;
•
for each ,
a unary evaluation operator
.
We write for the set of all closed -I terms of sort
.
The same notational conventions are used as before.
Infix notation is also used for the additional binary operators.
Moreover, the notation , where and is a
-I term of sort , is used for the term .
The notation , where and are
-I terms of sort , is used for the term
.
The axioms of -I (given below) include an equation
for each two terms and from for which the
formula holds in .
Let be a term from , be a term from ,
and be terms from , and be a basic
action from .
Then the additional operators to build terms of sort can be
explained as follows:
•
the term denotes the process that behaves as the process
denoted by if condition holds and as otherwise;
•
the term denotes the process that performs the
data parameterized action and after that terminates
successfully;
•
the term denotes the process that performs the assignment
action , whose intended effect is the assignment of the
result of evaluating to flexible variable , and after that
terminates successfully;
•
the term denotes the process that behaves the same as
the process denoted by except that each subterm of that belongs
to is evaluated using the evaluation map updated
according to the assignment actions that have taken place at the point
where the subterm is encountered.
Evaluation operators are a variant of state operators
(see e.g. [1]).
The following closed -I term is reminiscent of a program that
computes the difference between two integers by subtracting the smaller
one from the larger one ():
That is, the final value of is the absolute value of the result of
subtracting the initial value of from the initial value of .
An evaluation operator can be used to show that this is the case for
given initial values of and .
For example, consider the case where the initial values of and
are and , respectively.
Let be an evaluation map such that and
.
Then the following equation can be derived from the axioms of -I given below:
This equation shows that in the case where the initial values of
and are and the final value of is (which is the
absolute value of the result of subtracting from ).
An evaluation map can be extended homomorphically from flexible
variables to -I terms of sort and -I terms of sort
.
These extensions are denoted by as well.
Below, we write for the evaluation map
defined by if and
.
Three subsets of are defined:
In -I, the elements of are the terms from
that denote the processes that are considered to be atomic.
Henceforth, we write for
and for .
The axioms of -I are the axioms presented in
Table 1, on the understanding that now stands
for an arbitrary term from , now stands for an
arbitrary subset of or the set , and now
stands for an arbitrary subset of , and in addition the
axioms presented in Table 2.
Table 2: Additional axioms of -I
In the latter table,
and stand for arbitrary terms from ,
, , and , stand for arbitrary
terms from ,
stands for an arbitrary flexible variable from ,
stands for an arbitrary evaluation map from ,
, and stand for arbitrary basic actions from , and
stands for an arbitrary term from .
Axioms GC1–GC12 have been taken from [2] (using a different
numbering), but with the axioms with occurrences of Hoare’s ternary
counterpart of the guarded command operator (see below) replaced by
simpler axioms.
Axioms CM7Da and CM7Db have been inspired by [8].
Axiom BED is axiom BE generalized to the current setting.
An equivalent axiomatization is obtained if axiom BED is replaced by
the equation
.
Some earlier extensions of ACP include Hoare’s ternary counterpart of
the binary guarded command operator (see e.g. [2]).
This operator can be defined by the equation
.
From this defining equation, it follows that
.
In [25], a unary counterpart of the binary guarded command
operator is used.
This operator can be defined by the equation .
From this defining equation, it follows that
and also that and
.
4 -I with Recursion
A closed -I term of sort denotes a process with a finite
upper bound to the number of actions that it can perform.
Recursion allows the description of processes without a finite upper
bound to the number of actions that it can perform.
A recursive specification over -I is a set
, where is a finite set,
each is a variable from , each is a -I term of
sort in which only variables from
occur, and for all with .
We write , where is a recursive specification over
-I, for the set of all variables that occur in .
Let be a recursive specification and let .
Then the unique equation is called the
recursion equation for in .
Below, recursive specifications over -I are introduced in which
the right-hand sides of the recursion equations are linear -I terms.
The set of linear -I terms is inductively defined by
the following rules:
•
;
•
if , then ;
•
if , , and , then
;
•
if , then .
Let .
Then we refer to the subterms of that have the form
or the form as the summands of .
Let be a variable from and
let be an -I term in which occurs.
Then an occurrence of in is guarded if has a subterm
of the form where and
contains this occurrence of .
An occurrence of a variable in a linear -I term may not be
guarded because a linear -I term may have summands of the form
.
A guarded linear recursive specification over -I is a
recursive specification over -I where each is a linear -I term, and there does not exist an
infinite sequence over such that, for each
, there is an occurrence of in
that is not guarded.
A linearizable recursive specification over -I is a
recursive specification over -I where each is rewritable to an -I term , using the
axioms of -I in either direction and the equations in
from left to right, such
that is a guarded linear recursive
specification over -I.
A solution of a guarded linear recursive specification over
-I in some model of -I is a set
of elements of the carrier of that
model such that each equation in holds if, for all ,
is assigned .
A guarded linear recursive specification has a unique solution under the
equivalence defined in Section 5 for -I extended with guarded linear recursion.
If is the unique solution of a guarded
linear recursive specification , then, for
each , is called the -component of the
unique solution of .
-I is extended with guarded linear recursion by adding constants
for solutions of guarded linear recursive specifications over -I and axioms concerning these additional constants.
For each guarded linear recursive specification over -I and
each , a constant of sort , that
stands for the -component of the unique solution of , is added to
the constants of -I.
The equation RDP (Recursive Definition Principle) and the conditional
equation RSP (Recursive Specification Principle) given in
Table 3 are added to the axioms of -I.
Table 3: Axioms for guarded linear recursion
In RDP and RSP, stands for an arbitrary variable from ,
stands for an arbitrary -I term of sort ,
stands for an arbitrary guarded linear recursive specification over
-I, and
the notation is used for with, for all
, all occurrences of in replaced by
.
Side conditions restrict what , and stand for.
We write -I+REC for the resulting theory.
Furthermore, we write for the set of all closed
terms of sort .
RDP and RSP together postulate that guarded linear recursive
specifications over -I have unique solutions:
the equations and the conditional equations
for a fixed express that the constants
make up a solution of and that this solution is the
only one, respectively.
Because conditional equational formulas must be dealt with in -I+REC,
it is understood that conditional equational logic is used in deriving
equations from the axioms of -I+REC.
A complete inference system for conditional equational logic can for
example be found in [3, 24].
We write , where is -I+REC or -I+REC+CFAR (an extension of -I+REC introduced below), to indicate that the
equation is derivable from the axioms of using a complete
inference system for conditional equational logic.
The following closed -I+REC term is reminiscent of a program that
computes by repeated subtraction the quotient and remainder of dividing a
non-negative integer by a positive integer ():
where is the guarded linear recursive specification that consists of
the following two equations ():
The final values of and are the quotient and remainder of
dividing the initial value of by the initial value of .
An evaluation operator can be used to show that this is the case for
given initial values of and .
For example, consider the case where the initial values of and
are and , respectively.
Let be an evaluation map such that and
.
Then the following equation can be derived from the axioms of -I+REC:
This equation shows that in the case where the initial values of
and are and the final values of and are and
(which are the quotient and remainder of dividing by ).
Below, use will be made of a reachability notion for the variables
occurring in a guarded linear recursive specification over -I.
Let be a guarded linear recursive specification over -I and
let .
Then is directly reachable from in , written
, if occurs in the right-hand side of the
recursion equation for in .
We write for the reflexive transitive closure of
.
Processes with one or more cycles of actions are not definable
by guarded linear recursion alone, but they are definable by combining
guarded linear recursion and abstraction.
An example is
The semantics of -I+REC presented in Section 5
identifies this with .
However, the equation
is not derivable from the axioms of -I+REC.
This is remedied by the addition of the equational axiom schema CFAR
(Cluster Fair Abstraction Rule) that will be presented below.
This axiom schema makes it possible to abstract from a cycle of actions
that are turned into the unobservable action , by which only the
ways out of the cycle remain.
The side condition on the equation concerned requires several notions to
be made precise.
Let be a guarded linear recursive specification over -I,
let , and
let .
Then:
•
is a cluster for in if,
for each -I term of sort that
is a summand of the right-hand side of the recursion equation for some
in , only if and
;666We write for syntactic equality.
•
for each cluster for in , the exit set of for
in , written , is the set of -I terms of
sort defined by iff is a summand of
the right-hand side of the recursion equation for some in
and one of the following holds:
–
for some ,
, and such that
or ;
–
for some ;
•
is a conservative cluster for in if is a cluster
for in and, for each and ,
.
The cluster fair abstraction rule is presented in
Table 4.
Table 4: Cluster fair abstraction rule
In this table,
stands for an arbitrary variable from ,
stands for an arbitrary guarded linear recursive specification over
-I,
stands for an arbitrary subset of , and
stand for arbitrary -I terms of sort .
A side condition restricts what , , , and
stand for.
CFAR expresses that every cluster of actions will be exited
sooner or later.
This is a fairness assumption made in the verification of many
properties concerning the external behaviour of systems.
We write -I+REC+CFAR for the theory -I+REC extended with CFAR.
5 Bisimulation Semantics
In this section, a structural operational semantics of -I+REC is
presented and a notion of branching bisimulation equivalence for
-I+REC based on this structural operational semantics is defined.
The structural operational semantics of -I+REC consists of
•
a binary conditional transition relation on
for each ;
•
a unary successful termination relation on
for each .
We write instead of
and
instead of .
The relations from the structural operational semantics describe what
the processes denoted by terms from are capable of doing as
follows:
•
:
if the data values assigned to the flexible variables are as defined by
, then the process denoted by has the potential to make a
transition to the process denoted by by performing action ;
•
:
if the data values assigned to the flexible variables are as defined
by , then the process denoted by has the potential to
terminate successfully.
The relations from the structural operational semantics of -I+REC are the smallest relations satisfying the rules given in
Table 5.
Table 5: Transition rules for -I
In this table,
and stand for arbitrary evaluation maps from
,
stands for an arbitrary action from ,
, and stand for arbitrary actions from ,
and stand for arbitrary terms
from ,
stands for an arbitrary subset of or the set
,
stands for an arbitrary subset of ,
stands for an arbitrary term from ,
stands for an arbitrary flexible variable from ,
stands for an arbitrary variable from ,
stands for an arbitrary -I term of sort , and
stands for an arbitrary guarded linear recursive specification over
-I.
The rules in Table 5 have the form
, where
is optional.
They are to be read as “if and …and then ,
provided ”.
As usual, are called the premises and is called the
conclusion.
A side condition , if present, serves to restrict the applicability
of a rule.
If a rule has no premises, then nothing is displayed above the
horizontal bar.
Because the rules in Table 5 constitute an inductive
definition, or
holds iff it can be inferred from these rules.
For instance, for , , and
such that , we have that
can be inferred by applying the first rule, the third rule for ,
the second rule for , and the third rule for in that order.
Two processes are considered equal if they can simulate each other
insofar as their observable potentials to make transitions and to
terminate successfully are concerned, taking into account the assigments
of data values to flexible variables under which the potentials are
available.
This can be dealt with by means of the notion of branching bisimulation
equivalence introduced in [41] adapted to the conditionality of
transitions in which the unobservable action is performed.
An equivalence relation on the set is needed.
Two actions are data equivalent,
written , iff one of the following holds:
•
there exists an such that
and ;
•
for some ,
there exist an and
such that
, …, ,
, and ;
•
there exist a and such that
, , and
.
We write , where , for the equivalence
class of with respect to .
For each , the binary relation on
defined as the reflexive transitive closure of
is also needed.
Moreover, we write ,
where and , for
or both
and .
A branching bisimulation is a binary relation on
such that, for all terms with
, the following transfer conditions hold:
•
if , then there exist an
and such that
,
,
, and ;
•
if , then there exist an
and such that
,
,
, and ;
•
if , then there exists a
such that , , and
;
•
if , then there exists a
such that , , and
.
If is a branching bisimulation, then a pair is said to
satisfy the root condition in if the following conditions
hold:
•
if , then there exist an
and a such that
and ;
•
if , then there exist an
and a such that
and ;
•
iff .
Two terms are
rooted branching bisimulation equivalent,
written , if there exists a branching bisimulation
such that and satisfies the root condition
in .
In Section 7, it is proved that is a
congruence with respect to the operators of -I+REC of which the
result sort and at least one argument sort is .
Without the root condition, would not be a congruence with
respect to the operator .
For example, it would be the case that and not
.
Let be a branching bisimulation such that and the
pair satisfies the root condition in .
Then we say that is a branching bisimulation witnessing
.
6 Interlude
In the preceding sections, two relatively uncommon choices have been
made:
•
the choice to include the rather unusual evaluation operators, i.e. for each , in the operators of
-I+REC;
•
the choice for a structural operational semantics of -I+REC with a
transition relation on for each
, while a transition relation
on for each
is arguably more common.
In this short section, the reasons for these choices are clarified.
The issues which influenced the above-mentioned choices most are:
•
the need for a variant of rooted branching bisimulation equivalence
that is a congruence with respect to all operators of -I+REC;
•
the need for a coarser equivalence in cases where parallel composition,
left merge, and communication merge are not involved.
With the chosen kind of transition relations, the first need can be
fulfilled with a simple and natural generalization of rooted branching
bisimulation equivalence as originally introduced in [41], but
with the more common kind of transition relations a less obvious variant
of rooted branching bisimulation equivalence, a ‘stateless’ variant in
the terminology of [32], has to be devised.
As a consequence, with the chosen kind of transition relations,
generalizations of existing proof techniques and proof ideas could be
used in establishing the soundness and semi-completeness results
presented in Section 7, whereas this would not be
the case with the more common kind of transition relations.
The variant of rooted branching bisimulation equivalence referred to at
the beginning of the previous paragraph is the equivalence
introduced at the end of Section 5.
In order to be a congruence with respect to parallel composition,
left merge, and communication merge, identifies two terms
from if the processes denoted by them can simulate each
other even in the case where the data values assigned to flexible
variables may change after each transition — through assignment actions
performed by parallel processes.
The second need mentioned above is the need for an equivalence that does
not takes such changes into account in cases where parallel composition,
left merge, and communication merge are not involved.
Two terms are equivalent according to this
coarser equivalence iff
for all .
This means that the coarser equivalence is covered in the semantics of
-I+REC by the choice to include the evaluation operators in the
operators of -I+REC.
We have that,
for all and ,
iff
(see Corollary 1 below).
So the axioms of -I+REC+CFAR, which constitute an equational
axiomatization of , are also adequate for equational
verification of the coarser equivalence.
In [25], an extension of ACP with the empty process constant,
the unary counterpart of the binary guarded command operator, and
actions to change a data-state is presented.
Evaluation maps can be taken as special cases of data-states.
For similar reasons as in the case of -I+REC, there is a need for
two equivalences.
This is not dealt with by the inclusion of evaluation operators.
Instead, in equational reasoning, certain axioms may only be applied to
terms in which the parallel composition, left merge, and communication
merge operators do not occur.
In an appendix, a structural operational semantics of -I+REC is
presented which is reminiscent of a symbolic operational semantics in
the sense of [28].
It is a structural operational semantics with a transition relation
on for each
, where is the set of
all terms for which
.
In my opinion, this structural operational semantics is intuitively more
appealing than the one presented in Section 5, but
the definition of the variant of rooted branching bisimulation
equivalence based on it is quite unintelligible.
7 Soundness and Completeness
In this section, soundness and (semi-)completeness results with respect
to branching bisimulation equivalence for the axioms of
-I+REC+CFAR are presented.
Firstly, rooted branching bisimulation equivalence is an equivalence
relation indeed.
Proposition 1 (Equivalence)
The relation is an equivalence relation.
Proof
It must be shown that is reflexive, symmetric, and
transitive.
Let .
Then the identity relation on is a branching
bisimulation such that and satisfies the root
condition in .
Hence, , which proves that is reflexive.
Let be such that , and
let be a branching bisimulation such that and
satisfies the root condition in .
Then is a branching bisimulation such that
and satisfies the root condition in
.
Hence, , which proves that is symmetric.
Let be such that and
,
let be a branching bisimulation such that and
satisfies the root condition in , and
let be a branching bisimulation such that and
satisfies the root condition in .
Then is a branching bisimulation such that
and satisfies the root condition
in .777We write for the composition of with .
That is a branching bisimulation is proved in the same way
as Proposition 7 in [4].
Hence, , which proves that is transitive.
∎
Moreover, rooted branching bisimulation equivalence is a congruence with
respect to the operators of -I+REC of which the result sort and at
least one argument sort is .
Proposition 2 (Congruence)
For all terms and all terms
,
and only if
,
,
,
,
,
,
,
, and
.
Proof
A detailed proof would contain an adapted copy of at least ten pages
from [23].
Therefore, only an outline of the proof is given here.
In order to fully understand the outline, the above-mentioned paper must
be consulted.
In [23], an SOS rule format is presented which guarantees that
the ‘standard’ version of branching bisimulation equivalence is a
congruence.
The format concerned is called the RBB safe format.
Below, this format is adapted in order to deal with a set of transition
labels that contains a special element for each
instead of a single special element and
with a slightly different version of branching bisimulation equivalence.
A definition of a patience rule is needed that differs from the one
given in [23]: a patience rule for the th argument of
an -ary operator is a path rule of the form
where .
The RBB safe format is adapted by making the following changes to the
definition of the RBB safe format as given in [23]:
•
in the two syntactic restrictions of the RBB safe format that concern
wild arguments, the phrase “a patience rule” is changed to
“a patience rule for each ”;
•
in the second syntactic restrictions of the RBB safe format that concern
wild arguments, the phrase “the relation ” is changed to
“the relation for some
”.
It is straightforward to check that the proof of Theorem 3.4
from [23] goes through for the adapted RBB safe format and the
version of branching bisimulation equivalence considered in this paper.
This means that the proposition holds if the rules in
Table 5 are in the adapted RBB safe format with respect
to some tame/wild labeling of arguments of operators.
It is easy to verify that this is the case with the following tame/wild
labeling:
both arguments of are tame,
the first argument of is wild and
the second argument of is tame,
both arguments of are wild,
both arguments of and are tame,
the argument of and is wild,
the second argument of is tame, and
the argument of is wild.
∎
The tame/wild labeling given at the end of the proof of
Proposition 2 is provided so that the
reader who consults [23] can easily check that the rules in
Table 5 are in the adapted RBB safe format.
Below, the soundness of the axiom system of -I+REC+CFAR with respect to
for equations between terms from will
be established.
The following terminology will be used in the soundness proof:
(a) an equation of -I+REC terms of sort is said to be
valid with respect to if, for each closed
substitution instance of , and
(b) a conditional equation of -I+REC terms of sort
is said to be valid with respect to if, for each
closed substitution instance
of , if for each .
Theorem 7.1 (Soundness)
For all terms , is derivable from the
axioms of -I+REC+CFAR only if .
Proof
Because is a congruence with respect to all operators from
the signature of -I+REC+CFAR, only the validity of each axiom of
-I+REC+CFAR has to be proved.
Below, we write , where is an equation of -I+REC terms of sort , for the set of all closed substitution instances
of .
Moreover, we write for the identity relation on .
For each axiom of -I+REC+CFAR, a rooted branching bisimulation
witnessing the validity of can be constructed as follows:
•
if is one of the axioms A7, CM2E, CM5E, CM6E, GC2 or an instance
of one of the axiom schemas D0, D2, T0, GC3, V0, CM7Db–CM7Df:
•
if is one of the axioms A1–A6, A8, A9, CM4, CM8–CM9, GC1 or an
instance of one of the axiom schemas CM3, CM7, D1, D3, D4, T1–T4,
GC4–GC12, V1–V6, CM7Da, RDP:
•
if is CM1E:
•
if is an instance of BE:
•
if is an instance of BED: similar;
•
if is an instance
of CFAR:
where is the finite conservative cluster for in such that
and ;
•
if is an instance
() of RSP:
where
is the set of all functions from to and
, where and , stands
for with, for all , all occurrences of replaced by
.
For each equational axiom of -I+REC+CFAR, it is straightforward to
check that the constructed relation is a branching bisimulation
witnessing, for each closed substitution instance of ,
.
For each conditional equational axiom of -I+REC+CFAR, i.e. for
each instance of RSP, it is straightforward to check that the
constructed relation is a branching bisimulation witnessing, for
each closed substitution instance
of , if for each .
∎
The axioms of -I+REC+CFAR are incomplete with respect to
for equations between terms from and there is no
straightforward way to rectify this.
Below two semi-completeness results are presented.
The next two lemmas are used in the proofs of those results.
A term is called abstraction-free if no
abstraction operator occurs in .
A term is called bool-conditional if,
for each that occurs in ,
or
.
Lemma 1
For all abstraction-free , there exists a guarded
linear recursive specification and such that
.
Proof
This is easily proved by structural induction on .
The proof involves constructions of guarded linear recursive
specifications from guarded linear recursive specifications for the
operators of -I other than the abstraction operators.
For the greater part, the constructions are reminiscent of operations
on process graphs defined in Sections 2.7 and 4.5.5 from [3].
∎
Lemma 2
For all bool-conditional , there exists a guarded
linear recursive specification and such that
.
Proof
This is also proved by structural induction on .
The cases other than the case where is of the form
are as in the proof of Lemma 1.
The case where is of the form is the difficult one.
It is proved in the same way as it is done for +REC+CFAR in the proof of
Theorem 5.6.2 from [22].
∎
The difficult case of the proof of Lemma 2 is
the only case in which an application of CFAR is involved.
The following two theorems are the semi-completeness results referred to
above.
Theorem 7.2 (Semi-completeness I)
For all abstraction-free ,
if .
Proof
Because of Lemma 1,
Theorem 7.1, and
Proposition 1, it suffices to prove that,
for all guarded linear recursive specifications and with
and ,
if
.
This is proved in the same way as it is done for +REC in the proof
of Theorem 5.3.2 from [22].
∎
Theorem 7.3 (Semi-completeness II)
For all bool-conditional ,
if .
Proof
Because of Lemma 2,
Theorem 7.1, and
Proposition 1, it suffices to prove that,
for all guarded linear recursive specifications and with
and ,
if
.
This is proved in the same way as it is done for +REC in the proof
of Theorem 5.3.2 from [22].
∎
It is due to sufficiently similar shapes of linear -I terms and
linear terms that parts of the proof of
Theorems 7.2
and 7.3 go in the same way as parts of
proofs from [22].
It needs mentioning here that, the body of the proof of Theorem 5.3.2
from [22] is restricted to constants where does
not contain equations with
.
The corresponding part of the proof of
Theorems 7.2
and 7.3 is likewise restricted to
constants where does not contain equations
with
.
This is not because such an equation can be eliminated, but because it
can be replaced by .
The following is a corollary of Theorems 7.1
and 7.3.
Corollary 1
For all , for all ,
iff
.
8 Information-Flow Security
In this section, it will be explained how -I can be used for
information-flow security analysis of the kind that is concerned with
the leakage of confidential data.
However, first, a general idea is given of what information-flow
security is about and what results have been produced by research on
this subject.
Consider a program whose variables are partitioned into high-security
variables and low-security variables.
High-security variables are considered to contain confidential data and
low-security variables are considered to contain non-confidential data.
The information flow in the program is called secure if information
derivable from data contained in the high-security variables cannot be
inferred from data contained in the low-security variables.
Secure information flow means that no confidential data is leaked.
A well-known program property that guarantees secure information flow is
non-interference.
In the case where the program is a deterministic sequential program,
non-interference is the property that the data initially contained in
high security variables has no effect on the data finally contained in
low security variables.
Theoretical work on information-flow security is already done since the
1970s (see e.g. [5, 17, 18, 14, 15]).
A great part of the work done until now has been done in a
programming-language setting.
This work has among other things led to security-type systems for
programming languages.
The languages concerned vary from languages supporting sequential
programming to languages supporting concurrent programming and from
languages for programming transformational systems to languages for
programming reactive systems
(see e.g. [42, 40, 12, 34, 10]).
However, work on information-flow security has also been done in a
process-algebra setting.
In such a setting, the information flow in a process is generally called
secure if information derivable from confidential actions cannot be
inferred from non-confidential actions
(see e.g. [20, 36, 11, 31]).
So, in a process-algebra setting, secure information flow usually means
that no confidential action is revealed.
Moreover, in such a setting, non-interference is the property that the
confidential actions have no effect on the non-confidential actions.
Recently, work done on information-flow security in a process-algebra
setting occasionally deals with the data-oriented notion of secure
information flow, but on such occasions program variables are always
mimicked by processes (see e.g. [21, 29]).
-I obviates the need to mimic program variables.
In the rest of this section, the interest is in processes that are
carried out by systems that have a state comprising a number of
data-containing components whose content can be looked up and changed.
Moreover, the attention is focussed on processes, not necessarily
arising from the execution of a program, in which (a) confidential and
non-confidential data contained in the state components of the system in
question are looked up and changed and (b) an ongoing interaction with
the environment of the system in question is maintained where data are
communicated in either direction.
In the terminology of -I, the state components are called flexible
variables.
From now on, processes of the kind described above are referred to as
processes of the type of interest.
The processes that are carried out by many contemporary systems are
covered by the processes of the type of interest.
The point of view is taken that the information flow in a process of the
type of interest is secure if information derivable from the
confidential data contained in state components cannot be inferred from
its interaction with the environment.
A process property that guarantees secure information flow in this sense
is the property that the confidential data contained in state components
has no effect on the interaction with the environment.
This property, which will be made more precise below, is called the DNII
(Data Non-Interference with Interactions) property.
For a process with this property, differences in the confidential data
contained in state components cannot be observed in
(a) what remains of the process in the case where only the actions that
are performed to interact with the environment are visible and
(b) consequently in the data communicated with the
environment.
For each closed -I+REC term of sort that denotes a
process of the type of interest, it is assumed that the following has
been given:
•
a set of low-security flexible
variables of ;
•
a set
of external actions of .
For each closed -I+REC term of sort that denotes a
process of the type of interest, we define the following sets:
where
is called the set of high-security flexible variables
of and is called the set of internal actions of
.
The flexible variables in are the flexible variables of
that contain non-confidential data and the flexible variables in
are the flexible variables of that contain confidential
data.
The actions in are the actions that are performed by to
interact with the environment and the actions in are the
actions that are performed by to do something else than to interact
with the environment.
The actions in are considered to be invisible in the
environment.
In earlier work based on a purely action-oriented notion of secure
information flow, the actions in and are called
low-security actions and high-security actions, respectively, or
something similar.
For each closed -I+REC term of sort that denotes a
process of the type of interest, has the DNII property iff
for all evaluation maps and such that
for all .
This definition is justified by the fact, which follows from
Corollary 1, that
The left-hand side and the right-hand side of the equation in the above
definition denote the processes that remain of the process denoted by
in the case that the data values assigned to the flexible variables
are initially as defined by and , respectively, and
moreover all internal actions of are not visible.
The condition imposed on the evaluation maps and
tells us that the equation must always hold if, for each low-security
flexible variable of , the data values assigned to it according to
and are the same.
This corresponds to the intuitive idea mentioned above that, for a
process with the DNII property, differences in the confidential data
cannot be observed in what remains of the process in the case where only
the actions that are performed to interact with the environment are
visible.
Assume that and .
Let be the closed -I+REC term
of sort with and .
is a very simple example of a term of which it may not be
immediately clear that it denotes a process that does not have the DNII
property.
Notice that, by definition, and
.
When is performed, this cannot be observed in the
externally observable process because is an internal
action.
This means that, irrespective of the value that is initially assigned to
, the externally observable process performs either or and
after that terminates successfully.
This is why the process denoted by may seem to have the DNII
property.
However, at the point that the externally observable process has the
option to perform , it has also the option to perform in the case
where the value initially assigned to is not , while it does not
have also the option to perform in the case where the value
initially assigned to is .
In other words, the externally observable process in the former case
differs from the externally observable process in the latter case.
This means that, whether or not is initially assigned to can be
inferred from the externally observable process.
Hence, the informal conclusion is that denotes a process that does
not have the DNII property.
More formally, this conclusion follows from the definition of the DNII
property: we have
for all evaluation maps such that
and we have
for all evaluation maps such that ,
but we do not have
In CSPσ[16], presumably the only imperative process
algebra that supports abstraction from actions that are considered not
to be visible, the DNII property cannot be defined.
The cause of this is that abstraction from actions that are
considered not to be visible means in CSPσ that these actions
are simply removed.
Because of that processes such as
and from the example given above
are equated.
Assume that and .
Let be the closed -I+REC term
of sort with and .
is a very simple example of a term that denotes a process that has
the DNII property.
This follows from the definition of the DNII property: we have
for all evaluation maps such that ,
we have
for all evaluation maps such that ,
and we trivially have
The DNII property is only one of the process properties related to
information flow security that can be defined and verified in
-I+REC+CFAR.
Insofar as information flow security of contemporary systems is
concerned, it seems to be an essential property.
The DNII property is also one of the process properties related to
information flow security that cannot be defined naturally in the
process algebras used in earlier work on information flow security
(cf. [20, 36, 11, 31]).
The problem with those process algebras is that state components must be
mimicked by processes in them.
The DNII property concerns the non-disclosure of confidential data,
contained in state components of a system, through the possibly ongoing
interaction of the system concerned with its environment.
To my knowledge, such a property has not been proposed in the literature
on information-flow security before.
However, the DNII property is reminiscent of the combination of data
non-interference and event non-interference as defined in [37],
but a comparison is difficult to make because of rather different
semantical bases.
9 Concluding Remarks
I have introduced an ACP-based imperative process algebra.
This process algebra distinguishes itself from imperative process
algebras such as VPLA [27], IPAL [33],
CSPσ[16], AWN [19], and the process algebra
proposed in [13] by the following three properties:
(1) it supports abstraction from actions that are considered not to be
visible;
(2) a verification of the equivalence of two processes in its semantics
is automatically valid in any semantics that is fully abstract with
respect to some notion of observable behaviour;
(3) it offers the possibility of equational verification of process
equivalence.
Properties (1)–(3) have been achieved by the inclusion of the silent
step constant and the abstraction operators in the
constants and operators of the process algebra, the use of the rooted
branching bisimulation equivalence relation for the
equivalence of processes in its semantics, and the provision of the
equational axiomatization of .
The axioms of the presented imperative process algebra are not complete
with respect to the equivalence of processes in its semantics.
There is no straightforward way to rectify this.
However, two semi-completeness results that may be relevant to various
applications of this imperative process algebra have been established.
One of those results is at least relevant to information-flow security
analysis.
The finiteness and linearity restrictions on guarded recursive
specifications are not needed for the uniqueness of solutions.
However, there would be no semi-completeness results without these
restrictions.
In this paper, I build on earlier work on ACP.
The axioms of have been taken from Section 5.3 of [3]
and the axioms for the guarded command operator have been taken
from [2].
The evaluation operators have been inspired by [7] and the
data parameterized action operators have been inspired by [8].
Acknowledgement
I thank two anonymous referees for carefully reading a preliminary
version of this paper, for suggesting improvements of the presentation
of the paper, and for pointing out two minor but annoying errors in it.
Appendix: Alternative Bisimulation Semantics
In this appendix, an alternative to the structural operational semantics
of -I+REC is presented and a definition of rooted branching
bisimulation equivalence for -I+REC based on this alternative
structural operational semantics is given.
This appendix is strongly based on Section 4 of [9].
We write for the set of all terms for
which .
As formulas of a first-order language with equality of , the terms
from are the formulas that are satisfiable in .
The alternative structural operational semantics of -I+REC consists
of
•
a binary conditional transition relation on
for each ;
•
a unary successful termination relation on
for each .
We write instead of
and
instead of .
The relations from this structural operational semantics describe what
the processes denoted by terms from are capable of doing as
follows:
•
:
if condition holds for the process denoted by , then this
process has the potential to make a transition to the process denoted by
by performing action ;
•
:
if condition holds for the process denoted by , then this
process has the potential to terminate successfully.
The relations from this structural operational semantics of -I+REC are the smallest relations satisfying the rules given in
Table 6.
Table 6: Transition rules for -I
In this table,
stands for an arbitrary action from ,
and stand for arbitrary terms from ,
, and stand for arbitrary basic actions from ,
and stand for arbitrary terms
from ,
stands for an arbitrary subset of or the set
,
stands for an arbitrary subset of ,
stands for an arbitrary evaluation map from ,
stands for an arbitrary flexible variable from ,
stands for an arbitrary variable from ,
stands for an arbitrary -I term of sort , and
stands for an arbitrary guarded linear recursive specification over
-I.
The alternative structural operational semantics is such that the
structural operational semantics presented in
Section 5 can be obtained by replacing each
transition by a transition
for each
for which , and
likewise each .
Two processes are considered equal if they can simulate each other
insofar as their observable potentials to make transitions and to
terminate successfully are concerned.
In the case of the alternative structural operational semantics, there
are two issues that together complicate matters:
•
simply relating a single transition of one of the processes to a single
transition of the other process does not work because a transition of
one process may be simulated by a set of transitions of another process;
•
simply ignoring all transitions in which the unobservable action
is performed does not work because the observable potentials to make
transitions and to terminate successfully may change by such
transitions.
The first issue is illustrated by the processes denoted by
and :
the only transition of the former process is simulated by the two
transitions of the latter process.
The second issue is illustrated by the processes denoted by
and :
by making the transition in which the unobservable action is
performed, the former process loses the potential to make the
transition in which the observable action is performed before
anything has been observed, whereas this potential is a potential of the
latter process so long as nothing has been observed.
The first issue alone can be dealt with by means of the notion of
splitting bisimulation equivalence introduced in [7] and the
second issue alone can be dealt with by means of the notion of branching
bisimulation equivalence introduced in [41] adapted to the
conditionality of transitions in which the unobservable action is
performed.
In order to deal with both issues, the two notions are combined.
We write ,
where and ,
for or
, , and .
The notation , where and
are -I terms of sort , is used
for the -I term .
An ab-bisimulation is a binary relation on such
that, for all terms with , the
following transfer conditions hold:
•
if , then
there exists a finite set such that
and,
for all , there exists an and,
for some , there exist
and
such that
,
,
for all with ,
and
,
,
and ;
•
if , then
there exists a finite set such that
and,
for all , there exists an and,
for some , there exist
and
such that
,
,
for all with ,
and
,
,
and ;
•
if , then
there exists a finite set such that
and,
for all ,
for some , there exist
and
such that
,
,
for all with ,
and
, and ;
•
if , then
there exists a finite set such that
and,
for all ,
for some , there exist
and
such that
,
,
for all with ,
and
, and .
If is an ab-bisimulation, then a pair is said to
satisfy the root condition in if the following conditions hold:
•
if , then
there exists a finite set such that
and,
for all , there exist an and
a such that
and
;
•
if , then
there exists a finite set such that
and,
for all , there exist an and
a such that
and
;
•
if , then
there exists a finite set such that
and,
for all , ;
•
if , then
there exists a finite set such that
and,
for all , .
Two terms are rooted ab-bisimulation
equivalent, written , if there exists an
ab-bisimulation such that and
satisfies the root condition in .
In the absence of the constant , rooted ab-bisimulation
equivalence is essentially the same as splitting bisimulation
equivalence as defined in [7].
In the absence of all terms of sort other than the constants
and , rooted ab-bisimulation equivalence is essentially
the same as rooted branching bisimulation equivalence as defined
in [41].
I conjecture that, for all terms ,
iff .
References
[1]
J. C. M. Baeten and J. A. Bergstra.
Global renaming operators in concrete process algebra.
Information and Control, 78(3):205–245, 1988.
doi:10.1016/0890-5401(88)90027-2
[2]
J. C. M. Baeten and J. A. Bergstra.
Process algebra with signals and conditions.
In M. Broy, editor, Programming and Mathematical Methods,
volume F88 of NATO ASI Series, pages 273–323. Springer-Verlag, 1992.
doi:10.1007/978-3-642-77572-713
[3]
J. C. M. Baeten and W. P. Weijland.
Process Algebra, volume 18 of Cambridge Tracts in
Theoretical Computer Science.
Cambridge University Press, Cambridge, 1990.
doi:10.1017/CBO9780511624193
[4]
A. A. Basten.
Branching bisimulation is an equivalence indeed!
Information Processing Letters, 58(3):141–147, 1996.
doi:10.1016/0020-0190(96)00034-8
[5]
D. E. Bell and L. J. La Padula.
Secure computer systems: Mathematical foundations and model.
Technical Report M74-244, MITRE Corporation, 1973.
[6]
J. A. Bergstra and J. W. Klop.
Process algebra for synchronous communication.
Information and Control, 60(1–3):109–137, 1984.
doi:10.1016/S0019-9958(84)80025-X
[7]
J. A. Bergstra and C. A. Middelburg.
Splitting bisimulations and retrospective conditions.
Information and Computation, 204(7):1083–1138, 2006.
doi:10.1016/j.ic.2006.03.003
[8]
J. A. Bergstra and C. A. Middelburg.
A process calculus with finitary comprehended terms.
Theory of Computing Systems, 53(4):645–668, 2013.
doi:10.1007/s00224-013-9468-x
[9]
J. A. Bergstra and C. A. Middelburg.
Using Hoare logic in a process algebra setting.
Fundamenta Informaticae, 179(4):321–344, 2021.
doi:10.3233/FI-2021-2026
[10]
A. Bohannon et al.
Reactive noninterference.
In CCS ’09, pages 79–90. ACM Press, 2009.
doi:10.1145/1653662.1653673
[11]
A. Bossi, R. Focardi, C. Piazza, and S. Rossi.
Verifying persistent security properties.
Computer Languages, Systems & Structures, 30(3–4):231–258,
2004.
doi:10.1016/j.cl.2004.02.005
[12]
G. Boudol and I. Castellani.
Noninterference for concurrent programs and thread systems.
Theoretical Computer Science, 281(1–2):109–130, 2002.
doi:10.1016/S0304-3975(02)00010-5
[13]
M. S. Bouwman, S. P. Luttik, W. R. M. Schols, and T. A. C. Willemse.
A process algebra with global variables.
Electronic Proceedings in Theoretical Computer Science,
322:33–50, 2020.
doi:10.4204/EPTCS.322.5
[14]
E. Cohen.
Information transmission in computational systems.
In SOSP ’77, pages 133–139. ACM Press, 1977.
doi:10.1145/1067625.806556
[15]
E. Cohen.
Information transmission in sequential programs.
In R. A. DeMillo, D. P. Dobkin, A. K. Jones, and R. J. Lipton,
editors, Foundations of Secure Computation, pages 297–335. Academic
Press, 1978.
[16]
R. Colvin and I. J. Hayes.
CSP with hierarchical state.
In M. Leuschel and H. Wehrheim, editors, IFM 2009, volume 5423
of Lecture Notes in Computer Science, pages 118–135. Springer-Verlag,
2009.
doi:10.1007/978-3-642-00255-7_9
[17]
D. E. Denning.
A lattice model of secure information flow.
Communications of the ACM, 19(5):236–243, 1976.
doi:10.1145/360051.360056
[18]
D. E. Denning and P. J. Denning.
Certification of programs for secure information flow.
Communications of the ACM, 20(7):504–513, 1977.
doi:10.1145/359636.359712
[19]
A. Fehnker, R. J. van Glabbeek, P. Höfner, A. McIver, M. Portmann, and
W. L. Tan.
A process algebra for wireless mesh networks.
In H. Seidl, editor, ESOP 2012, volume 7211 of Lecture
Notes in Computer Science, pages 295–315. Springer-Verlag, 2012.
doi:10.1007/978-3-642-28869-2_15
[20]
R. Focardi and R. Gorrieri.
A classification of security properties for process algebras.
Journal of Computer Security, 3(1):5–33, 1995.
doi:10.3233/JCS-1994/1995-3103
[21]
R. Focardi, S. Rossi, and A. Sabelfeld.
Bridging language-based and process calculi security.
In V. Sassone, editor, FOSSACS 2005, volume 3441 of Lecture Notes in Computer Science, pages 299–315. Springer-Verlag, 2005.
doi:10.1007/978-3-540-31982-5_19
[22]
W. J. Fokkink.
Introduction to Process Algebra.
Texts in Theoretical Computer Science, An EATCS Series.
Springer-Verlag, Berlin, 2000.
doi:10.1007/978-3-662-04293-9
[23]
W. J. Fokkink.
Rooted branching bisimulation as a congruence.
Journal of Computer and System Sciences, 60(1):13–37, 2000.
doi:10.1006/jcss.1999.1663
[24]
J. A. Goguen.
Theorem proving and algebra.
arXiv:2101.02690 [cs.LO], January 2021.
arXiv:2101.02690
[25]
J. F. Groote and A. Ponse.
Process algebra with guards: Combining Hoare logic with process
algebra.
Formal Aspects of Computing, 6(2):115–164, 1994.
doi:10.1007/BF01221097
[26]
D. Harel and A. Pnueli.
On the development of reactive systems.
In K. Apt, editor, Logics and Models of Concurrent Systems,
volume F13 of NATO ASI Series, pages 477–498. Springer-Verlag, 1985.
doi:10.1007/978-3-642-82453-1_17
[27]
M. Hennessy and A. Ingólfsdóttir.
Communicating processes with value-passing and assignments.
Formal Aspects of Computing, 5(5):432–466, 1993.
doi:10.1007/BF01212486
[28]
M. Hennessy and H. Lin.
Symbolic bisimulations.
Theoretical Computer Science, 138:353–389, 1995.
doi:10.1016/0304-3975(94)00172-F
[29]
K. Honda and N. Yoshida.
A uniform type structure for secure information flow.
ACM Transactions on Programming Languages and Systems,
29(6):Article 31, 2007.
doi:10.1145/1286821.1286822
[30]
L. Lamport.
The temporal logic of actions.
ACM Transactions on Programming Languages and Systems,
16(3):872–923, 1994.
doi:10.1145/177492.177726
[31]
G. Lowe.
Semantic models for information flow.
Theoretical Computer Science, 315(1):209–256, 2004.
doi:10.1016/j.tcs.2003.11.019
[32]
M. R. Mousavi, M. A. Reniers, and J. F. Groote.
Notions of bisimulation and congruence formats for SOS with data.
Information and Computation, 200:107–147, 2005.
doi:10.1016/j.ic.2005.03.002
[33]
R. De Nicola and R. Pugliese.
Testing semantics of asynchronous distributed programs.
In M. Dam, editor, LOMAPS 1996, volume 1192 of Lecture
Notes in Computer Science, pages 320–344. Springer-Verlag, 1997.
doi:10.1007/3-540-62503-8_15
[34]
K. R. O’Neill, M. R. Clarkson, and S. Chong.
Information-flow security for interactive programs.
In CSFW 2006, pages 190–201. IEEE, 2006.
doi:10.1109/CSFW.2006.16
[35]
D. Pigozzi and A. Salibra.
The abstract variable-binding calculus.
Studia Logica, 55(1):129–179, 1995.
doi:10.1007/BF01053036
[36]
P. Y. A. Ryan and S. A. Schneider.
Process algebra and non-interference.
In CSFW 1999, pages 214–227. IEEE, 1999.
doi:10.1109/CSFW.1999.779775
[37]
N. B. Said and I. Cristescu.
End-to-end information flow security for web services orchestration.
Science of Computer Programming, 187:102376, 2020.
doi:10.1016/j.scico.2019.102376
[38]
D. Sannella and A. Tarlecki.
Algebraic preliminaries.
In E. Astesiano, H.-J. Kreowski, and B. Krieg-Brückner,
editors, Algebraic Foundations of Systems Specification, pages 13–30.
Springer-Verlag, Berlin, 1999.
doi:10.1007/978-3-642-59851-7_2
[39]
F. B. Schneider.
On Concurrent Programming.
Graduate Texts in Computer Science. Springer-Verlag, Berlin, 1997.
doi:10.1007/978-1-4612-1830-2
[40]
G. Smith and D. Volpano.
Secure information flow in a multi-threaded imperative language.
In POPL ’98, pages 355–364. ACM Press, 1998.
doi:10.1145/268946.268975
[41]
R. J. van Glabbeek and W. P. Weijland.
Branching time and abstraction in bisimulation semantics.
Journal of the ACM, 43(3):555–600, 1996.
doi:10.1145/233551.233556
[42]
D. Volpano, C. Irvine, and G. Smith.
A sound type system for secure flow analysis.
Journal of Computer Security, 4(3):167–187, 1996.
doi:10.3233/JCS-1996-42-304
[43]
M. Wirsing.
Algebraic specification.
In J. van Leeuwen, editor, Handbook of Theoretical Computer
Science, volume B, pages 675–788. Elsevier, Amsterdam, 1990.
doi:10.1016/B978-0-444-88074-1.50018-4