technical

report

ECRC

-LCB-

-LCB-

True

Concurrency

Semantics

for

a

Linear

Logic

Programming

Language

with

Broadcast

Communication

Jean-Marc

Andreoli

Lone

Leth

Remo

Pareschi

Bent

Thomsen

EUROPEAN

COMPUTER-INDUSTRY

RESEARCH

CENTRE

ECRC

GMBH

ARABELLASTR

MUNCHEN

GERMANY

TEL

FAX

TLX

c

European

Computer-Industry

Research

Centre

February

Neither

the

authors

of

this

report

nor

the

European

Computer-Industry

Research

Centre

GmbH

Munich

Germany

make

any

warranty

express

or

implied

or

assume

any

legal

liability

for

the

accuracy

completeness

or

usefulness

of

any

information

apparatus

product

or

process

disclosed

or

represent

that

its

use

would

not

in

fringe

privately

owned

rights

Permission

to

copy

in

whole

or

in

part

is

granted

for

non-profit

educational

and

research

purposes

provided

that

all

such

whole

or

partial

copies

include

the

following

a

notice

that

such

copying

is

by

the

permission

of

the

European

Computer-Industry

Research

Centre

GmbH

Munich

Germany

an

acknowledgement

of

the

authors

and

individual

contributors

to

the

work

all

applicable

portions

of

this

copyright

notice

Copying

reproducing

or

republishing

for

any

other

purpose

shall

require

a

license

with

payment

of

fee

to

the

European

Computer-Industry

Research

Centre

GmbH

Munich

Germany

All

rights

reserved

ii

Abstract

This

report

is

to

appear

in

the

proceedings

of

the

TAPSOFT

conference

held

in

Paris

-LRB-

France

-RRB-

in

April

We

define

a

true

concurrency

semantics

for

LO

a

reactive

programming

language

characterized

by

dynamically

reconfigurable

agents

-LRB-

processes

-RRB-

with

interagent

communication

implemented

as

broadcasting

and

logical

operators

corresponding

to

Linear

Logic

connectives

Our

semantic

model

is

given

by

the

well-known

Chemical

Abstract

Machine

formalism

where

concurrent

events

happen

in

the

form

of

chemical-like

reactions

Our

approach

consists

of

mapping

LO

computations

into

CHAM

computations

and

is

easily

generalizable

to

CHAM-related

models

like

CHARMs

rewriting

logics

etc.

We

propose

two

mappings

from

LO

to

CHAMs

both

making

use

of

the

membrane

mechanism

of

the

CHAM

but

differing

in

the

choice

of

active

elements

in

one

case

the

messages

are

passive

and

the

agents

are

the

active

entities

which

perform

read

and

write

operations

by

contrast

in

the

second

case

the

agents

are

passive

with

respect

to

communication

and

the

messages

themselves

move

around

the

solution

to

deliver

their

content

to

each

agent

The

results

in

the

paper

show

the

effectiveness

of

the

CHAM

and

related

formalisms

as

abstract

frameworks

for

modeling

the

implementation

of

practical

languages

on

parallel

architectures

Furthermore

they

provide

insight

on

the

two

following

issues

-LRB-

i

-RRB-

the

amount

of

synchronization

needed

to

add

broadcasting

to

one-to-one

communication

primitives

-LRB-

ii

-RRB-

the

problem

of

parallel

searching

for

Linear

Logic

proofs

iii

Contents

Introduction

CHAM

Preliminaries

LO

Programs

Resources

Proofs

Operational

Interpretation

of

the

Inference

Figures

Proof

Construction

Control

of

Broadcast

Communication

Encoding

LO

Computations

into

CHAM

Computations

The

Basic

Case

No

Broadcasting

Implementation

of

the

Broadcast

Mechanism

Linear

Time

Branching

Time

Discussion

Constructing

Proofs

in

Linear

Logic

Broadcasting

iv

Introduction

In

this

paper

we

provide

a

true

concurrency

semantic

characterization

for

LO

-LSB-

-RSB-

a

language

designed

for

programming

reactive

systems

LO

is

finding

applications

in

such

fields

as

parallel

algorithms

-LSB-

-RSB-

distributed

simulations

-LSB-

-RSB-

and

as

a

coordination

language

for

extending

the

capabilities

of

objectoriented

languages

-LSB-

-RSB-

LO

views

the

computation

as

performed

by

concurrent

agents

that

are

themselves

characterized

by

multiple

concurrent

internal

threads

of

computation

agents

can

self-replicate

and

their

primary

form

of

communication

is

broadcasting

LO

's

operators

correspond

to

Linear

Logic

connectives

-LSB-

-RSB-

hence

LO

can

be

viewed

as

a

linear

logic

programming

language

One

main

motivation

for

giving

a

true

concurrency

semantics

to

LO

is

that

it

provides

us

with

an

exact

picture

of

the

different

options

available

for

its

parallel

implementation

More

generally

we

want

also

to

gain

insight

on

synchronization

problems

related

to

broadcasting

and

on

the

subject

of

parallel

search

of

Linear

Logic

proofs

As

far

as

broadcasting

in

LO

is

concerned

a

major

issue

is

soundness

-LRB-

that

is

the

requirement

that

every

message

is

delivered

exactly

once

to

each

receiver

-RRB-

under

the

assumption

that

the

number

of

receiving

agents

may

change

at

run

time

this

situation

is

common

to

other

reactive

systems

be

they

concurrent

programming

languages

or

operating

systems

As

far

as

proofs

in

Linear

Logic

are

concerned

we

shall

show

that

CHAMs

provide

proof

encodings

characterized

by

a

similar

degree

of

parallelism

as

Proof

Nets

-LSB-

-RSB-

but

better

suited

for

practical

implementation

in

the

context

of

linear

logic

programming

Our

model

of

true

concurrency

is

given

by

the

well-known

Chemical

Abstract

Machine

-LRB-

CHAM

-RRB-

framework

-LSB-

-RSB-

which

extends

the

Gamma

model

-LSB-

-RSB-

and

where

concurrent

events

take

the

form

of

chemical-like

reactions

Our

approach

consists

of

mapping

LO

computations

into

CHAM

rewrite

sequences

and

is

easily

generalizable

to

formalisms

related

to

the

CHAM

like

CHARMs

-LSB-

-RSB-

rewriting

logics

-LSB-

-RSB-

etc.

The

rest

of

this

paper

is

structured

as

follows

Section

recalls

the

main

points

about

the

CHAM

Section

formally

describes

LO

and

its

model

of

concurrent

computation

In

section

we

show

how

LO

computations

can

be

encoded

into

CHAM

computations

We

start

from

the

basic

case

of

LO

computations

where

no

broadcasting

is

involved

and

then

we

consider

how

things

change

once

broadcasting

has

to

be

taken

into

account

in

terms

of

the

corresponding

CHAM

encodings

this

will

typically

imply

with

respect

to

the

situation

characterized

by

absence

of

broadcasting

the

introduction

of

a

notion

of

time

to

indicate

that

a

given

agent

has

already

seen

or

has

not

yet

seen

a

certain

message

Different

choices

will

be

possible

here

by

making

time

either

linear

or

branching

for

all

cases

theorems

will

be

provided

to

show

the

correctness

and

the

completeness

of

the

encodings

Finally

we

shall

devote

section

to

the

discussion

of

the

results

Remark

due

to

space

restrictions

the

proofs

of

the

theorems

are

omitted

They

are

available

in

the

technical

report

version

of

this

paper

CHAM

Preliminaries

The

basic

idea

of

the

CHAM

-LSB-

-RSB-

is

that

the

state

of

a

system

is

like

a

chemical

solution

where

molecules

float

around

These

molecules

can

interact

with

each

other

according

to

some

reaction

rules

Possible

contact

between

molecules

is

provided

for

by

some

means

of

a

stirring

mechanism

The

solution

transformation

process

is

truly

parallel

since

any

number

of

transformations

can

be

performed

at

the

same

time

when

several

rules

can

be

applied

to

the

solution

simultaneously

and

no

molecule

is

involved

in

more

than

one

rule

Subsolutions

can

also

be

transformed

in

parallel

Solutions

are

shown

using

membrane

delimiters

fj

jg

and

can

be

treated

as

molecules

or

appear

