module accessibility
  depends on entity_event_and_action

  sort declarations
    make_accessible :: actions
    make_inaccessible :: actions

  function declarations
    fluents 
      basic
        accessible_to : entity * thing -> booleans
        is_accessible : entity -> booleans

      defined
        inaccessible_to : entity * thing -> booleans
        is_inaccessible : entity -> booleans

  axioms
    inaccessible_to(X, Y) if -accessible_to(X, Y).
    is_inaccessible(X) if -is_accessible(X).

    accessible_to(X, Y) if is_accessible(X).
    -accessible_to(X, Y) if -is_accessible(X).

    false if instance(X, make_accessible),
             -defined_object(X).

    false if instance(X, make_inaccessible),
             -defined_object(X).

    occurs(X) causes accessible_to(O, B) if instance(X, make_accessible),
                                            object(X, O),
                                            base(X, B).

    occurs(X) causes is_accessible(O) if instance(X, make_accessible),
                                         object(X, O),
                                         -defined_base(X).

    occurs(X) causes -accessible_to(O, B) if instance(X, make_inaccessible),
                                             object(X, O),
                                             base(X, B).

    occurs(X) causes -is_accessible(O) if instance(X, make_inaccessible),
                                          object(X, O),
                                          -defined_base(X).

    impossible occurs(X) if instance(X, make_accessible),
                            object(X, O),
                            base(X, B),
                            accessible(O, B).

    impossible occurs(X) if instance(X, make_accessible),
                            object(X, O),
                            -defined_base(X),
                            is_accessible(O).

    impossible occurs(X) if instance(X, make_inaccessible),
                            object(X, O),
                            base(X, B),
                            -accessible(O, B).

    impossible occurs(X) if instance(X, make_inaccessible),
                            object(X, O),
                            -defined_base(X),
                            -is_accessible(O).