Download paper here. Download implementation here.

Summary

Their example...

aspect Equality perobjects(Bit, Bit) {
        Bit left, right;
        boolean busy = false;   //indicates if the
                                //relation is active

        Equality(Bit l, Bit r) {
                associate(l, r); //establishes
                left = l; right = r; //association
        }

        after(Bit l) : call(void Bit.set()) && target(l) && associated(l,*){
                propagateSet(right); //when left is called,
        } //call set on right

        after(Bit r) : call(void Bit.set()) && target(r) && associated(*,r){
                propagateSet(left); //when right is called,
        } //call set on left

        void propagateSet(Bit opp) {
                if (!busy) { //call set on opp
                        busy = true; //unless it already has
                        opp.set(); //propagated
                        busy = false;
                }
        }

        // advice decls, for clear method go here
}

In our syntax...

Note that the aspect parameters are labeled (left/right). Hence, the "associated" pointcut is unnecessary.

relational aspect Equality(Bit left, Bit right) {
        boolean busy = false;   //indicates if the
                                //relation is active

        after() : call(void Bit.set()) && target(left){
                propagateSet(right); //when left is called,
        } //call set on right

        after() : call(void Bit.set()) && target(right){
                propagateSet(left); //when right is called,
        } //call set on left

        void propagateSet(Bit opp) {
                if (!busy) { //call set on opp
                        busy = true; //unless it already has
                        opp.set(); //propagated
                        busy = false;
                }
        }

        // advice decls, for clear method go here
}

Possible translation:

aspect Equality {

        boolean busy = false;   //indicates if the
                                //relation is active

        private final Bit left, private final Bit right; //just a copy for easier type checking

        public static Equality associate(Bit l, Bit r) {
                return new Equality(); // to be generated in the backend
        }

        public static void release(Bit l, Bit r) {
        }

        (static) tracematch(Bit left, Bit right, Equality state) {

                sym associate after returning(state):
                        call(Equality.new(..)) && args(left,right);

                sym release before:
                        call(Equality.release(..)) && args(left,right);

                sym action after:
                        call(void Bit.set()) && target(left);

                associate+ action+ {
                        state.propagateSet(right);  //"this" reference replaced by "state"
                }

        }


        (static) tracematch(Bit left, Bit right, Equality state) {

                sym associate after returning(state):
                        call(Equality.associate(..)) && args(left,right);

                sym release before:
                        call(Equality.release(..)) && args(left,right);

                sym action after:
                        call(void Bit.set()) && target(right);

                associate+ action+ {
                        state.propagateSet(left);  //"this" reference replaced by "state"
                }

        }

        void propagateSet(Bit opp) {
                if (!busy) { //call set on opp
                        busy = true; //unless it already has
                        opp.set(); //propagated
                        busy = false;
                }
        }


        // advice decls, for clear method go here
}