as

subsolutions

in

a

molecule

In

the

following

m

ranges

over

molecules

and

S

ranges

over

solutions

with

-RSB-

being

multiset

union

There

are

certain

laws

associated

with

a

CHAM

The

reaction

laws

comprise

the

rewrite

rules

of

the

CHAM

and

these

rules

are

specific

to

each

CHAM

The

rewrite

rules

only

apply

to

molecules

in

solutions

not

within

molecules

Using

the

CHAM

rewrite

rules

a

multiset

of

molecules

is

related

to

a

multiset

of

molecules

A

solution

consisting

of

an

instance

of

a

left

hand

side

of

a

reaction

rule

can

be

substituted

by

a

solution

consisting

of

the

corresponding

instance

of

the

rules

right

hand

side

In

addition

to

the

reaction

laws

there

are

three

meta

rules

-LSB-

-RSB-

The

chemical

law

S

S

-RSB-

-RSB-

describes

how

parts

of

a

multiset

can

be

rewritten

The

membrane

law

S

fj

C

-LSB-

S

-RSB-

jg

fj

C

-LSB-

-RSB-

jg

states

that

a

solution

can

be

rewritten

inside

any

context

The

reversible

airlock

law

presented

in

some

CHAM

's

fj

fmg

-RSB-

S

jg

fj

m

S

jg

converts

any

arbitrary

solution

into

a

singleton

solution

isolating

the

molecule

m

This

rule

adds

a

means

for

introducing

some

sequentiality

into

the

otherwise

extremely

parallel

CHAM

model

Apart

from

these

meta

rules

a

CHAM

will

consist

of

axioms

for

transforming

molecules

on

the

form

mp

LO

Programs

Resources

Proofs

LO

programs

are

built

from

the

following

operators

par

-LRB-

written

-RRB-

with

-LRB-

written

-RRB-

becomes

-LRB-

written

ffi

-RRB-

and

top

-LRB-

written

-RRB-

We

assume

an

initial

-LRB-

possibly

infinite

-RRB-

set

of

atomic

formulae

A

from

which

we

can

recursively

define

two

classes

of

expressions

resource

formulae

R

and

program

formulae

P

R

A

j

R+R

j

R&R

j

P

A

ffi

R

j

A

P

A

program

is

a

set

of

program

formulae

and

a

context

is

a

finite

multiset

of

resource

formulae

An

LO

sequent

is

a

pair

written

as

P

C

where

P

is

a

program

and

C

is

a

context

A

proof

is

a

tree

structure

whose

nodes

are

labeled

with

LO

sequents

By

convention

a

proof

tree

is

graphically

represented

with

its

root

at

the

bottom

and

growing

upward

Its

branches

are

obtained

as

instances

of

the

following

inference

figures

ffl

Decomposition

inference

figures

-LSB-

-RSB-

P

C

P

C

-LSB-

-RSB-

P

C

-LSB-

-RSB-

P

C

P

C

P

C

ffl

Progression

inference

figure

-LSB-

ffi

-RSB-

P

C

R

P

C

An

if

-LRB-

An

ffi

R

-RRB-

P

In

these

figures

P

and

C

denote

respectively

a

program

and

a

context

R

denote

resource

formulae

and

the

expression

C

R

denotes

the

context

obtained

as

the

multiset

union

of

C

and

the

singleton

R.

Notice

that

by

definition

the

elements

of

a

multiset

are

not

ordered

Therefore

the

order

of

the

atoms

in

the

left-hand

side

of

a

program

formula

is

not

relevant

Operational

Interpretation

of

the

Inference

Figures

Read

bottom-up

a

proof

with

root

sequent

P

C

gives

us

a

static

representation

-LRB-

a

snapshot

-RRB-

of

the

overall

evolution

of

a

system

of

agents

working

on

the

initial

set

of

resources

C

under

program

P.

Each

branch

of

proof

represents

the

evolution

of

one

agent

the

nodes

are

the

agent

states

while

the

edges

are

the

state

transitions

The

open

leaves

are

the

agents

still

living

at

the

time

of

the

snapshot

Program

formulae

define

the

allowed

state

transitions

They

can

be

thought

of

as

composed

of

two

parts

an

input

part

-LRB-

left-hand

side

of

the

symbol

ffi

-RRB-

and

an

output

part

-LRB-

right-hand

side

of

the

symbol

ffi

-RRB-

implementing

respectively

the

consumption

and

the

production

of

resources

from/to

the

agent

's

state

However

the

operation

of

producing

new

resources

is

here

more

complex

than

in

standard

multiset

rewriting

and

may

in

fact

involve

the

creation

of

new

agents

or

the

termination

of

existing

ones

Indeed

when

the

output

part

of

a

program

formula

is

produced

into

a

context

by

application

of

the

progression

inference

figure

-LSB-

ffi

-RSB-

it

is

recursively

decomposed

by

application

of

the

decomposition

inference

figures

which

will

either

terminate

the

agent

-LRB-

inference

figure

-LSB-

-RSB-

-RRB-

or

create

a

new

agent

by

cloning

-LRB-

inference

figure

-LSB-

-RSB-

-RRB-

or

simply

add

new

components

in

the

context

of

the

agent

-LRB-

inference

figure

-LSB-

-RSB-

-RRB-

However

we

have

not

yet

explained

how

broadcast

communication

among

agents

is

realized

as

a

matter

of

fact

this

is

not

done

in

terms

of

an

explicit

inference

figure

but

is

instead

achieved

as

a

side

effect

of

how

proof

trees

are

constructed

We

detail

the

mechanism

of

proof

construction

in

the

next

section

Proof

Construction

A

program

call

is

a

pair

hP

Ri

consisting

of

an

LO

program

P

and

a

resource

formula

R.

Definition

A

target

proof

for

a

program

call

hP

Ri

is

a

proof

such

that

its

root

is

a

sequent

of

the

form

P

C

R

where

C

is

a

context

containing

only

atoms

In

other

words

target

proofs

are

searched

in

such

a

way

that

the

context

at

their

root

node

may

properly

contain

the

initial

resource

of

the

program

call

We

consider

two

proof

construction

mechanisms

Let

be

any

LO

proof

ffl

Expansion

Let

be

an

open

leaf

of

whose

sequent

matches

the

lower

sequent

of

an

inference

figure

Let

be

the

proof

obtained

by

expanding

at

node

with

branches

to

new

open

leaves

labeled

with

the

upper

sequent

-LRB-

s

-RRB-

of

the

selected

inference

figure

We

write

-RRB-

e

ffl

Instantiation

Let

be

the

proof

obtained

by

adding

an

occurrence

of

a

given

atom

to

the

context

at

each

node

of

We

write

-RRB-

i

Clearly

these

proof

construction

mechanisms

are

sound

in

the

following

sense

Theorem

If

is

a

target

proof

for

a

given

program

call

and

-RRB-

e

or

-RRB-

i

then

is

also

a

target

proof

for

that

program

call

Definition

A

proof

construction

sequence

is

a

sequence

of

proofs

n

such

that

n

k

-RRB-

e

k

or

k

-RRB-

i

k

The

trivial

proof

o

reduced

to

the

single

node

P

R

is

obviously

a

target

proof

for

the

program

call

hP

Ri

Hence

by

application

of

theorem

so

is

any

proof

such

that

there

exists

a

proof

construction

sequence

leading

from

o

to

Furthermore

it

can

be

shown

that

the

proofs

obtained

by

this

method

are

all

the

possible

target

proofs

for

the

program

call

so

that

the

two

construction

mechanisms

introduced

above

are

also

complete

In

the

agent-oriented

computational

interpretation

of

proof

construction

an

expansion

step

corresponds

to

an

agent

state

transition

whereas

an

instantiation

step

corresponds

to

a

form

of

communication

by

broadcasting

indeed

the

atom

which

is

added

to

all

the

nodes

in

an

instantiation

step

acts

as

a

message

broadcast

to

all

the

living

agents

in

the

system

-LRB-

p

q

-RRB-

r

s

-LSB-

-RSB-

-LSB-

-RSB-

p

q

p

q

-LSB-

-RSB-

r

s

r

s

-LRB-

p

q

-RRB-

r

s

-LSB-

-RSB-

-LSB-

-RSB-

p

q

a

p

q

a

-LSB-

-RSB-

r

a

-LSB-

ffi

-RSB-

-LSB-

-RSB-

s

a

r

s

a

-LRB-

p

q

-RRB-

r

s

a

-LSB-

-RSB-

-LSB-

-RSB-

-LSB-

ffi

-RSB-

-LSB-

-RSB-

q

p

q

a

p

q

a

-LSB-

-RSB-

-LSB-

ffi

-RSB-

-LSB-

-RSB-

r

a

-LSB-

ffi

-RSB-

-LSB-

-RSB-

s

a

r

s

a

-LRB-

p

q

-RRB-

r

s

a

Figure

A

subsequence

of

a

regular

proof

construction

sequence

Control

of

Broadcast

Communication

Unfortunately

the

two

mechanisms

of

expansion

-LRB-

i.e.

state

transition

-RRB-

and

instantiation

-LRB-

i.e.

broadcast

communication

-RRB-

are

here

completely

disconnected

indeed

it

can

be

shown

that

any

expansion

step

permutes

with

any

instantiation

step

In

order

to

allow

a

form

of

synchronization

between

the

two

mechanisms

required

in

most

applications

we

introduce

a

pragmatic

tool

which

gives

the

programmer

some

control

over

the

order

of

execution

of

expansion

steps

and

instantiation

steps

in

proof

constructions

-LRB-

we

loose

completeness

here

-RRB-

Let

be

a

special

symbol

called

the

broadcast

marker

which

can

be

used

to

prefix

any

atom

in

the

input

part

of

a

program

formula

Consider

then

the

following

program

formula

p

a

ffi

r

This

means

that

to

apply

this

program

formula

in

an

expansion

step

using

the

progression

inference

figure

the

atom

p

-LRB-

unmarked

-RRB-

must

be

found

in

the

context

of

the

selected

node

while

the

atom

a

is

added

to

this

context

by

performing

beforehand

an

instantiation

step

adding

a

to

all

the

nodes

of

the

Except

in

this

situation

no

other

instantiation

steps

are

allowed

A

proof

construction

sequence

satisfying

this

requirement

is

called

regular

In

the

rest

of

this

paper

we

consider

only

regular

proof

construction

sequences

and

we

take

the

phrase

proof

construction

to

mean

regular

proof

construction

Definition

Let

be

proofs

We

write

=-RRB-

if

there

exists

a

-LRB-

regular

-RRB-

proof

construction

sequence

from

to

Clearly

the

relation

=-RRB-

is

reflexive

transitive

Consider

for

example

the

following

LO

program

f

p

a

ffi

q

a

ffi

r

a

ffi

s

a

ffi

g

Then

as

the

reader

may

easily

verify

=-RRB-

=-RRB-

=-RRB-

where

and

are

the

proofs

in

Fig.

-LRB-

In

the

figure

the

program

is

omitted

from

the

left-hand

side

of

the

sequents

-RRB-

The

step

between

and

consists

of

an

instantiation

step

-LRB-

broadcasting

a

-RRB-

prior

to

an

expansion

step

using

the

progression

inference

figure

with

the

fourth

program

formula

on

the

rightmost

open

leaf

of

This

instantiation

step

is

indeed

allowed

by

the

presence

of

the

broadcast

marker

in

the

program

formula

used

the

difference

here

between

our

broadcast

marker

and

the

tell

mechanism

of

Concurrent

Constraint

Logic

Programming

Languages

-LSB-

-RSB-

in

our

case

a

copy

of

each

broadcast

message

is

delivered

to

each

receiver

which

can

locally

consume

it

on

the

other

hand

told

constraints

are

added

to

the

global

constraint

store

from

where

they

can

not

be

removed

Encoding

LO

Computations

into

CHAM

Computations

In

this

section

we

show

how

LO

computations

can

be

mapped

into

corresponding

CHAM

computations

The

basic

idea

is

that

each

open

leaf

of

an

LO

proof

which

represents

a

living

agent

of

the

system

is

mapped

into

a

sub-solution

in

the

CHAM

The

following

definition

which

will

be

exploited

later

on

in

the

translation

schemes

maps

a

resource

formula

into

the

set

of

multisets

of

atoms

which

it

yields

when

decomposed

-LRB-

by

application

of

the

Decomposition

inference

figures

-RRB-

Definition

Let

R

be

a

resource

formula

we

take

kRk

to

be

the

set

of

par-components

of

R

defined

inductively

as

follows

Each

par-component

is

a

multiset

of

atoms

If

Then

R

kRk

f

-RSB-

s.t.

and

R

kRk

-LSB-

R

kRk

R

is

an

atom

A

kRk

ffAgg

Thus

for

example

if

R

is

the

resource

formula

-LRB-

p

q

-RRB-

r

then

recursive

application

of

the

definition

above

yields

two

par-components

respectively

fp

rg

and

fq

rg

These

are

indeed

the

multisets

of

resources

which

replace

the

resource

R

in

the

two

branches

of

proof

obtained

in

its

decomposition

We

first

give

the

translation

from

LO

to

CHAM

computations

in

the

simple

case

of

programs

without

occurrences

of

the

broadcast

marker

and

then

we

extend

the

basic

mapping

scheme

with

the

broadcast

mechanism

The

Basic

Case

No

Broadcasting

The

CHAM

used

here

is

simply

composed

of

a

set

of

subsolutions

Each

subsolution

represents

an

open

node

in

the

proof

-LRB-

i.e.

a

living

agent

-RRB-

and

contains

a

multiset

of

resource

formulae

-LRB-

i.e.

the

state

of

the

corresponding

agent

-RRB-

Definition

Let

be

a

proof

We

take

cham

-LRB-

-RRB-

to

be

the

CHAM

solution

consisting

of

the

subsolutions

of

the

form

fj

C

jg

where

C

is

the

context

at

an

open

leaf

of

The

following

definitions

provide

translation

schemes

for

mapping

progression

and

decomposition

inference

figures

into

CHAM

rules

in

the

case

of

LO

programs

where

no

program

formula

is

decorated

with

the

broadcast

marker

Definition

-LRB-

Progression

rules

-RRB-

Let

P

Ar

ffi

R

be

a

program

formula

we

take

P

to

be

the

following

CHAM

rule

Ar

R

Thus

according

to

this

definition

the

progression

inference

figure

-LSB-

ffi

-RSB-

disappears

altogether

in

the

CHAM

formulation

as

the

application

of

each

program

formula

according

to

this

inference

figure

gets

directly

compiled

into

a

corresponding

CHAM

rule

Definition

-LRB-

Decomposition

rules

-RRB-

Let

R

be

a

resource

formula

we

take

R

to

be

the

following

CHAM

rule

If

Then

R

is

the

rule

kRk

fj

R

S

jg

kRk

f

g

R

kRk

f

ng

with

n

fj

R

S

jg

fj

S

-RSB-

jg

fj

S

-RSB-

n

jg

Just

as

above

the

decomposition

inference

figures

are

compiled

away

into

CHAM

rules

for

each

resource

formula

to

which

they

apply

By

definition

the

par-components

of

a

resource

formula

R

are

the

multisets

of

atoms

obtained

by

recursively

applying

the

decomposition

inference

figures

to

R

till

only

atomic

formulae

remain

When

there

is

only

one

par-component

-LRB-

second

line

of

the

table

in

the

definition

above

-RRB-

the

decomposition

is

purely

local

to

the

subsolution

in

which

it

occurs

On

the

other

hand

when

there

are

zero

or

more

than

one

par-components

-LRB-

first

and

third

line

respectively

in

the

table

-RRB-

the

content

of

the

global

solution

is

modified

as

the

whole

subsolution

where

the

decomposition

applies

may

disappear

or

may

be

cloned

a

number

of

times

this

global

behavior

is

achieved

via

the

use

of

the

airlock

mechanism

of

the

CHAM

which

involves

a

form

of

sequentialization

We

can

now

formally

state

the

equivalence

between

LO

computations

and

CHAM

computations

as

follows

Theorem

Let

P

be

an

LO

program

-LRB-

with

no

occurrence

of

the

broadcast

marker

-RRB-

and

let

and

be

two

proofs

based

on

P

We

consider

on

one

hand

-LRB-

regular

-RRB-

proof

construction

sequences

based

on

P

and

on

the

other

hand

the

CHAM

consisting

of

the

set

of

rules

-LSB-

fRgR

We

have

=-RRB-

if

and

only

if

cham

-LRB-

-RRB-

cham

-LRB-

-RRB-

Implementation

of

the

Broadcast

Mechanism

The

definition

of

the

CHAM

rules

implementing

the

progression

inference

figure

is

first

modified

to

account

for

the

broadcast

markers

Definition

Let

P

Ap

Ap

Ar

ffi

R

be

a

program

formula

we

take

P

to

be

the

following

CHAM

rule

Ap

R

fAp

Arg

Notice

that

the

output

part

and

the

broadcast

atoms

of

the

input

part

of

the

formula

are

coupled

together

within

molecules

of

a

new

kind

of

the

form

R

-LRB-

where

R

is

a

resource

formula

and

a

multiset

of

atoms

-RRB-

so

as

to

express

the

synchronization

condition

captured

by

the

regularity

requirement

of

proof

construction

The

CHAM

rules

implementing

decomposition

and

broadcasting

are

presented

below

using

two

alternative

time

stamp

mechanisms

In

both

cases

the

subsolutions

representing

the

living

agents

are

indexed

with

a

time

stamp

but

in

the

first

case

time

stamps

form

a

totally

ordered

linear

sequence

whereas

the

second

case

makes

use

of

a

partial

order

with

a

branching

structure

Linear

Time

Here

the

global

solution

contains

besides

the

subsolutions

corresponding

to

the

living

agents

a

-LRB-

unique

-RRB-

global

clock

written

t

-LRB-

where

t

is

the

current

global

time

encoded

as

a

non

negative

integer

-RRB-

together

with

blocks

of

messages

of

the

form

t

where

t

is

a

time

stamp

and

a

multiset

of

atoms

These

blocks

represent

broadcast

messages

and

need

to

be

prefixed

with

a

time

stamp

in

order

to

ensure

that

agents

read

them

only

once

For

each

time

stamp

t

lower

than

the

current

global

time

there

is

one

and

only

one

block

of

messages

prefixed

with

t

and

there

are

no

blocks

of

messages

prefixed

with

time

stamps

larger

than

or

equal

to

the

current

global

time

The

idea

is

that

each

agent

indexed

with

a

given

time

stamp

t

has

already

read

all

the

messages

prefixed

with

time

stamps

lower

than

or

equal

to

t

and

still

need

to

read

the

messages

prefixed

with

time

stamps

greater

than

t

The

synchronization

is

achieved

as

follows

ffl

When

an

agent

is

indexed

with

a

time

stamp

t

lower

than

the

current

global

time

and

hence

attached

to

a

unique

block

of

messages

this

block

of

messages

is

read

by

the

agent

i.e.

it

is

added

to

its

current

state

This

is

achieved

by

the

following

CHAM

rule

We

take

broadcast-rule

to

be

the

set

consisting

of

this

single

rule

fj

S

jgt

t

fj

S

-RSB-

jg

-LRB-

t

-RRB-

t

Notice

that

the

time

stamp

of

the

agent

is

incremented

so

that

it

will

never

read

the

block

of

messages

again

On

the

other

hand

the

block

of

messages

itself

is

not

discarded

as

other

agents

may

still

have

to

read

it

ffl

If

an

agent

is

indexed

with

the

current

global

time

then

and

only

then

it

is

allowed

to

broadcast

messages

-LRB-

prefixed

with

the

global

time

which

then

gets

incremented

-RRB-

and

decompose

resource

formulae

messages

blocks

of

global

clock

reader

agents

writer

agent

-LRB-

unique

-RRB-

non

communicating

agents

Figure

The

linear-time

CHAM

at

work

Definition

Let

R

be

a

resource

formula

and

o

be

a

multiset

of

atoms

we

take

R

o

to

be

the

following

CHAM

rule

fj

R

o

S

jgt

t

t

o

fj

S

-RSB-

jg

-LRB-

t

-RRB-

fj

S

-RSB-

n

jg

-LRB-

t

-RRB-

-LRB-

t

-RRB-

where

kRk

f

ng

Notice

that

each

application

of

any

of

these

rules

grabs

the

global

clock

so

that

broadcast

operations

are

here

sequentialized

Furthermore

the

agent

-LRB-

s

-RRB-

resulting

from

the

decomposition

of

R

is

-LRB-

are

-RRB-

indexed

with

the

time

stamp

t

so

that

they

can

not

read

the

messages

in

o

which

are

prefixed

with

t

This

is

indeed

required

since

in

LO

broadcast

messages

are

immediately

discarded

from

the

state

of

the

agent

which

initiates

the

broadcast

before

the

transition

specified

by

R

is

performed

Figure

shows

the

system

of

agents

at

work

At

any

time

each

agent

can

either

be

a

reader

a

writer

or

noncommunicating

There

might

be

several

simultaneous

read

whereas

only

one

write

operation

is

allowed

at

a

time

Of

course

evolutions

inside

the

agents

-LRB-

subsolutions

-RRB-

are

completely

independent

and

may

occur

in

parallel

We

now

map

LO

proofs

into

CHAM

solutions

Definition

Let

be

a

proof

and

t

be

a

time

stamp

We

take

cham

-LRB-

t

-RRB-

to

be

the

CHAM

solution

consisting

of

the

molecule

t

together

with

the

subsolutions

of

the

form

fj

C

jgt

where

C

is

the

context

at

an

open

leaf

of

In

other

words

this

mapping

assumes

that

each

open

leaf

of

the

proof

is

mapped

into

a

subsolution

indexed

with

the

global

time

-LRB-

this

amounts

to

a

global

synchronization

of

all

the

agents

-RRB-

Furthermore

given

a

solution

S

we

take

filter

-LRB-

S

-RRB-

to

be

the

solution

obtained

by

deleting

from

S

all

the

blocks

of

messages

-LRB-

of

the

form

u

-RRB-

We

can

now

formally

state

the

equivalence

between

LO

computations

and

CHAM

computations

as

follows

Theorem

Let

P

be

an

LO

program

let

and

be

two

proofs

based

on

P

and

let

t

be

any

time

stamp

We

consider

on

one

hand

-LRB-

regular

-RRB-

proof

construction

sequences

based

on

P

and

on

the

other

hand

the

CHAM

consisting

of

the

set

of

rules

-LSB-

fR

gR

ff

-LSB-

broadcast-rule

could

be

argued

that

simultaneous

reading

is

not

implemented

by

the

CHAM

described

above

because

the

block

of

messages

in

the

broadcast-rule

is

grabbed

by

the

reading

agent

This

is

in

fact

an

instance

of

a

general

problem

of

the

CHAM

framework

as

mentioned

in

-LSB-

-RSB-

the

CHAM

can

not

distinguish

between

the

situation

where

some

item

is

preserved

by

a

rewrite

rule

-LRB-

as

intended

for

the

block

of

messages

in

the

broadcast-rule

-RRB-

and

the

situation

where

the

same

item

is

cancelled

and

then

generated

again

-LRB-

in

which

case

one

could

argue

that

simultaneous

reading

is

excluded

-RRB-

The

CHARM

framework

-LSB-

-RSB-

offers

a

solution

to

this

problem

We

have

left

a

study

of

using

the

CHARM

framework

instead

of

the

CHAM

framework

for

future

research

We

have

=-RRB-

if

and

only

if

S

s.t.

ae

cham

-LRB-

t

-RRB-

S

cham

-LRB-

-RRB-

filter

-LRB-

S

-RRB-

Branching

Time

Here

the

time

stamps

are

finite

ordered

sequences

of

positive

integers

The

empty

sequence

is

written

ffl

and

the

expression

k

t

denotes

the

sequence

with

first

element

k

-LRB-

an

integer

-RRB-

and

tail

t

-LRB-

a

sequence

itself

-RRB-

The

global

solution

contains

besides

the

subsolutions

corresponding

to

the

living

agents

four

kinds

of

floating

molecules

ffl

Branching

points

of

the

form

tn

-LRB-

where

n

-RRB-

encoding

a

transition

at

time

t

with

n

output

states

-LRB-

creation

by

cloning

-RRB-

ffl

Terminating

points

of

the

form

t

encoding

a

transition

at

time

t

with

no

output

state

-LRB-

termination

-RRB-

ffl

Upward

and

downward

blocks

of

messages

of

the

form

respectively

t

and

t

where

t

is

a

time

stamp

and

is

a

multiset

of

atoms

implementing

message

propagation

In

fact

the

structure

of

the

time

stamps

mimics

that

of

the

proof

tree

each

time

stamp

identifies

a

unique

node

in

the

proof

Notice

that

we

consider

here

the

possibility

of

branching

points

with

more

than

two

branches

since

decomposition

of

resource

formulae

is

executed

at

once

and

may

yield

any

number

of

par-components

Definition

Let

R

be

a

resource

formula

and

o

be

a

multiset

of

atoms

we

take

R

o

to

be

the

following

CHAM

rule

If

Then

R

o

is

the

rule

kRk

fj

R

o

S

jgt

t

o

t

kRk

f

g

fj

R

o

S

jgt

t

o

fj

S

-RSB-

jgt

kRk

f

ng

-LRB-

n

-RRB-

fj

R

o

S

jgt

t

o

tn

fj

S

-RSB-

t

fj

S

-RSB-

n

jgn

t

The

propagation

of

the

broadcast

messages

is

achieved

by

the

set

broadcast-rules

consisting

of

the

following

four

CHAM

rules

j

t

tn

fi

t

gi

n

j

t

tn

t

tn

fi

t

gi

n

tn

t

t

t

t

fj

S

jgt

fj

S

-RSB-

jgt

The

broadcast

mechanism

works

in

the

following

way

The

broadcaster

is

always

a

living

agent

hence

an

open

leaf

of

the

proof

tree

mapped

into

a

subsolution

of

the

CHAM

indexed

with

a

time

stamp

t

identifying

the

position

of

the

leaf

in

the

proof

tree

In

order

to

broadcast

a

block

of

messages

to

the

entire

tree

the

block

is

recursively

propagated

downwards

in

the

tree

using

the

information

of

the

time

stamp

to

all

the

ancestors

of

the

agent

Furthermore

each

time

a

downward

propagation

step

is

performed

at

a

node

upward

propagation

steps

are

triggered

at

that

node

Of

course

upward

propagation

is

not

initiated

on

the

branch

where

the

downward

propagation

takes

place

but

only

on

sibling

branches

This

is

captured

by

the

first

rule

in

broadcast-rules

The

last

three

rules

implement

in

an

obvious

way

upward

propagation

Figure

illustrates

the

propagation

mechanism

Dashed

arrows

represent

downward

propagation

steps

along

the

branch

of

the

ancestors

of

the

agent

requesting

the

broadcast

Plain

arrows

represent

the

upward

propagation

steps

ultimately

reaching

the

whole

tree

triggered

by

these

ancestors

Propagation

and

delivery

of

messages

may

here

take

place

simultaneously

multiple

concurrent

writer

agents

are

allowed

as

well

as

multiple

concurrent

We

now

map

LO

proofs

into

CHAM

solutions

Definition

Let

be

a

proof

We

take

cham

-LRB-

-RRB-

to

be

the

CHAM

solution

consisting

for

each

node

at

position

t

in

of

a

molecule

of

the

form

tn

if

the

node

is

a

branching

node

of

or

a

molecule

of

the

form

t

if

the

node

is

a

termination

node

of

or

a

subsolutions

of

the

form

fj

C

jgt

if

the

node

is

an

open

leaf

labeled

with

the

context

C.

similar

to

those

of

footnote

apply

here

too

R

a

Figure

The

branching-time

CHAM

at

work

Thus

the

whole

structure

of

the

proof

tree

is

mapped

into

the

CHAM

solution

We

can

now

formally

state

the

equivalence

between

LO

computations

and

CHAM

computations

as

follows

Theorem

Let

P

be

an

LO

program

let

and

be

two

proofs

based

on

P

We

consider

on

one

hand

-LRB-

regular

-RRB-

proof

construction

sequences

based

on

P

and

on

the

other

hand

the

CHAM

consisting

of

the

set

of

rules

-LSB-

fR

gR

ff

-LSB-

broadcast-rules

We

have

=-RRB-

if

and

only

if

cham

-LRB-

-RRB-

cham

-LRB-

-RRB-

Discussion

Constructing

Proofs

in

Linear

Logic

As

shown

in

-LSB-

-RSB-

LO

without

the

mechanism

for

broadcast

communication

is

sound

and

complete

with

respect

to

Linear

Logic

-LSB-

-RSB-

in

other

words

-LRB-

i

-RRB-

any

proof

in

LO

can

be

trivially

mapped

into

a

proof

in

Linear

Logic

and

-LRB-

ii

-RRB-

any

proof

in

Linear

Logic

can

be

transformed

by

permutation

of

the

inference

figures

into

a

proof

in

normal

form

-LRB-

called

a

focusing

proof

in

-LSB-

-RSB-

-RRB-

which

can

then

be

represented

by

a

proof

in

As

a

matter

of

fact

LO

by

trading

explicit

exponentials

-LRB-

responsible

in

Linear

Logic

for

marking

reusable

formulae

-RRB-

with

a

spatial

separation

in

sequents

-LRB-

permanent

entities

i.e.

program

formulae

on

the

left

of

the

provability

symbol

and

non-permanent

entities

i.e.

resource

formulae

on

the

right

-RRB-

allows

searching

for

Linear

Logic

proofs

under

a

particularly

efficient

strategy

described

in

-LSB-

-RSB-

-LRB-

see

also

Sec

-RRB-

a

spatial

separation

of

a

similar

kind

has

also

been

adopted

in

some

more

recent

developments

of

the

Linear

Logic

enterprise

-LSB-

-RSB-

On

the

other

hand

the

LO

operational

semantics

is

still

given

in

terms

of

sequent

inference

figures

and

thus

maintains

those

aspects

of

artificial

serialization

of

the

computation

which

are

inherent

to

sequent

proofs

namely

the

fact

that

all

inference

steps

on

a

branch

of

proof

must

appear

in

sequence

although

in

principle

many

of

them

could

be

performed

in

parallel

This

problem

is

tackled

within

Linear

Logic

itself

where

the

concept

of

Proof

Nets

has

been

proposed

as

an

alternative

to

sequent

proofs

in

-LSB-

-RSB-

Proof

Nets

permit

a

highly

parallel

encoding

of

Linear

Logic

proofs

However

they

are

based

on

a

well-formedness

criterion

-LRB-

the

short

trip

condition

-RRB-

which

is

rather

cumbersome

to

handle

in

the

process

of

proof

construction

thus

they

appear

better

suited

for

computational

frameworks

-LRB-

e.g.

Interaction

Nets

-LSB-

-RSB-

-RRB-

where

proofs

are

normalized

-LRB-

perhaps

by

multiple

normalization

steps

taking

place

simultaneously

-RRB-

rather

then

directly

searched

and

constructed

Our

CHAM

encoding

of

LO

computations

retains

some

aspects

of

desequentialization

offered

by

Proof

Nets

but

is

better

suited

to

the

case

of

proof

construction

In

particular

program

formulae

which

are

purely

multiplicative

-LRB-

i.e.

contain

no

occurrence

of

the

additive

connective

-RRB-

can

be

applied

simultaneously

in

the

CHAM

solution

provided

they

do

not

share

a

resource

in

their

fact

in

a

slight

extension

of

LO

described

in

-LSB-

-RSB-

under

the

name

LinLog

p

ffi

r

q

ffi

s

-LRB-

q

s

-RRB-

-LRB-

q

s

-RRB-

-LRB-

q

s

-RRB-

q

s

q

s

r

p

-LRB-

p

r

-RRB-

-LRB-

p

r

-RRB-

-LRB-

p

r

-RRB-

r

p

qp

p

qr

qr

s

p

q

r

sp

s

Figure

A

potentially

simultaneous

multiple

transition

is

represented

as

a

single

proof

net

-LRB-

left

-RRB-

or

as

two

sequent

proofs

-LRB-

right

-RRB-

input

part

Consider

for

example

the

program

of

Fig.

In

the

CHAM

encoding

the

two

formulae

may

apply

simultaneously

to

any

solution

of

the

form

fj

p

q

S

jg

and

lead

to

the

solution

fj

r

s

S

jg

This

is

captured

in

the

proof

net

representation

of

the

same

transition

-LRB-

see

Fig.

-RRB-

where

the

application

of

the

two

are

performed

in

two

distinct

parts

of

the

net

and

hence

are

not

sequentialized

In

the

sequent

proof

system

on

the

other

hand

two

syntactically

distinct

proofs

are

possible

-LRB-

see

Fig.

-RRB-

which

differ

only

inessentially

in

the

-LRB-

arbitrary

-RRB-

sequence

of

application

of

the

formulae

On

the

other

hand

program

formulae

containing

the

additive

must

be

sequentialized

In

our

CHAM

based

true

concurrency

operational

semantics

this

is

realized

by

the

use

of

the

airlock

mechanism

in

the

expression

of

the

rules

for

the

decomposition

of

resource

formulae

containing

the

additive

allowing

the

duplication

of

whole

subsolutions

Similarly

proof

nets

introduce

the

concept

of

box

to

deal

with

this

problem

Clearly

one

could

experiment

also

with

other

frameworks

related

to

CHAMs

to

implement

our

approach

suitable

candidates

are

CHARMs

-LSB-

-RSB-

-LRB-

see

footnote

-RRB-

rewriting

logics

-LSB-

-RSB-

contextual

nets

-LSB-

-RSB-

etc.

The

proof

construction

mechanism

called

instantiation

in

section

can

be

shown

sound

and

complete

with

respect

to

Linear

Logic

as

shown

in

-LSB-

-RSB-

via

the

Phase

Semantics

introduced

in

-LSB-

-RSB-

to

provide

a

modeltheoretic

-LRB-

tarskjian

-RRB-

characterization

of

Linear

Logic

Basically

soundness

and

completeness

rely

on

the

idea

that

generating

contexts

through

proof

construction

amounts

to

enumerating

phases

in

the

phase

space

corresponding

to

the

denotation

of

the

given

program

In

this

way

the

copying

operational

meaning

of

the

connective

is

exploited

not

just

for

duplicating

preexisting

information

but

also

for

propagating

new

information

However

in

order

to

make

this

approach

practical

there

is

need

of

the

broadcast

marker

to

give

the

user

control

on

which

phases

are

effectively

generated

as

a

consequence

this

creates

a

form

of

incompleteness

Still

the

focusing

strategy

for

searching

proofs

can

be

maintained

by

intertwining

it

with

synchronization

mechanisms

to

handle

communication

this

is

directly

reflected

in

the

fact

that

the

CHAM

encodings

for

LO

with

broadcasting

are

simple

extensions

of

the

non-broadcasting

case

where

the

extensions

specifically

concern

the

delivery

and

the

reception

of

information

Broadcasting

We

have

seen

that

the

main

challenges

about

implementing

broadcasting

in

LO

are

in

keeping

track

of

the

dynamic

reconfigurability

of

the

system

-LRB-

creation

and

deletion

of

agents

at

run-time

-RRB-

and

ensuring

soundness

in

the

delivery

of

the

messages

This

kind

of

challenges

is

in

general

to

be

met

in

adding

broadcasting

to

systems

based

on

oneto-one

communication

We

have

proposed

two

solutions

which

both

make

use

of

a

notion

of

time

to

overcome

such

program

formulae

are

represented

by

-LRB-

p

r

-RRB-

and

-LRB-

q

s

-RRB-

in

the

Proof

Net

a

matter

of

fact

a

broadcast

mechanism

has

been

recently

implemented

on

top

of

the

rewriting

logic

programming

language

MAUDE

-LSB-

-RSB-

difficulties

thus

messages

are

time-stamped

and

agents

themselves

have

an

internal

time

through

which

it

can

be

checked

whether

a

given

message

must

or

must

not

be

delivered

to

a

given

agent

The

linear

time

solution

relies

on

the

idea

that

agents

regulate

their

own

clocks

with

respect

to

a

global

clock

through

which

messages

are

also

time-stamped

agents

can

only

read

messages

which

are

not

in

their

present

or

in

their

past

the

internal

clock

of

an

agent

advances

each

time

an

agent

reads

a

message

or

writes

one

in

which

case

the

global

clock

gets

itself

updated

through

the

action

of

writing

The

branching

time

solution

relies

on

the

idea

of

time-stamping

agents

at

the

time

of

their

creation

sibling

agents

all

get

different

stamps

initiating

alternative

futures

evolving

from

a

common

past

messages

are

themselves

time-stamped

with

the

stamp

of

their

creator

and

can

not

be

read

by

any

agent

who

belongs

to

the

same

present

or

the

same

future

of

the

broadcast

message

In

this

case

there

is

no

global

clock

but

only

local

times

starting

from

the

time

of

the

oldest

agent

which

is

stamped

with

ffl

Both

solutions

have

their

advantages

and

their

trade-offs

linear

time

is

very

simple

and

entails

a

straightforward

way

of

implementing

parallel

reading

but

is

completely

sequential

in

the

writing

as

each

writer

agent

must

first

take

possession

of

the

global

clock

and

release

it

after

the

write

is

performed

branching

time

permits

more

parallelism

in

the

writing

as

there

is

no

notion

of

a

unique

global

clock

but

is

more

complicated

from

the

point

of

view

of

reading

as

information

must

flow

through

a

sideway-downward/upward

propagation

scheme

along

the

branches

of

the

proof

tree

We

can

make

conjectures

about

which

machine

architectures

are

more

appropriate

for

each

solution

shared

memory

architectures

appear

particularly

well-suited

for

linear

time

as

the

time

stamps

could

be

seen

as

different

locations

in

the

memory

where

the

messages

are

stored

and

agents

actively

go

and

fetch

them

highly

distributed

message

passing

architectures

fit

well

instead

with

branching

time

as

open

nodes

in

the

proof

-LRB-

agents

-RRB-

can

be

identified

with

nodes

in

a

network

and

their

ancestors

with

communication

points

handling

the

routing

information

The

type

of

broadcasting

in

LO

programs

is

closely

related

to

the

model

studied

in

-LSB-

-RSB-

These

studies

are

concerned

with

the

externally

observable

behavior

of

processes

communicating

via

broadcasting

thus

assuming

broadcasting

as

a

primitive

mode

of

communication

However

it

is

seldom

-LRB-

if

ever

-RRB-

the

case

that

parallel

or

distributed

implementation

platforms

provide

broadcast

communication

as

a

primitive

Instead

one-to-one

asynchronous

message

passing

seems

to

be

predominant

and

we

have

therefore

focused

on

how

to

implement

-LRB-

in

an

abstract

sense

-RRB-

broadcast

communication

when

one-to-one

asynchronous

message

passing

is

assumed

Recently

in

the

-LRB-

theoretical

-RRB-

object

oriented

community

the

asynchronous

one-to-one

message

passing

paradigm

has

been

studied

in

its

own

right

-LSB-

-RSB-

Acknowledgement

Acknowledgements

are

due

to

the

anonymous

Tapsoft

referees

for

their

insightful

comments

Bibliography

-LSB-

-RSB-

J-M

Andreoli

P.

Ciancarini

and

R.

Pareschi

Interaction

abstract

machines

In

G.

Agha

A.

Yonezawa

and

P.

Wegner

editors

Research

Directions

in

Concurrent

Object

Oriented

Programming

MIT

Press

To

appear

-LSB-

-RSB-

J-M

Andreoli

Logic

programming

with

focusing

proofs

in

linear

logic

Journal

of

Logic

and

Computation

-LRB-

-RRB-

-LSB-

-RSB-

J-M

Andreoli

and

R.

Pareschi

Communication

as

fair

distribution

of

knowledge

In

Proc

of

OOP

SLA

Phoenix

Az

U.S.A.

-LSB-

-RSB-

J-M

Andreoli

and

R.

Pareschi

Linear

objects

Logical

processes

with

built-in

inheritance

New

Generation

Computing

-LRB-

-RRB-

-LCB-

-LSB-

-RSB-

J-M

Andreoli

R.

Pareschi

and

M.

Bourgois

Dynamic

programming

as

multi-agent

programming

In

Proc

of

the

OOPSLA

workshop

on

Object-based

concurrent

computing

Lecture

Notes

in

Computer

Science

-LRB-

-RRB-

Gen?eve

Switzerland

Springer

Verlag

-LSB-

-RSB-

M.

Bourgois

J-M

Andreoli

and

R.

Pareschi

Extending

objects

with

rules

composition

and

concurrency

the

lo

experience

In

Proc

of

the

OOPSLA

workshop

on

Object-Oriented

Programming

Languages

The

Next

Generation

Vancouver

Canada

-LSB-

-RSB-

G.

Berry

and

G.

Boudol

The

chemical

abstract

machine

In

Proc

of

the

ACM

Symposium

on

Principles

of

Programming

Languages

San

Francisco

Ca

U.S.A.

-LSB-

-RSB-

J-P

Ban

atre

A.

Coutant

and

D.

Le

Metayer

A

parallel

machine

for

multiset

transformation

and

its

programming

style

Future

Generation

Computer

Systems

-LRB-

-RRB-

-LCB-

-LSB-

-RSB-

A.

Corradini

U.

Montanari

and

F.

Rossi

Concurrency

and

hiding

in

an

abstract

rewrite

machine

In

Proc

of

the

International

Conference

on

Generation

Computer

Systems

Tokyo

Japan

-LSB-

-RSB-

J-Y

Girard

Linear

logic

Theoretical

Computer

Science

-LCB-

-LSB-

-RSB-

J-Y

Girard

A

new

constructive

logic

Classical

logic

Mathematical

Structures

in

Computer

Science

-LRB-

-RRB-

-LSB-

-RSB-

J-Y

Girard

On

the

unity

of

logic

Preprint

Universit?e

de

Paris

-LSB-

-RSB-

K.

Honda

and

M.

Tokoro

An

object

calculus

for

asynchronous

communication

In

Proc

of

ECOOP

Gen?eve

Switzerland

-LSB-

-RSB-

Y.

Lafont

Interaction

nets

In

Proc

of

ACM

Symposium

on

Principles

of

Programming

Languages

San

Francisco

Ca

U.S.A.

-LSB-

-RSB-

J.

Meseguer

Conditional

rewriting

logic

as

a

unified

model

of

concurrency

Theoretical

Computer

Science

-LCB-

-LSB-

-RSB-

J.

Meseguer

A

logical

theory

of

concurrent

objects

and

its

realization

in

the

MAUDE

language

In

G.

Agha

A.

Yonezawa

and

P.

Wegner

editors

Research

Directions

in

Concurrent

Object

Oriented

Programming

MIT

Press

To

appear

-LSB-

-RSB-

U.

Montanari

and

F.

Rossi

Contextual

nets

Technical

report

Universit?a

di

Pisa

Pisa

Italy

-LSB-

-RSB-

O.

Nierstrasz

Towards

an

object

calculus

In

Proc

of

the

OOPSLA

workshop

on

Object-based

concurrent

computing

Lecture

Notes

in

Computer

Science

-LRB-

-RRB-

Gen?eve

Switzerland

Springer

Verlag

-LSB-

-RSB-

K.V.S.

Prasad

A

calculus

of

broadcasting

systems

In

Proc

of

the

Colloquium

on

Trees

in

Algebra

and

Programming

-LSB-

-RSB-

V.A.

Saraswat

Concurrent

Constraint

Programming

Languages

PhD

thesis

Carnegie-Mellon

University

Pittsburg

Pa

U.S.A.

Other

Reports

Available

from

ECRC

-LSB-

ECRC

-LCB-

TR

-LCB-

-RSB-

Mireille

Ducasse

and

Anna-Maria

Emde

Opium

User

Manual

A

High-level

Debugging

Environment

for

Prolog

-LSB-

ECRC

-LCB-

TR

-LCB-

-RSB-

E.

Yardeni

T.

Fruhwirth

and

E.

Shapiro

Polymorphically

Typed

Logic

Programs

-LSB-

ECRC

-LCB-

TR

-LCB-

-RSB-

U.

Baron

S.

Bescos

and

S.

Delgado

The

ElipSys

Logic

Programming

Language

-LSB-

ECRC

-LCB-

TR

-LCB-

-RSB-

Sergio

Delgado

Michel

Dorochevsky

and

Kees

Schuerman

A

Shared

Environment

Parallel

Logic

Programming

System

On

Distributed

Memory

Architectures

-LSB-

ECRC

-LCB-

TR

-LCB-

-RSB-

Andre

Veron

Jiyang

Xu

and

Kees

Schuerman

Virtual

Memory

Support

for

OR-Parallel

Logic

Programming

Systems

-LSB-

ECRC

-LCB-

TR

-LCB-

-RSB-

Michel

Dorochevsky

Garbage

Collection

in

the

OR-Parallel

Logic

Programming

-LSB-

ECRC

-LCB-

TR

-LCB-

-RSB-

Alan

Sexton

KCM

Kernel

Implementation

Report

-LSB-

ECRC

-LCB-

TR

-LCB-

-RSB-

Michel

Dorochevsky

Key

Features

of

a

Prolog

Module

System

-LSB-

ECRC

-LCB-

TR

-LCB-

-RSB-

Michel

Dorochevsky

Kees

Schuerman

and

Andre

Veron

ElipSys

An

Integrated

Platform

for

Building

Large

Decision

Support

Systems

-LSB-

ECRC

-LCB-

TR

-LCB-

-RSB-

Jiyang

Xu

and

Andre

Veron

Types

and

Constraints

in

the

Parallel

Logic

Programming

System

ElipSys

-LSB-

ECRC

-LCB-

TR

-LCB-

-RSB-

Olivier

Thibault

Design

and

Evaluation

of

a

Symbolic

Processor

-LSB-

ECRC

-LCB-

TR

-LCB-

-RSB-

Michel

Dorochevsky

Jacques

Noy?e

and

Olivier

Thibault

Has

Dedicated

Hardware

for

Prolog

a

Future

-LSB-

ECRC

-LCB-

-LCB-

-RSB-

Norbert

Eisinger

and

Hans

Jurgen

Ohlbach

Deduction

Systems

Based

on

Resolution

-LSB-

ECRC

-LCB-

-LCB-

-RSB-

Michel

Kuntz

The

Gist

of

GIUKU

Graphical

Interactive

Intelligent

Utilities

for

Knowledgeable

Users

of

Data

Base

Systems

-LSB-

ECRC

-LCB-

-LCB-

-RSB-

Michel

Kuntz

An

Introduction

to

GIUKU

Graphical

Interactive

Intelligent

Utilities

for

Knowledgeable

Users

of

Data

Base

Systems

-LSB-

ECRC

-LCB-

-LCB-

-RSB-

Michel

Kuntz

Enhanced

Graphical

Browsing

Techniques

for

Collections

of

Structured

Data

-LSB-

ECRC

-LCB-

-LCB-

-RSB-

Michel

Kuntz

A

Graphical

Syntax

Facility

for

Knowledge

Base

Languages

-LSB-

ECRC

-LCB-

-LCB-

-RSB-

Michel

Kuntz

A

Versatile

Browser-Editor

for

Relations

-LSB-

ECRC

-LCB-

-LCB-

-RSB-

Norbert

Eisinger

Nabiel

Elshiewy

and

Remo

Pareschi

Distributed

Artificial

Intelligence

An

Overview

-LSB-

ECRC

-LCB-

-LCB-

-RSB-

Norbert

Eisinger

An

Approach

to

Multi-Agent

Problem-Solving

-LSB-

ECRC

-LCB-

-LCB-

-RSB-

Klaus

H.

Ahlers

Michael

Fendt

Marc

Herrmann

Isabelle

Hounieu

and

Philippe

Marchal

TUBE

Implementor

's

Manual

-LSB-

ECRC

-LCB-

-LCB-

-RSB-

Klaus

H.

Ahlers

Michael

Fendt

Marc

Herrmann

Isabelle

Hounieu

and

Philippe

Marchal

TUBE

Programmer

's

Manual

-LSB-

ECRC

-LCB-

-LCB-

-RSB-

Michael

Dahmen

A

Debugger

for

Constraints

in

Prolog

-LSB-

ECRC

-LCB-

-LCB-

-RSB-

Jean-Marc

Andreoli

and

Remo

Pareschi

Communication

as

Fair

Distribution

of

Knowledge

-LSB-

ECRC

-LCB-

-LCB-

-RSB-

Jean-Marc

Andreoli

Remo

Pareschi

and

Marc

Bourgois

Dynamic

Programming

as

Multiagent

Programming

-LSB-

ECRC

-LCB-

-LCB-

-RSB-

Volker

Kuchenhoff

On

the

Efficient

Computation

of

the

Difference

Between

Consecutive

Database

States

-LSB-

ECRC

-LCB-

-LCB-

-RSB-

Sylvie

Bescos

and

Michael

Ratcliffe

Secondary

Structure

Prediction

of

rRNA

Molecules

Using

ElipSys

-LSB-

ECRC

-LCB-

-LCB-

-RSB-

Michael

Dahmen

Abstract

Debugging

of

Coroutines

and

Constraints

in

Prolog

-LSB-

ECRC

-LCB-

-LCB-

-RSB-

Thierry

Le

Provost

and

Mark

Wallace

Constraint

Satisfaction

Over

the

CLP

Scheme

-LSB-

ECRC

-LCB-

-LCB-

-RSB-

G?erard

Comyn

M.

Jarke

and

Suryanarayana

M.

Sripada

Proceedings

of

the

Compulog

Net

meeting

on

Knowledge

Bases

-LRB-

CNKBS

-RRB-

-LSB-

ECRC

-LCB-

-LCB-

-RSB-

Jesper

Larsson

Traeff

and

Steven

David

Prestwich

Meta-programming

for

reordering

Literals

in

Deductive

Databases

-LSB-

ECRC

-LCB-

-LCB-

-RSB-

Beat

Wuthrich

Update

Realizations

Drawn

from

Knowledge

Base

Schemas

and

Executed

by

Dialog

-LSB-

ECRC

-LCB-

-LCB-

-RSB-

Lone

Leth

A

New

Direction

in

Functions

as

Processes

-LSB-

ECRC

-LCB-

-LCB-

-RSB-

Steven

David

Prestwich

The

PADDY

Partial

Deduction

System

-LSB-

ECRC

-LCB-

-LCB-

-RSB-

Andrei

Voronkov

Extracting

Higher

Order

Functions

from

First

Order

Proofs

-LSB-

ECRC

-LCB-

-LCB-

-RSB-

Andrei

Voronkov

On

Computability

by

Logic

Programs

-LSB-

ECRC

-LCB-

-LCB-

-RSB-

Beat

Wuthrich

Towards

Probabilistic

Knowledge

Bases

-LSB-

ECRC

-LCB-

-LCB-

-RSB-

Petra

Bayer

Update

Propagation

for

Integrity

Checking

Materialized

View

Maintenance

and

Production

Rule

Triggering

-LSB-

ECRC

-LCB-

-LCB-

-RSB-

Mireille

Ducass?e

Abstract

views

of

Prolog

executions

in

Opium

-LSB-

ECRC

-LCB-

-LCB-

-RSB-

Alexandre

Lefebvre

Towards

an

Efficient

Evaluation

of

Recursive

Aggregates

in

Deductive

Databases

-LSB-

ECRC

-LCB-

-LCB-

-RSB-

Udo

W.

Lipeck

and

Rainer

Manthey

-LRB-

Hrsg

-RRB-

Kurzfassungen

des

GI-Workshops

Grundlagen

von

Datenbanken

Barsinghausen

-LSB-

ECRC

-LCB-

-LCB-

-RSB-

Lone

Leth

and

Bent

Thomsen

Some

Facile

Chemistry

-LSB-

ECRC

-LCB-

-LCB-

-RSB-

Jacques

Noy?e

-LRB-

Ed

-RRB-

Proceedings

of

the

International

KCM

User

Group

Meeting

Munich

and

October

-LSB-

ECRC

-LCB-

-LCB-

-RSB-

Frederick

Knabe

A

Distributed

Protocol

for

Channel-Based

Communication

with

Choice

-LSB-

ECRC

-LCB-

-RSB-

Benoit

Baurens

Petra

Bayer

Luis

Hermosilla

and

Andrea

Sikeler

Publication

Management

A

Requirements

Analysis

-LSB-

ECRC

-LCB-

-RSB-

Thom

Fruhwirth

Constraint

Simplification

Rules

-LSB-

ECRC

-LCB-

-RSB-

Mark

Wallace

Compiling

Integrity

Checking

into

Update

Procedures

-LSB-

ECRC

-LCB-

-RSB-

Petra

Bayer

Data

and

Knowledge

for

Medical

Applications

A

Case

Study

-LSB-

ECRC

-LCB-

-RSB-

Michel

Dorochevsky

and

Andr?e

V?eron

Binding

Techniques

and

Garbage

Collection

for

OR-Parallel

CLP

Systems

-LSB-

ECRC

-LCB-

-RSB-

Shan-Wen

Yan

Efficiently

Estimating

Relative

Grain

Size

for

Logic

Programs

on

Basis

of

Abstract

Interpretation

-LSB-

ECRC

-LCB-

-RSB-

Jean-Marc

Andreoli

Paolo

Ciancarini

and

Remo

Pareschi

Interaction

Abstract

Machines

-LSB-

ECRC

-LCB-

-RSB-

Jean-Marc

Andreoli

and

Remo

Pareschi

Associative

Communication

and

its

Optimization

via

Abstract

Interpretation

-LSB-

ECRC

-LCB-

-RSB-

Jean-Marc

Andreoli

Lone

Leth

Remo

Pareschi

and

Bent

Thomsen

On

the

Chemistry

of

Broadcasting

-LSB-

ECRC

-LCB-

-RSB-

Marc

Bourgois

Jean-Marc

Andreoli

and

Remo

Pareschi

Extending

Objects

with

Rules

Composition

and

Concurrency

the

LO

Experience

-LSB-

ECRC

-LCB-

-RSB-

Benoit

Dageville

and

Kam-Fai

Wong

SIM

A

C-based

SIMulation

Package

-LSB-

ECRC

-LCB-

-RSB-

Beat

Wuthrich

On

the

Efficient

Distribution-free

Learning

of

Rule

Uncertainties

and

their

Integration

into

Probabilistic

Knowledge

Bases

-LSB-

ECRC

-LCB-

-RSB-

Andrei

Voronkov

Logic

Programming

with

Bounded

Quantifiers

-LSB-

ECRC

-LCB-

-RSB-

Eric

Monfroy

Grobner

Bases

Strategies

and

Applications

-LSB-

ECRC

-LCB-

-RSB-

Eric

Monfroy

Specification

of

Geometrical

Constraints

-LSB-

ECRC

-LCB-

-RSB-

Bent

Thomsen

Lone

Leth

and

Alessandro

Giacalone

Some

Issues

in

the

Semantics

of

Facile

Distributed

Programming

-LSB-

ECRC

-LCB-

-RSB-

Mireille

Ducass?e

An

Extendable

Trace

Analyser

to

Support

Automated

Debugging

-LSB-

ECRC

-LCB-

-RSB-

Jorge

Bocca

and

Luis

Hermosilla

A

Preliminary

Study

of

the

Performance

of

MegaLog

-LSB-

ECRC

-LCB-

-LCB-

-RSB-

Benoit

Dageville

and

Kam-Fai

Wong

Supporting

Thousands

of

Threads

Using

a

Hybrid

Stack

Sharing

Scheme

-LSB-

ECRC

-LCB-

-LCB-

-RSB-

Steven

Prestwich

ElipSys

Programming

Tutorial

-LSB-

ECRC

-LCB-

-LCB-

-RSB-

Beat

Wuthrich

Learning

Probabilistic

Rules

-LSB-

ECRC

-LCB-

-LCB-

-RSB-

Eric

Monfroy

A

Survey

of

Non-Linear

Solvers

-LSB-

ECRC

-LCB-

-LCB-

-RSB-

Thom

Fruhwirth

Alexander

Herold

Volker

Kuchenhoff

Thierry

Le

Provost

Pierre

Lim

Eric

Monfroy

and

Mark

Wallace

Constraint

Logic

Programming

An

Informal

Introduction

broadcasting
linear logic
true concurrency

chemical abstract machines
concurrent rewriting