# Accelerating the Convergence of Coupled Cluster Calculations of the
Homogeneous Electron Gas Using Bayesian Ridge Regression

Julie Butler  Department of Biochemistry, Chemistry, and Physics, University
of Mount Union, Alliance, Ohio 46601, USA  Department of Physics and Astronomy
and Facility for Rare Isotope Beams and National Superconducting Cyclotron
Laboratory, Michigan State University, East Lansing, MI 48824, USA  Morten
Hjorth-Jensen  Department of Physics and Astronomy and Facility for Rare
Isotope Beams and National Superconducting Cyclotron Laboratory, Michigan
State University, East Lansing, MI 48824, USA  Department of Physics and
Center for Computing in Science Education, University of Oslo, N-0316 Oslo,
Norway  Justin G. Lietz  National Center for Computational Sciences, Oak Ridge
National Laboratory, Oak Ridge, TN 37831, USA

###### Abstract

The homogeneous electron gas is a system which has many applications in
chemistry and physics. However, its infinite nature makes studies at the many-
body level complicated due to long computational run times. Because it is size
extensive, coupled cluster theory is capable of studying the homogeneous
electron gas, but it still poses a large computational challenge as the time
needed for precise calculations increases in a polynomial manner with the
number of particles and single-particle states. Consequently, achieving
convergence in energy calculations becomes challenging, if not prohibited, due
to long computational run times and high computational resource requirements.
This paper develops the sequential regression extrapolation (SRE) to predict
the coupled cluster energies of the homogeneous electron gas in the complete
basis limit using Bayesian ridge regression to make predictions from
calculations at truncated basis sizes. Using the SRE method we were able to
predict the coupled cluster doubles energies for the electron gas across a
variety of values of N and $r_{s}$, for a total of 70 predictions, with an
average error of 4.28x10-4 Hartrees while saving 88.9 hours of computational
time. The SRE method can accurately extrapolate electron gas energies to the
complete basis limit, saving both computational time and resources.
Additionally, the SRE is a general method that can be applied to a variety of
systems, many-body methods, and extrapolations.

## Introduction

A proper understanding of the role of correlations beyond a mean-field
description is of great importance for quantum many-particle theories. For all
possible quantum-mechanical systems, either finite ones or infinite systems
like the homogeneous electron gas in two or three dimensions or nuclear or
neutron star matter, the concept of an independent particle motion continues
to play a fundamental role in studies of many-particle systems. Deviations
from such an independent particle, or mean-field, picture have normally been
interpreted as a possible measure of correlations. The latter are expected to
reveal important features of both the structure and the dynamics of a many-
particle system beyond a mean-field approximation.

The homogeneous electron gas (HEG) is an infinite matter system composed of
electrons with a uniform positive background charge Shepherd  _et al._
(2012a); Shepherd (2016); Lietz  _et al._ (2017); Bishop (1991); Bishop and
Lührmann (1982, 1981); Neufeld and Thom (2017). The ions are stationary and
the system as a whole is neutral. It is widely studied in chemistry and
physics because it is a reasonable model for many systems of interest. For
instance, the three-dimensional HEG is fundamental in density functional
theory’s local-density approximation and can represent electrons in alkali
metals and doped semiconductors. Two-dimensional electron fluids are observed
on metal and liquid-helium surfaces, as well as at metal-oxide-semiconductor
interfaces. The HEG serves also as a foundation for developing many-body
frameworks applicable to more complex systems such as infinite nuclear matter.

The HEG in two and three dimensions represent also some of the few examples of
systems of many interacting particles that allow for analytical solutions of
the mean-field Hartree-Fock equations. Irrespective of this simplicity, the
HEG in both two and three-dimensions, has eluded a proper description of
correlations in terms of various first principle methods, except perhaps for
quantum Monte Carlo methods. In particular, the diffusion Monte Carlo
calculations of Ceperley et al. Ceperley and Alder (1980); Tanatar and
Ceperley (1989), are presently still considered the best possible benchmarks
for two- and three-dimensional electron gas. In Ref. Ceperley and Alder
(1980), the fermion sign problem is handled using a released-node
approximation. Similar accuracy has been obtained in more recent calculations
using the backflow-correlation technique Kwon  _et al._ (1998), which is used
to relax the simpler fixed-node approximation. Recently, variational Monte
Carlo approaches using deep neural networks Pescia  _et al._ (2023); Cassella
_et al._ (2023) result in ground state energies for a variety of densities
which show minima below the best diffusion Monte Carlo results. In addition to
various Monte Carlo approaches, the electron gas has been studied using a
large number of different approaches and many-body methods. Amongst such many-
body methods, we have coupled cluster (CC) theory. Coupled cluster theory is a
powerful method used in nuclear physics, condensed matter physics, quantum
chemistry, and other fields to predict ground state energy accurately Shavitt
and Bartlett (2009a); Binder  _et al._ (2013); Bishop and Kümmel (1987);
Vargas-Hernández  _et al._ (2018); Neufcourt  _et al._ (2018); Kümmel  _et
al._ (1978); Bartlett and Musiał (2007); Čižek and Paldus (1971); Čížek
(2004). It organizes and includes interactions beyond the mean-field in a
systematic manner, making it a popular choice for many-body calculations.
Although CC truncates interactions, making it less accurate than full
configuration interaction theory, it offers faster computational run times.
Compared to other many-body methods like many-body perturbation theory, CC
achieves significantly higher accuracy, making it an attractive compromise
between speed and accuracy.

Singal and Das Singal and Das (1973) were the first to study the electron gas
using a CC approach. The approximation they used is similar to the Brueckner
Hartree-Fock method Haftel and Tabakin (1970), and did not properly include
particle-hole ring diagrams. Later, Freeman performed CC calculations Freeman
(1977) in which only ring diagrams and their exchange parts were retained in a
CC doubles approximation. The results of both Singal and Das Singal and Das
(1973) and Freeman Freeman (1977) compared well with dielectric-function
approaches. These calculations of the three-dimensional electron gas were
improved by Bishop and Lührmann Bishop and L”uhrmann (1978, 1982). Bishop and
Lührmann derived a CC SUB2 approximation (also called CC doubles (CCD) Shavitt
and Bartlett (2009b)) for the electron gas, extended with some ladder
contributions from higher-order amplitudes. As the authors described in Ref.
Bishop and L”uhrmann (1978), the CCD approximation contains many more
diagrammatic classes than partial-summation techniques derived from
perturbation theory. The CCD approximation takes account of particle-particle
and hole-hole ladders, particle-hole ring diagrams including exchange terms,
and many other diagrams to infinite order in perturbation theory. Recently,
Shepherd _et al._ Shepherd  _et al._ (2012b); Shepherd and Grüneis (2013);
Shepherd  _et al._ (2014a, b) have taken up again the CC effort for the three-
dimensional electron gas. The CC calculations for the electron gas from the
1970s and 1980s were all done at the thermodynamic limit Singal and Das
(1973); Freeman (1977); Bishop and L”uhrmann (1978, 1982). Unfortunately,
singularities related to the Coulomb two-body interaction may complicate
numerical calculations at the thermodynamic limit. Shepherd _et al._
approximate the electron gas using finite cubic boxes Shepherd  _et al._
(2012b); Shepherd and Grüneis (2013); Shepherd  _et al._ (2014a, b). However,
to make CC calculations feasible in the HEG using finite lattices, truncations
are necessary, thereby introducing errors that diminish accuracy. The
truncation in the basis of single-particle states ($M$) leads to basis
incompleteness errors while truncating the number of electrons ($N$) and the
HEG volume ($\Omega$) introduces finite-size errors. One way to reduce these
errors is by performing CC calculations at high values of $M$ and $N$, such
that the calculations have converged. However, this approach demands extensive
computational resources and time. Since basis incompleteness errors and finite
size errors arise from different truncations, they can be addressed
independently Shepherd  _et al._ (2012a); Shepherd (2016). This work focuses
on removing the basis truncation errors from CC doubles calculations of the
HEG using machine learning.

Machine learning (ML), a field at the intersection of data science and
artificial intelligence, has become increasingly prominent as a tool in
physics and chemistry, which can be applied to a wide variety of problems
Murphy (2013); Géron (2017); Mehta  _et al._ (2019); Negoita  _et al._ (2019);
Jiang  _et al._ (2019); Akkoyun  _et al._ (2013); Utama  _et al._ (2016);
Carleo and Troyer (2017); Boehnlein  _et al._ (2022); Ismail and Gezerlis
(2021); Meredig  _et al._ (2018); Jinnouchi  _et al._ (2017); Knöll  _et al._
(2023). This paper aims to develop an ML-based extrapolation method, called
sequential regression extrapolation (SRE) that uses Bayesian ridge regression.
This method extrapolates CC correlation energies calculated at smaller M to
eliminate basis incompleteness errors. Despite the challenges of applying ML
for extrapolation and limited data sets due to computational constraints, the
proposed approach is expected to significantly reduce the run time of fully
converged CC calculations without sacrificing accuracy.

Previous studies have explored ML techniques in CC calculations, including
predicting CC correlation energies from many-body perturbation theory
amplitudes and using neural networks to eliminate finite-size errors in
nuclear CC calculations Jiang  _et al._ (2019); Margraf and Reuter (2018);
Smith  _et al._ (2019). Traditional extrapolation methods have also been
employed to extrapolate converged CC correlation energies for the HEG and
other many-body systems, to eliminate basis incompleteness and finite-sized
errors Shepherd  _et al._ (2012a); Shepherd (2016); Mihm  _et al._ (2021a,
2023, b); Liao and Grüneis (2016); Mihm  _et al._ (2021c); Köhn and Tew
(2010). However, this paper distinguishes itself by applying an ML-based
extrapolation technique, SRE, to predict CC correlation energies using
Bayesian ridge regression, specifically targeting the HEG.

The paper’s structure begins with a theoretical explanation of the homogeneous
electron gas, many-body perturbation theory, and coupled cluster theory. It
then introduces the development of the SRE algorithm and its application to
accelerate the convergence of CC correlation energies concerning the number of
single-particle states and electrons. Finally, the results and discussion
section presents the time savings achieved with the SRE algorithm, and the
accuracy of extrapolation in terms of single-particle states.

## Background

Coupled cluster theory (CC) is a highly effective many-body method that
approximates the solution to the Schrödinger equation to a high degree of
accuracy Bartlett and Musiał (2007); Čižek and Paldus (1971); Čížek (2004);
Coester and Kümmel (1960); Coester (1958). Coupled cluster theory is widely
used in quantum chemistry to accurately predict the ground state energy of
complex systems Kümmel  _et al._ (1978). By systematically incorporating
interactions beyond the mean field, CC offers a robust framework for many-body
calculations. CC outperforms other many-body methods like many-body
perturbation theory in terms of accuracy, making it an appealing choice that
strikes a balance between speed and precision. However, even though CC is size
extensive (an important quality for its application to infinite matter
systems) the polynomial time scaling, with respect to the size of the system,
can make CC run times prohibitively long for large systems Urban  _et al._
(1985).

Coupled cluster theory starts with the exponential ansatz that states a many-
body wavefunction can be created by applying an exponential cluster operator
to the Fermi vacuum state, shown in Eq. (1). The cluster operator consists of
N excitation operators, where N is the number of electrons or particles in the
system. However, for practical calculations, the number of terms in the
cluster operator is often truncated to a set level Taube and Bartlett (2008);
Kucharski and Bartlett (1998); Bartlett  _et al._ (1990); Raghavachari  _et
al._ (1989); He  _et al._ (2001); Urban  _et al._ (1985). In this work, the
focus is on the doubles level (CCD), which approximates the cluster operator
with just the two-particle two-hole excitation operator (Eq. (2)).

$|\Psi\rangle=e^{\hat{T}}|\Phi_{0}\rangle,$ (1)

and

$\hat{T}=\sum_{i=1}^{N}\hat{T}_{i}\longrightarrow\hat{T}_{CCD}=\hat{T}_{2}.$
(2)

A CCD calculation has an expected run time of $O(M^{6})$, where $M$ is the
number of single-particle states in the calculation Urban  _et al._ (1985).
Furthermore, it is important to note that a CCD calculation contains all
correlations needed to compute the many-body perturbation theory to the
second-order (MBPT2) results, so MBPT2 energies can be computed from a CCD
calculation with little additional computational costs. The MBPT2 energy is
less accurate than the CCD energy but it has a significantly smaller run time
while still incorporating some aspects of the interactions beyond the mean
field.

The energy calculated through CC, denoted as ECC, is typically presented as
the correlation energy, which is the CC energy minus the reference energy
obtained from Hartree-Fock theory

$E_{CC}=\langle\Phi_{0}|e^{-\hat{T}}\hat{H}e^{\hat{T}}|\Phi_{0}\rangle=E_{REF}+\Delta
E_{CC}.$ (3)

MBPT2 energies can be found, as shown in Eq. (4), are are often presented as
correlation energies as well.

$E_{MBPT}=E_{REF}+\frac{1}{4}\sum_{ijab}\frac{\langle
ij|\hat{v}_{2}|ab\rangle\langle
ab|\hat{v}_{2}|ij\rangle}{(\epsilon_{i}+\epsilon_{j})-(\epsilon_{a}+\epsilon_{b})}$
(4)

As mentioned above, the HEG is an infinite matter system consisting of
electrons with a uniform positive background charge, and studies are important
in diverse areas of chemistry and physics Shepherd  _et al._ (2012a); Shepherd
(2016); Bishop and Lührmann (1978, 1982, 1981). In the context of the three-
dimensional HEG, it plays a fundamental role in the local-density
approximation of density functional theory. Additionally, the HEG can
effectively model electrons in alkali metals and doped semiconductors and
provides a foundation for developing many-body frameworks applicable to more
intricate infinite matter systems, including infinite nuclear matter Shepherd
_et al._ (2012a); Shepherd (2016); Lietz  _et al._ (2017); Bishop and Lührmann
(1982, 1981).

The HEG Hamiltonian for $N$ electrons includes kinetic energy, electron-
electron interactions, and the Madelung term. The last two terms make up the
Ewald interaction, which separates short-range and long-range components of
the Coulomb interaction Shepherd  _et al._ (2012a); Shepherd (2016). The
Hamiltonian is defined as:

$\hat{H}=-\frac{1}{2}\sum_{\alpha}\nabla^{2}_{\alpha}+\frac{1}{2}\sum_{\alpha\neq\beta}\hat{v}_{\alpha\beta}+\frac{1}{2}Nv_{M},$
(5)

where $\alpha$ and $\beta$ are electron indices. The two-electron operator,
$\hat{v}_{\alpha\beta}$, accounts for the contributions from the electron-
electron interactions.

The one-electron basis set consists of plane waves, which are given by the
wave function:

$\psi_{j}(\vec{r},\sigma)=\sqrt{\frac{1}{\Omega}}\ e^{i\vec{k}j\cdot\vec{r}}\
\delta{\sigma_{j},\sigma},$ (6)

where $\Omega$ is the volume of the HEG, $\vec{k}_{j}$ is the wave vector, and
$\delta{\sigma_{j},\sigma}$ is the Kronecker delta Lietz  _et al._ (2017);
March  _et al._ (1995). The density of the HEG is often described by the
Wigner-Seitz radius, $r_{s}$, which is related to the size of the sphere that
contains the electron gas. In this work, we are interested in high-density HEG
systems and will restrict $r_{s}<1.0$ Carr and Maradudin (1964); Sawada
(1957).

When applying CC to the HEG, certain truncations become necessary to make
calculations computationally feasible, albeit at the cost of introducing
errors that compromise accuracy Shepherd  _et al._ (2012a); Shepherd (2016);
Bishop and Lührmann (1982, 1981). The truncation of single-particle states
($M$) gives rise to basis incompleteness errors while truncating electrons
($N$) and the corresponding volume of the HEG ($\Omega$) introduces finite-
size errors while also necessitating the inclusion of boundary conditions
(periodic boundary conditions are used in this work). Finally, the CC cluster
operator must also be truncated, as discussed previously.

This paper focuses on the truncation of $M$, which introduces basis truncation
errors into the calculations compared to calculates performed at the complete
basis limit ($M\longrightarrow\infty$). One approach to mitigate this error
involves performing CC calculations at high values of $M$. However, this
strategy imposes significant computational demands and time requirements,
since CCD computational costs scale as $O(M^{6})$ Urban  _et al._ (1985). For
the calculations performed in this work, the energies converted with respect
to basis size at M=6,142 single-particle states, making the computational
costs of $O(M^{6})$ a very unattractive prospect. This paper aims to address
the truncation errors in coupled cluster calculations by proposing a method
that retains accuracy without relying on computationally burdensome
calculations at larger $M$ values. The focus is on removing the basis
incompleteness error by performing calculations at smaller values of $M$ and
extrapolating the coupled cluster (CC) energy results to achieve convergence
in the complete basis limit.

Specifically, the method involves conducting calculations at a fixed number of
electrons, N, and a fixed Wigner-Seitz radius (rs) using 15 increasing, yet
relatively small, values of $M$ ($M\leq$ 2,090). Note that the exact values of
$M$ used in the calculations depend on the number of particles in the system.
A machine learning-based algorithm is employed to extrapolate the CC energy to
convergence. The resulting converged CC energy should approximate the CC
energy obtained at a high $M$ value ($M=6,142$ in this work), effectively
mitigating the basis incompleteness error, while saving significant
computational time and resources.

## Methodology

(a) $\Delta E_{CC}$ per electron plotted against $N$ with calculations
performed at four different values of $M$. As $M$ increases, the error in the
calculation decreases, but the run time drastically increases.

(b) The run times (measure in node hours) for CCD calculations of the HEG as a
function of M and at three different values of N.

(c) The RAM required for CCD calculations of the HEG as a function of M and at
three different values of N.

(d) A plot of $\Delta E_{CC}$ and $\Delta E_{MBPT}$ versus $M$ for a HEG
system with $N=342$ and rs=0.5. The converged correlation energies calculated
at $M=6,142$ are shown with dashed lines for each method.

(e) Figure 1(d) is transformed such that $\Delta E_{CC}$ are plotted as a
function of t$\Delta E_{MBPT}$ (such that each point has the same $M$). The
resulting plot has a linear relationship that becomes stronger to the left (as
$M$ increases).

(f) A plot of the ratio of $\Delta E_{CC}$ to $\Delta E_{MBPT}$ as a function
of $M$ for $N=114$, $342$, and $514$ and rs=0.5. As $M$ increases, the ratio
(or the slope of the line in Figure 1(c) becomes increasingly constant.
However, it is important to note that the run time increases drastically as
$M$ increases.

Figure 1: An analysis of the relationship between $\Delta E_{CC}$ and $\Delta
E_{MBPT}$ for calculations on the HEG at various $M$, $N$, and rs.

In this work, the CCD and MBPT2 correlation energies will be denoted as
$\Delta$ECC,M and $\Delta$EMBPT,M, respectively, to show the number of single-
particle states in the calculations. Figure 1(a) shows a plot of $\Delta
E_{CC}$ per particle for all magic numbers between two and 514 (inclusive),
with the CC calculations performed at four different values of $M$ and at
$r_{s}$ = 0.5. The calculations performed at $M=514$ (the red line in the
plot) are the least accurate since the data was generated with the lowest
value of $M$. When $M=6,142$, the correlation energies are converged (to
$10^{-7}$ Hartrees), making this data set (plotted in purple) the most
accurate. However, as $M$ increased, the run time and computational resources
of the calculation drastically increased as well.

The computational run times for CCD calculations for the HEG are shown in
Figure 1(b), plotted as a function of the number of single-particle states in
the calculation for three values of $N$ and $r_{s}$ = 0.5. Note that the run
times are reported in node hours, calculated by multiplying the number of
nodes used in the program by the total run time (in hours). This is done to
more accurately reflect the computational resources needed by a parallelized
program. All calculations were performed on Michigan State University’s High
Performance Computing Center (HPCC) using Intel Xeon processors with a clock
speed of 2.4 GHz and 240 GB of RAM. All calculations were parallelized using
four MPI nodes and 28 OpenMP threads. Run time increases drastically as both
$N$ and $M$ increase, with the calculations at higher values of $M$ and $N$
having run times of over twelve node hours. Studies of the homogeneous
electron gas frequently require calculations at many values of $N$ and
$r_{s}$, so having one calculation take hours can make large-scale studies
prohibitive.

Figure 1(c) shows the RAM needed for CCD calculations for the HEG as a
function of $M$ and for three values of $N$ at $r_{s}$ = 0.5. Note that these
RAM measurements have been taken from a naive CCD code which has no memory
optimizations, to show the worst-case scenario in these calculations. This
increase in RAM as $M$ increases is due to an increase in the number of matrix
elements as both $N$ and $M$ increase. Naively, there are ${M\choose N}$
matrix elements, but computational advancements, such as the block-diagonal
memory structure described in Lietz (2019), do reduce the total number of
matrix elements that need to be calculated and stored at one time and since
CCD is already truncated, its memory requirements are only $O(M^{4})$, which
is still quite high for when performing calculations in the complete basis
limit

Therefore, this paper aims to predict the converged $\Delta E_{CC}$ for the
HEG using only data calculated at smaller values of $M$, where the
computational time and resource requirements are less significant. This paper
will use $\Delta E_{CC,6142}$ as the actual, or most accurate result, and
$\Delta E_{CC}$ has been confirmed to have converged at this point, meaning
that the correlation energies have converged to within $10^{-7}$ Hartrees when
adding additional single-particle states to the calculations.

Figure 1(d) shows the convergence of $\Delta E_{CC}$ as a function of $M$ for
a HEG with $N=342$ and rs=0.5. Though the apparent route would be to attempt
to predict the converged correlation energy (plotted with a red dashed line)
using the converging correlation energies from smaller $M$ calculations, in
practice, predictions using this method do not have an acceptable accuracy.
However, if we plot $\Delta E_{MBPT}$ for the same system in addition to
$\Delta E_{CC}$, we see that they follow a very similar pattern. Since $\Delta
E_{MBPT}$ can be generated quickly, the goal of this work is to create a model
through which the converged $\Delta E_{CC}$ can be predicted from $\Delta
E_{MBPT}$. Figure 1(e) is a transformation of Figure 1(d), where $\Delta
E_{CC}$ are plotted as a function of $\Delta E_{MBPT}$. Each point represents
a calculation performed with the same value of $M$. When the data is formatted
in this way, $M$ increases from right to left. As the graph moves from right
to left, it becomes increasingly linear (i.e., the ratio $\Delta E_{CC}/\Delta
E_{MBPT}$ becomes constant as $M$ increases).

We can see this trend more clearly if we plot $\Delta E_{CC}/\Delta E_{MBPT}$
for various $M$ values and $N=114$, $342$, and $514$ with rs = 0.5 in Figure
1(f). For each of these data sets at larger values of $M$, the ratio leveled
off to a constant, or near constant, value. Therefore the goal of the research
is to be able to predict the constant value of $\Delta E_{CC}/\Delta
E_{MBPT}$, which occurs at larger values of $M$ by extrapolating from data
points collected at lower values of $M$. We will use this pattern to create
the input to a method created by the authors known as sequential regression
extrapolation (SRE), a regression-based machine learning algorithm used to
accurately extrapolate small data sets generated from many-body codes.

Both $\Delta E_{CC}$ and $\Delta E_{MBPT}$ converge as M increases. Therefore,
there must be a large value of M where their ratio becomes a constant:

$\frac{\Delta E_{CC,Large\ M}}{\Delta E_{MBPT,Large\ M}}\longrightarrow
constant.$ (7)

Ridge regression, a supervised machine learning algorithm, will be used to
find this constant value using only data collected at low values of M Murphy
(2013); Géron (2017). where the ratio is not yet constant. $\Delta E_{CC}$ and
$\Delta E_{MBPT}$ were calculated for a range of N and rs values, and for 15
values of M for each data set (2 $\leq$ M$\leq$ 2090, exact values depend on
N), resulting in 15 points per data set. For each data set, the training data
for the regression algorithm was created by dividing $\Delta E_{CC}$ by
$\Delta E_{MBPT}$ at the same value of M.

$y=\frac{\Delta E_{CC,M}}{\Delta E_{MBPT,M}}=\frac{\Delta E_{CC,M_{1}}}{\Delta
E_{MBPT,M_{1}}},\frac{\Delta E_{CC,M_{2}}}{\Delta E_{MBPT,M_{2}}},\frac{\Delta
E_{CC,M_{3}}}{\Delta E_{MBPT,M_{3}}},...,\frac{\Delta E_{CC,M_{15}}}{\Delta
E_{MBPT,M_{15}}}$ (8)

Next, a ridge regression algorithm with Bayesian hyperparameter tuning is
trained on this data set Murphy (2013); MacKay (1992); Tipping (2001).
However, the way this algorithm is trained is unique because there is no x
component of the data set. Instead, the input to the algorithm is two
sequential ratios, taking at neighboring values of M, and the output is the
ratio at the next value of M. This method of data formatting combined with a
regression algorithm gives rise to the SRE algorithm.

$f_{Ridge}(\frac{\Delta E_{CC,k-2}}{\Delta E_{MBPT,k-2}},\frac{\Delta
E_{CC,k-1}}{\Delta E_{MBPT,k-1}})=\frac{\Delta E_{CC,k}}{\Delta E_{MBPT,k}}$
(9)

The SRE algorithm is then used to extrapolate this data set to many points
until the ratio of correlation energies has converged (for 100 points in
total). This value can then be taken as the slope of the graph created with
$\Delta E_{CC}$ plotted as a function of $\Delta E_{MBPT}$ at high M (Figure
1(e)).

$\lim_{k\to\infty}\frac{\Delta E_{CC,k}}{\Delta E_{MBPT,k}}=slope=m$ (10)

Finally, $\Delta E_{MBPT,6142}$ is generated, a process that takes less than
one second (not including the time to generate the matrix elements). $\Delta
E_{MBPT,6142}$ is multiplied by the slope, m, to approximate $\Delta
E_{CC,6142}$.

$m\Delta E_{MBPT,6142}\approx\Delta E_{CC,6142}$ (11)

This process is performed for many combinations of N and $r_{s}$, but each
training and prediction takes an average of 30 ms and thus does not contribute
significantly to the run time. It is important to note that the data sets used
to train a machine learning algorithm in this work consist of 15 points each,
making these data sets some of the smallest used in physics applications of
machine learning. Many machine learning algorithms need more points to be
accurately trained, even up to 1-2 orders of magnitude more, as with some
neural networks Jiang  _et al._ (2019); Murphy (2013); Géron (2017); Zhang and
Ling (2018). It is also of note that machine learning is typically only used
to make extrapolations in exceptional cases such as recurrent neural networks.
When asked to make predictions outside their training range, many machine
learning algorithms perform poorly without significant modifications. However,
it will be shown that SRE can make accurate extrapolations using only a small
training set, making it a unique machine learning-based algorithm.

## Results and Discussion

The SRE method must meet two metrics to be a useful extrapolator. First, the
total time to generate the training data, train the SRE algorithm, and predict
the converged correlation energy must be less than the time to do the total
calculation for the correlation energy at $M=6,142$ (significantly less so to
be an attractive alternative). Secondly, the accuracy between the predicted
converged correlation energies and the calculated converged correlation
energies must be high.

The time needed to train the SRE algorithm and predict the converged
correlation energy is on the order of milliseconds, so the primary time
savings will come from calculating the training data versus the time needed to
perform the calculation at $M=6142$. When the number of electrons $N$ is
small, the time savings is also small, only 0.024 node hours for $N=66$ and
$r_{s}$ = 0.5. However, the time savings grows quickly as $N$ increases. For
example, at $N=246$ and $r_{s}$ = 0.5, using the SRE method saves 2.05 node
hours, and by N=514 and $r_{s}$ = 0.5, the SRE time savings is 5.88 node
hours. Therefore, the SRE method can drastically reduce the run times of
predicting the converged correlation energies for the HEG system, especially
for studies requiring many values of rs and $N$. Additionally, the total time
saved from just generating the training data compared to performing all
calculations at $M=6142$ for all data points shown in Figure 2 is 88.9 node
hours.

The amount of RAM needed to generate the training points with the highest $M$
value ($M=2090$) is only 33.15 GB at 514 electrons (represented the largest
combination of $N$ and $M$ across all of the training data sets) while it
takes 106.48 GB of RAM just to generate the fully converged coupled cluster
correlation energy at 66 electrons (one of the smaller numbers of electrons
studied). At its worst, calculating the fully converged CCD correlation energy
at 514 electrons (the highest number of electrons in this study) took 444.48
GB of RAM. Thus, using the SRE method and only needing to generate a small
amount of training data at low values of M saves significant computational
time and resources when compared to performing the fully converged
calculations at a high value of $M$.

While a reduced run time and lessened computational resources are important,
an even more important factor is the accuracy of the predictions. In Figure 2,
the predicted converged $\Delta E_{CC}$ per electron is plotted with $\Delta
E_{CC,6142}/N$ for a variety of values of $N$ and rs. We limit ourselves to
values of $r_{s}<1.0$ as we are interested in studying a high-density electron
gas Carr and Maradudin (1964); Sawada (1957). The solid lines graph the fully
converged calculations performed at $M=6142$, the triangular markers plot the
SRE prediction for the converged CCD correlation energy per electron at each
combination of $N$ and $r_{s}$, and the shaded regions show the uncertainty of
the ML prediction, computed by the Bayesian ridge regression algorithm. Each
color in the plot represents a different value of $r_{s}$, as shown in the
legend of Figure 2.

Figure 2: The results from performing an SRE extrapolation for various numbers
of electrons and values of rs. Results are plotted against $\Delta
E_{CC,6142}$ and the uncertainties on the predictions are also shown with
shaded regions.

The machine learning predictions lead to an average error for each $r_{s}$
shown in Table 1, and an overall percent error of 0.46$\%$. If instead of
considering the correlation energy, we instead consider transforming the
predictions to the full coupled cluster energy ($E_{CC}=E_{0}+\Delta E_{CC}$),
the average percent error drops to 0.011$\%$. Regardless of whether the
energies or correlation energies are the desired result, the SRE method is
able to make all predictions shown in Figure 2 (70 predictions) with an
average error of 4.29x10-4 Hartrees, meaning this error would not be
significant in most coupled cluster calculations.

rs | Average Error on Prediction (Hartrees) | Average Uncertainty (Hartrees)
---|---|---
0.05 | 1.59x10${-4}$ | 5.59x10-3
0.1 | 2.49x10-4 | 5.10x10-3
0.25 | 3.57x10-4 | 3.48x10-3
0.5 | 3.99x10-4 | 2.23x10-3
0.75 | 9.93x10-3 | 2.21x10-3
Table 1: A quantitative summary of the SRE prediction accuracy. The first
column is the Wigner-Seitz radius, the second the average error (in Hartrees)
for each value of $r_{s}$, and the third column the average uncertainty on the
predictions, taken from the Bayesian ridge regression algorithm.

## Conclusion

Truncating the number of single-particle states in coupled cluster
calculations of the homogeneous electron gas is required due to restrictions
on computational time and resources. However, this truncation introduces basis
incompleteness errors into the calculations, which reduces their accuracy. The
SRE method allows the coupled cluster double correlation energies at the limit
of high M to be recovered using CCD correlation energies at small values of
$M$. This saves significant computational time and resources while still
achieving an acceptable level of accuracy. To frame the SRE method in another
method, it is a dimensionality reduction algorithm for CCD calculations since
it allows the number of single-particle states in a calculation to be
drastically reduced while still achieving the accuracy of a calculation with a
much higher dimension (i.e. the complete basis limit).

Though this work presents the SRE method in the light of performing basis
completeness extrapolations for coupled cluster calculations of the
homogeneous electron gas, SRE is an extremely general method that can be
applied to many problems. With no modifications, this method can perform basis
completeness extrapolations for coupled cluster calculations of many systems,
both finite and infinite. Of particular interest to the authors is the
potential ability of the SRE method to predict the CC correlation energy in
the complete basis limit for infinite nuclear matter and atomic nuclei
Baardsen  _et al._ (2013); Hagen  _et al._ (2014a); Baardsen (2014); Hagen
_et al._ (2014b); Hu  _et al._ (2022); Hagen  _et al._ (2016). Additionally,
basis truncations are not unique to coupled cluster calculations, making SRE
applicable to other many-body methods as well. Other many-body methods, such
as full configuration interaction and in-medium similarity renormalization
group theory, may also benefit from an SRE approach Hergert  _et al._ (2016);
Morris  _et al._ (2015). Finally, with minor modifications to the set-up of
the problem, the SRE method can be used to perform other extrapolations such
as extrapolating to the thermodynamic limit to remove finite size effects and
extrapolating with respect to the order of a calculation to include higher-
order terms without increasing run times, relevant for many-body perturbation
theory and coupled cluster theory among others. Thus, the SRE method, capable
of accurately performing extrapolations with small data sets, has the
possibility of decreasing computational run times and resource requirements of
calculations throughout the field of many-body physics, making large-scale
studies and studies of complex systems much more feasible.

## Acknowledgements

This research is supported by the U.S. National Science Foundation Grants No.
PHY-1404159 and PHY-2013047. Support from the Research Council of Norway
through the INTPART program, grant No. 288125, is acknowledged. This material
is based upon work supported by the U.S. Department of Energy, Office of
Science, Office of Workforce Development for Teachers and Scientists, Office
of Science Graduate Student Research (SCGSR) program. The SCGSR program is
administered by the Oak Ridge Institute for Science and Education (ORISE) for
the DOE. ORISE is managed by ORAU under contract number DE-SC0014664. All
opinions expressed in this paper are the author’s and do not necessarily
reflect the policies and views of DOE, ORAU, or ORISE.

## References

  * Shepherd  _et al._ (2012a) J. J. Shepherd, A. Grüneis, G. H. Booth, G. Kresse, and A. Alavi, Phys. Rev. B 86, 035111 (2012a).
  * Shepherd (2016) J. J. Shepherd, The Journal of Chemical Physics 145, 031104 (2016), https://doi.org/10.1063/1.4958461 .
  * Lietz  _et al._ (2017) J. G. Lietz, S. Novario, G. R. Jansen, G. Hagen, and M. Hjorth-Jensen, “Computational nuclear physics and post hartree-fock methods,” in  _An Advanced Course in Computational Nuclear Physics: Bridging the Scales from Quarks to Neutron Stars_, edited by M. Hjorth-Jensen, M. P. Lombardo, and U. van Kolck (Springer International Publishing, Cham, 2017) pp. 293–399.
  * Bishop (1991) R. Bishop, Theoretica Chimica Acta 80, 95 (1991).
  * Bishop and Lührmann (1982) R. F. Bishop and K. H. Lührmann, Phys. Rev. B 26, 5523 (1982).
  * Bishop and Lührmann (1981) R. Bishop and K. Lührmann, Physica B+C 108, 873 (1981).
  * Neufeld and Thom (2017) V. A. Neufeld and A. J. W. Thom, The Journal of Chemical Physics 147 (2017), 10.1063/1.5003794, 194105, https://pubs.aip.org/aip/jcp/article-pdf/doi/10.1063/1.5003794/15534755/194105_1_online.pdf .
  * Ceperley and Alder (1980) D. M. Ceperley and B. J. Alder, Phys. Rev. Lett. 45, 566 (1980).
  * Tanatar and Ceperley (1989) B. Tanatar and D. M. Ceperley, Phys. Rev. B 39, 5005 (1989).
  * Kwon  _et al._ (1998) Y. Kwon, D. M. Ceperley, and R. M. Martin, Phys. Rev. B 58, 6800 (1998).
  * Pescia  _et al._ (2023) G. Pescia, J. Nys, J. Kim, A. Lovato, and G. Carleo, “Message-passing neural quantum states for the homogeneous electron gas,” (2023), arXiv:2305.07240 [quant-ph] .
  * Cassella  _et al._ (2023) G. Cassella, H. Sutterud, S. Azadi, N. D. Drummond, D. Pfau, J. S. Spencer, and W. M. C. Foulkes, Phys. Rev. Lett. 130, 036401 (2023).
  * Shavitt and Bartlett (2009a) I. Shavitt and R. J. Bartlett,  _Many-Body Methods in Chemistry and Physics: MBPT and Coupled-Cluster Theory_, Cambridge Molecular Science (Cambridge University Press, 2009).
  * Binder  _et al._ (2013) S. Binder, P. Piecuch, A. Calci, J. Langhammer, P. Navrátil, and R. Roth, Phys. Rev. C 88, 054319 (2013).
  * Bishop and Kümmel (1987) R. F. Bishop and H. G. Kümmel, Physics Today 40, 52 (1987), https://pubs.aip.org/physicstoday/article-pdf/40/3/52/8298562/52_1_online.pdf .
  * Vargas-Hernández  _et al._ (2018) R. A. Vargas-Hernández, J. Sous, M. Berciu, and R. V. Krems, Phys. Rev. Lett. 121, 255702 (2018).
  * Neufcourt  _et al._ (2018) L. Neufcourt, Y. Cao, W. Nazarewicz, and F. Viens, Phys. Rev. C 98, 034318 (2018).
  * Kümmel  _et al._ (1978) H. Kümmel, K. Lührmann, and J. Zabolitzky, Physics Reports 36, 1 (1978).
  * Bartlett and Musiał (2007) R. J. Bartlett and M. Musiał, Rev. Mod. Phys. 79, 291 (2007).
  * Čižek and Paldus (1971) J. Čižek and J. Paldus, International Journal of Quantum Chemistry 5, 359 (1971), https://onlinelibrary.wiley.com/doi/pdf/10.1002/qua.560050402 .
  * Čížek (2004) J. Čížek, The Journal of Chemical Physics 45, 4256 (2004), https://pubs.aip.org/aip/jcp/article-pdf/45/11/4256/11266618/4256_1_online.pdf .
  * Singal and Das (1973) C. M. Singal and T. P. Das, Phys. Rev. B 8, 3675 (1973).
  * Haftel and Tabakin (1970) M. I. Haftel and F. Tabakin, Nucl. Phys. A 158, 1 (1970).
  * Freeman (1977) D. L. Freeman, Phys. Rev. B 15, 5512 (1977).
  * Bishop and L”uhrmann (1978) R. F. Bishop and K. H. L”uhrmann, Phys. Rev. B 17, 3757 (1978).
  * Bishop and L”uhrmann (1982) R. F. Bishop and K. H. L”uhrmann, Phys. Rev. B 26, 5523 (1982).
  * Shavitt and Bartlett (2009b) I. Shavitt and R. J. Bartlett,  _Many-body Methods in Chemistry and Physics_ (Cambridge University Press, 2009).
  * Shepherd  _et al._ (2012b) J. J. Shepherd, A. Grüneis, G. H. Booth, G. Kresse, and A. Alavi, Phys. Rev. B 86, 035111 (2012b).
  * Shepherd and Grüneis (2013) J. J. Shepherd and A. Grüneis, Phys. Rev. Lett. 110, 226401 (2013).
  * Shepherd  _et al._ (2014a) J. J. Shepherd, T. M. Henderson, and G. E. Scuseria, Phys. Rev. Lett. 112, 209901 (2014a).
  * Shepherd  _et al._ (2014b) J. J. Shepherd, T. M. Henderson, and G. E. Scuseria, The Journal of Chemical Physics 140, 124102 (2014b), http://dx.doi.org/10.1063/1.4867783.
  * Murphy (2013) K. P. Murphy,  _Machine learning : a probabilistic perspective_ (MIT Press, Cambridge, Mass. [u.a.], 2013).
  * Géron (2017) A. Géron,  _Hands-on machine learning with Scikit-Learn and TensorFlow : concepts, tools, and techniques to build intelligent systems_ (O’Reilly Media, Sebastopol, CA, 2017).
  * Mehta  _et al._ (2019) P. Mehta, M. Bukov, C.-H. Wang, A. G. Day, C. Richardson, C. K. Fisher, and D. J. Schwab, Physics Reports 810, 1 (2019), a high-bias, low-variance introduction to Machine Learning for physicists.
  * Negoita  _et al._ (2019) G. A. Negoita, J. P. Vary, G. R. Luecke, P. Maris, A. M. Shirokov, I. J. Shin, Y. Kim, E. G. Ng, C. Yang, M. Lockner, and G. M. Prabhu, Phys. Rev. C 99, 054308 (2019).
  * Jiang  _et al._ (2019) W. G. Jiang, G. Hagen, and T. Papenbrock, Phys. Rev. C 100, 054326 (2019).
  * Akkoyun  _et al._ (2013) S. Akkoyun, T. Bayram, S. O. Kara, and A. Sinan, Journal of Physics G: Nuclear and Particle Physics 40, 055106 (2013).
  * Utama  _et al._ (2016) R. Utama, J. Piekarewicz, and H. B. Prosper, Phys. Rev. C 93, 014311 (2016).
  * Carleo and Troyer (2017) G. Carleo and M. Troyer, Science 355, 602 (2017), https://www.science.org/doi/pdf/10.1126/science.aag2302 .
  * Boehnlein  _et al._ (2022) A. Boehnlein, M. Diefenthaler, N. Sato, M. Schram, V. Ziegler, C. Fanelli, M. Hjorth-Jensen, T. Horn, M. P. Kuchera, D. Lee, W. Nazarewicz, P. Ostroumov, K. Orginos, A. Poon, X.-N. Wang, A. Scheinker, M. S. Smith, and L.-G. Pang, Rev. Mod. Phys. 94, 031003 (2022).
  * Ismail and Gezerlis (2021) N. Ismail and A. Gezerlis, Phys. Rev. C 104, 055802 (2021).
  * Meredig  _et al._ (2018) B. Meredig, E. Antono, C. Church, M. Hutchinson, J. Ling, S. Paradiso, B. Blaiszik, I. Foster, B. Gibbons, J. Hattrick-Simpers, A. Mehta, and L. Ward, Mol. Syst. Des. Eng. 3, 819 (2018).
  * Jinnouchi  _et al._ (2017) R. Jinnouchi, H. Hirata, and R. Asahi, The Journal of Physical Chemistry C 121, 26397 (2017), https://doi.org/10.1021/acs.jpcc.7b08686 .
  * Knöll  _et al._ (2023) M. Knöll, T. Wolfgruber, M. L. Agel, C. Wenz, and R. Roth, Physics Letters B 839, 137781 (2023).
  * Margraf and Reuter (2018) J. T. Margraf and K. Reuter, The Journal of Physical Chemistry A 122, 6343 (2018), pMID: 29985611, https://doi.org/10.1021/acs.jpca.8b04455 .
  * Smith  _et al._ (2019) J. Smith, B. Nebgen, R. Zubatyuk, N. Lubbers, C. Devereux, K. Barros, S. Tretiak, O. Isayev, and A. Roitberg, Nature Communications 10 (2019), 10.1038/s41467-019-10827-4.
  * Mihm  _et al._ (2021a) T. N. Mihm, B. Yang, and J. J. Shepherd, Journal of Chemical Theory and Computation 17, 2752 (2021a), pMID: 33830754, https://doi.org/10.1021/acs.jctc.0c01171 .
  * Mihm  _et al._ (2023) T. N. Mihm, L. Weiler, and J. J. Shepherd, Journal of Chemical Theory and Computation 19, 1686 (2023), pMID: 36918372, https://doi.org/10.1021/acs.jctc.2c00737 .
  * Mihm  _et al._ (2021b) T. N. Mihm, W. Z. Van Benschoten, and J. J. Shepherd, The Journal of Chemical Physics 154 (2021b), 10.1063/5.0033408, 024113, https://pubs.aip.org/aip/jcp/article-pdf/doi/10.1063/5.0033408/15583886/024113_1_online.pdf .
  * Liao and Grüneis (2016) K. Liao and A. Grüneis, The Journal of Chemical Physics 145 (2016), 10.1063/1.4964307, 141102, https://pubs.aip.org/aip/jcp/article-pdf/doi/10.1063/1.4964307/15518055/141102_1_online.pdf .
  * Mihm  _et al._ (2021c) T. Mihm, T. Schäfer, and S. e. a. Ramadugu, Nat Comput Sci 1, 801 (2021c).
  * Köhn and Tew (2010) A. Köhn and D. P. Tew, The Journal of Chemical Physics 132 (2010), 10.1063/1.3291040, 024101, https://pubs.aip.org/aip/jcp/article-pdf/doi/10.1063/1.3291040/14745329/024101_1_online.pdf .
  * Coester and Kümmel (1960) F. Coester and H. Kümmel, Nuclear Physics 17, 477 (1960).
  * Coester (1958) F. Coester, Nuclear Physics 7, 421 (1958).
  * Urban  _et al._ (1985) M. Urban, J. Noga, S. J. Cole, and R. J. Bartlett, The Journal of Chemical Physics 83, 4041–4046 (1985).
  * Taube and Bartlett (2008) A. G. Taube and R. J. Bartlett, The Journal of Chemical Physics 128 (2008), 10.1063/1.2830236, 044110, https://pubs.aip.org/aip/jcp/article-pdf/doi/10.1063/1.2830236/13473501/044110_1_online.pdf .
  * Kucharski and Bartlett (1998) S. A. Kucharski and R. J. Bartlett, The Journal of Chemical Physics 108, 5243 (1998), https://pubs.aip.org/aip/jcp/article-pdf/108/13/5243/10789764/5243_1_online.pdf .
  * Bartlett  _et al._ (1990) R. J. Bartlett, J. Watts, S. Kucharski, and J. Noga, Chemical Physics Letters 165, 513 (1990).
  * Raghavachari  _et al._ (1989) K. Raghavachari, G. W. Trucks, J. A. Pople, and M. Head-Gordon, Chemical Physics Letters 157, 479 (1989).
  * He  _et al._ (2001) Y. He, Z. He, and D. Cremer, Theoretical Chemistry Accounts: Theory, Computation, and Modeling (Theoretica Chimica Acta) 105, 182 (2001).
  * Bishop and Lührmann (1978) R. F. Bishop and K. H. Lührmann, Phys. Rev. B 17, 3757 (1978).
  * March  _et al._ (1995) N. March, W. Young, and S. Sampanthar,  _The Many-Body Problem in Quantum Physics_ (Dover Publications, 1995).
  * Carr and Maradudin (1964) W. J. Carr and A. A. Maradudin, Phys. Rev. 133, A371 (1964).
  * Sawada (1957) K. Sawada, Phys. Rev. 106, 372 (1957).
  * Lietz (2019) J. G. Lietz,  _Computational developments for ab initio many-body theory_ , Ph.d., Michigan State University (2019).
  * MacKay (1992) D. J. C. MacKay, Neural Computation 4, 415 (1992), https://direct.mit.edu/neco/article-pdf/4/3/415/812340/neco.1992.4.3.415.pdf .
  * Tipping (2001) M. E. Tipping, J. Mach. Learn. Res. 1, 211–244 (2001).
  * Zhang and Ling (2018) Y. Zhang and C. Ling, npj Computational Materials 4 (2018), 10.1038/s41524-018-0081-z.
  * Baardsen  _et al._ (2013) G. Baardsen, A. Ekström, G. Hagen, and M. Hjorth-Jensen, Phys. Rev. C 88, 054312 (2013).
  * Hagen  _et al._ (2014a) G. Hagen, T. Papenbrock, A. Ekström, K. A. Wendt, G. Baardsen, S. Gandolfi, M. Hjorth-Jensen, and C. J. Horowitz, Phys. Rev. C 89, 014319 (2014a).
  * Baardsen (2014) G. Baardsen,  _Coupled-cluster theory for infinite matter_ , Ph.d., University of Oslo (2014).
  * Hagen  _et al._ (2014b) G. Hagen, T. Papenbrock, M. Hjorth-Jensen, and D. J. Dean, Reports on Progress in Physics 77, 096302 (2014b).
  * Hu  _et al._ (2022) B. Hu, W. Jiang, T. Miyagi, Z. Sun, A. Ekström, C. Forssén, G. Hagen, J. D. Holt, T. Papenbrock, S. R. Stroberg, and I. Vernon, Nature Physics 18 (2022), 10.1038/s41567-022-01715-8.
  * Hagen  _et al._ (2016) G. Hagen, M. Hjorth-Jensen, G. R. Jansen, and T. Papenbrock, Physica Scripta 91, 063006 (2016).
  * Hergert  _et al._ (2016) H. Hergert, S. Bogner, T. Morris, A. Schwenk, and K. Tsukiyama, Physics Reports 621, 165 (2016), memorial Volume in Honor of Gerald E. Brown.
  * Morris  _et al._ (2015) T. D. Morris, N. M. Parzuchowski, and S. K. Bogner, Phys. Rev. C 92, 034331 (2015).


May 2023 An ASP Framework for the Refinement of Authorization and Obligation
Policies–References

# An ASP Framework for the Refinement of Authorization and Obligation Policies

DANIELA INCLEZAN
Miami University  Oxford  OH  USA
<EMAIL_ADDRESS>
(2023)

###### Abstract

This paper introduces a framework for assisting policy authors in refining and
improving their policies. In particular, we focus on authorization and
obligation policies that can be encoded in Gelfond and Lobo’s $\mathscr{AOPL}$
language for policy specification. We propose a framework that detects the
statements that make a policy inconsistent, underspecified, or ambiguous with
respect to an action being executed in a given state. We also give attention
to issues that arise at the intersection of authorization and obligation
policies, for instance when the policy requires an unauthorized action to be
executed. The framework is encoded in Answer Set Programming.

###### keywords:

policy, authorizations and obligations, dynamic domains, ASP

##  1 Introduction

This paper introduces a framework for assisting policy authors in refining and
improving the policies they elaborate. Here, by a policy we mean a collection
of statements that describe the permissions and obligations related to an
agent’s actions.

In particular, we focus on authorization and obligation policies that can be
encoded in the policy specification language $\mathscr{AOPL}$ by Gelfond and
Lobo 2008. $\mathscr{AOPL}$ allows an author to specify policies for an
autonomous agent acting in a changing environment. A description of the
dynamic domain in terms of sorts of the domain, relevant fluents, and actions
is assumed to be available to the policy writer. Policy rules of
$\mathscr{AOPL}$ may be of two kinds: _authorization_ rules specifying what
actions are permitted/ not permitted and in which situations, and _obligation_
rules indicating what actions an agent must perform or not perform under
certain conditions. Rules can either be strict or defeasible, and preferences
between defeasible rules can be set by the policy author. The semantics of
$\mathscr{AOPL}$ is defined via a translation into Answer Set Programming
(ASP) Gelfond and Lifschitz (1991). Gelfond and Lobo define policy properties
such as consistency and categoricity. However, there is a gap in analyzing
what happens at the intersection between authorization and obligation
policies, for instance when a policy requires an unauthorized action to be
executed, which is called a modality conflict by Craven et al. 2009.

We propose a framework that detects the rules that make a policy inconsistent,
underspecified, or ambiguous with respect to an action and a given state. The
goal is to notify the policy author about the natural language statements in
the policy that may be causing an issue and explain why that is the case for
the particular action and state.

Given rapid advancements in AI in the past years, the importance of setting
and enforcing policies on intelligent agents has become paramount. At the same
time, policy specifications can become large and intricate. Thus, assisting
policy authors and knowledge engineers with policy refinement by automatically
detecting issues in a provably correct way and highlighting conflicting policy
statements is of great importance.

The contributions of our work are as follows:

  * •

We define a new translation of $\mathscr{AOPL}$ policies into ASP by reifying
policy rules.

  * •

We formally define issues that may arise in $\mathscr{AOPL}$ policies and
describe how to detect the causing policy statements, using the reified ASP
translation.

  * •

We define means for explaining the root causes for issues like inconsistency,
underspecification, ambiguity, and modality conflicts.

In what follows, we provide a short description of language $\mathscr{AOPL}$
in Section 2 and give a motivating example in Section 3. We describe our new
translation of $\mathscr{AOPL}$ policies into ASP in Section 4 and introduce
our framework in Section 5. We discuss related work in Section 6 and end with
conclusions and future work.

##  2 Background: Language $\mathscr{AOPL}$

Let us now briefly present the $\mathscr{AOPL}$ language. We direct the
unfamiliar reader to outside resources on ASP Gelfond and Lifschitz (1991);
Marek and Truszczynski (1999) and action language $\mathscr{AL}_{d}$ Gelfond
and Inclezan (2013); Gelfond and Kahl (2014), which are also relevant to this
work.

Gelfond and Lobo 2008111Available at
https://www.depts.ttu.edu/cs/research/documents/44.pdf introduced the
Authorization and Obligation Policy Language $\mathscr{AOPL}$ for specifying
policies for an intelligent agent acting in a dynamic environment. A policy is
a collection of authorization and obligation statements, which we simply call
authorizations and obligations, respectively. An authorization indicates
whether an agent’s action is permitted or not, and under which conditions. An
obligation describes whether an agent is obligated or not obligated to perform
a specific action under certain conditions. An $\mathscr{AOPL}$ policy works
in conjunction with a dynamic system description of the agent’s environment
written in an action language such as $\mathscr{AL}_{d}$. The signature of the
dynamic system description includes predicates denoting sorts for the elements
in the domain; fluents (i.e., properties of the domain that may be changed by
actions); and actions. As in $\mathscr{AL}_{d}$, we consider dynamic systems
that can be represented by a directed graph, called a transition diagram,
containing a finite number of nodes representing physically possible states of
the dynamic domain. A state is a complete and consistent set of fluent
literals. Arcs in the transition diagram are labeled by action atoms (shortly
actions) that take the system from one state to another. Actions can be
elementary or compound, where a compound action is a set of elementary actions
executed simultaneously.

The signature of an $\mathscr{AOPL}$ policy includes the signature of the
associated dynamic system and additional predicates $permitted$ for
authorizations, $obl$ for obligations, and prefer for establishing preferences
between authorizations or obligations. A prefer atom is created from the
predicate prefer; similarly for $permitted$ and $obl$ atoms.

######  Definition 1 (Policy)

An $\mathscr{AOPL}$ policy $\mathscr{P}$ is a finite collection of statements
of the form:

$\displaystyle\ \ permitted\left(e\right)$ $\displaystyle\textbf{ if }\ cond$
(1a) $\displaystyle\neg permitted\left(e\right)$ $\displaystyle\textbf{ if }\
cond$ (1b) $\displaystyle\ \ obl\left(h\right)$ $\displaystyle\textbf{ if }\
cond$ (1c) $\displaystyle\neg obl\left(h\right)$ $\displaystyle\textbf{ if }\
cond$ (1d) $\displaystyle d:\textbf{normally }$ $\displaystyle\ \
permitted(e)$ $\displaystyle\textbf{ if }\ cond$ (1e) $\displaystyle
d:\textbf{normally }$ $\displaystyle\neg permitted(e)$ $\displaystyle\textbf{
if }\ cond$ (1f) $\displaystyle d:\textbf{normally }$ $\displaystyle\ \
obl(h)$ $\displaystyle\textbf{ if }\ cond$ (1g) $\displaystyle
d:\textbf{normally }$ $\displaystyle\neg obl(h)$ $\displaystyle\textbf{ if }\
cond$ (1h) $\displaystyle\ \ \mbox{{prefer}}(d_{i},d_{j})$ (1i)

where $e$ is an elementary action; $h$ is a happening (i.e., an elementary
action or its negation222If $obl(\neg e)$ is true, then the agent must not
execute $e$.); $cond$ is a (possibly empty) collection of atoms of the
signature, except for atoms containing the predicate prefer; $d$ appearing in
(1e)-(1h) denotes a defeasible rule label; and $d_{i}$, $d_{j}$ in (1i) refer
to two distinct rule labels from $\mathscr{P}$. Rules (1a)-(1d) encode strict
policy statements, while rules (1e)-(1h) encode defeasible statements (i.e.,
statements that may have exceptions). Rule (1i) captures priorities between
defeasible statements.

In deontic terms, rules (1a) and (1e) denote permissions; rules (1b) and (1f)
denote prohibitions; rules (1c) and (1g) denote obligations; and rules (1d)
and (1h) denote dispensations.

The semantics of an $\mathscr{AOPL}$ policy determine a mapping
$\textbf{P}(\sigma)$ from states of a transition diagram $\mathscr{T}$ into a
collection of $permitted$ and $obl$ literals. To formally describe the
semantics of $\mathscr{AOPL}$, a translation of a policy and transition
diagram into ASP is defined.

######  Definition 2 (ASP Translation of a Policy and State)

The translation $lp$ is defined as:

  * •

If $x$ is a fluent literal, action literal, $permitted$, or $obl$ literal,
then $lp(x)=_{def}x$ .

  * •

If $L$ is a set of literals, then $lp(L)=_{def}\\{lp(l):l\in L\\}$

  * •

If $r=``l\ \textbf{if}\ cond"$ is a strict rule like the ones in (1a)-(1d),
then $lp(r)=_{def}lp(l)\leftarrow lp(cond)$

  * •

If $r$ is a defeasible rule like (1e) or (1f), or a preference rule
“prefer$(d_{i},d_{j})$” like the one in (1i), then $lp(r)$ is obtained using
standard ASP techniques for encoding defaults, as shown in equations (2a),
(2b), and (2c) respectively:

$\displaystyle permitted(e)$ $\displaystyle\leftarrow\ lp(cond),\mbox{not}\
ab(d),\mbox{not}\ \neg permitted(e)$ (2a) $\displaystyle\neg permitted(e)$
$\displaystyle\leftarrow\ lp(cond),\mbox{not}\ ab(d),\mbox{not}\ permitted(e)$
(2b) $\displaystyle ab(d_{j})$ $\displaystyle\leftarrow\ lp(cond_{i})$ (2c)

where $cond_{i}$ is the condition of $d_{i}$. Similarly for defeasible
obligations (1g) and (1h).

  * •

If $\mathscr{P}$ is a policy, then
$lp(\mathscr{P})=_{def}\\{lp(st):st\in\mathscr{P}\\}$.

  * •

If $\mathscr{P}$ is a policy and $\sigma$ is a state of the (transition
diagram associated with the) dynamic system description $\mathscr{T}$,

$lp(\mathscr{P},\sigma)=_{def}lp(\mathscr{P})\cup lp(\sigma)$

Properties of an $\mathscr{AOPL}$ policy $\mathscr{P}$ are defined in terms of
the answer sets of the logic program $lp(\mathscr{P},\sigma)$ expanded with
appropriate rules.

The following definitions by Gelfond and Lobo are relevant to our work
(original definition numbers in parenthesis). In what follows $a$ denotes a
(possibly) compound action (i.e., a set of simultaneously executed elementary
actions), while $e$ refers to an elementary action. An event
$\langle\sigma,a\rangle$ is a pair consisting of a state $\sigma$ and a
(possibly) compound action $a$ executed in $\sigma$.333In policy analysis, we
want to encompass all possible events, i.e., pairs consisting of a physically
possible state $\sigma$ and physically executable action $a$ in $\sigma$.

######  Definition 3 (Consistency – Def. 3)

A policy $\mathscr{P}$ for $\mathscr{T}$ is called consistent if for every
state $\sigma$ of $\mathscr{T}$, the logic program $lp(\mathscr{P},\sigma)$ is
consistent, i.e., it has an answer set.

######  Definition 4 (Policy Compliance for Authorizations – Defs. 4 and 5)

$\bullet\ $ An event $\langle\sigma,a\rangle$ is strongly compliant with
authorization policy $\mathscr{P}$ if for every $e\in a$ we have that
$permitted(e)\in$ $\textbf{P}(\sigma)$ (i.e., the logic program
$lp(\mathscr{P},\sigma)$ entails $permitted(e)$).

$\bullet\ $ An event $\langle\sigma,a\rangle$ is weakly compliant with
authorization policy $\mathscr{P}$ if for every $e\in a$ we have that $\neg
permitted(e)\notin$ $\textbf{P}(\sigma)$ (i.e., the logic program
$lp(\mathscr{P},\sigma)$ does not entail $\neg permitted(e)$).

$\bullet\ $ An event $\langle\sigma,a\rangle$ is non-compliant with
authorization policy $\mathscr{P}$ if for every $e\in a$ we have that $\neg
permitted(e)\in$ $\textbf{P}(\sigma)$ (i.e., the logic program
$lp(\mathscr{P},\sigma)$ entails $\neg permitted(e)$).

######  Definition 5 (Policy Compliance for Obligations – Def. 9)

An event $\langle\sigma,a\rangle$ is compliant with obligation policy
$\mathscr{P}$ if

$\bullet\ $ For every $obl(e)\in$ $\textbf{P}(\sigma)$ we have that $e\in a$,
and

$\bullet\ $ For every $obl(\neg e)\in$ $\textbf{P}(\sigma)$ we have that
$e\notin a$.

######  Definition 6 (Categoricity – Def. 6)

A policy $\mathscr{P}$ for $\mathscr{T}$ is called categorical if for every
state $\sigma$ of $\mathscr{T}$ the logic program $lp(\mathscr{P},\sigma)$ is
categorical, i.e., has exactly one answer set.

Note that $\mathscr{AOPL}$ does not discuss interactions between
authorizations and obligations referring to the same action, for instance
situations when both $obl(e)$ and $\neg permitted(e)$ are part of the answer
set of $lp(\mathscr{P},\sigma)$ for some state $\sigma$.

##  3 Motivating Example

To illustrate the policy refinement process that we want to facilitate, let’s
consider an example provided by Gelfond and Lobo, expanded with an additional
rule 4):

######  Example 1 (Authorization Policy Example)

1) A military officer is not allowed to command a mission they authorized.

2) A colonel is allowed to command a mission they authorized.

3) A military observer can never authorize a mission.

4) A military officer must command a mission if ordered by their superior to
do so.

Before discussing the encoding of this policy, let us assume that the
description of this domain includes actions $assume\\_comm(C,M)$ and
$authorize\\_comm(C,M)$; fluents $autorized(C,M)$ and
$ordered\\_by\\_superior(C,M)$; and sorts $colonel(C)$ and $observer(C)$,
where $C$ is a commander and $M$ is a mission.

In the English description of the policy in Example 1, note that statements 1)
and 2) are phrased as strict rules and thus an automated translation process
into $\mathscr{AOPL}$ would produce the policy:

$\displaystyle\neg permitted(assume\\_comm(C,M))$ $\displaystyle\textbf{ if
}authorized(C,M)$ (3a) $\displaystyle permitted(assume\\_comm(C,M))$
$\displaystyle\textbf{ if }colonel(C)$ (3b) $\displaystyle\neg
permitted(authorize\\_comm(C,M))$ $\displaystyle\textbf{ if }observer(C)$ (3c)
$\displaystyle obl(assume\\_comm(C,M))$ $\displaystyle\textbf{ if
}ordered\\_by\\_superior(C,M)$ (3d)

Such a policy is inconsistent in a state in which $authorized(c,m)$ and
$colonel(c)$ both hold, due to rules (3a) and (3b). Gelfond and Lobo indicate
that “[s]ince the nature of the first two authorization policy statements of
our example are contradictory we naturally assume them to be defeasible” and
replace the encoding in rules (3a) and (3b) with

$\begin{array}[]{ll}d_{1}(C,M)\ :&{\bf normally}\ \neg
permitted(assume\\_comm(C,M))\ \textbf{ if }authorized(C,M)\\\ d_{2}(C,M)\
:&{\bf normally}\ \ \ permitted(assume\\_comm(C,M))\ \textbf{ if
}colonel(C)\\\ &prefer(d_{2}(C,M),d_{1}(C,M))\end{array}$

while leaving rule (3c) as it is. Rule (3d) is unaffected, as it corresponds
to the new policy statement 4) that we added to the original example by
Gelfond and Lobo, to illustrate obligations.

This approach has several drawbacks: (a) it puts the burden on the knowledge
engineer, who may have a more limited knowledge of the domain than the policy
author and thus may make false assumptions; (b) it does not scale for large
and intricate policies; and (c) it would be difficult to automate. Instead, we
propose a framework that detects inconsistencies like the one above, alerts
the policy author of the conflicting policy statements and the conditions that
cause them, and allows the policy author to refine the policy (with options
for refinement possibly suggested, in the future). In particular, for Example
1, we expect our framework to indicate that statements 1) and 2) are in
conflict in a state in which both $colonel(c)$ and $authorized(c,m)$ are true.
Similarly, our framework should flag the contradiction between the obligation
in rule 4) and rule 1) in a state in which $authorized(c,m)$ and
$ordered\\_by\\_superior(c,m)$ both hold.

To achieve this goal, we modify $\mathscr{AOPL}$ by introducing labels for all
rules (including strict and preference rules)444As in the original
$\mathscr{AOPL}$ language, preferences can be defined only between pairs of
defeasible rules. and connecting rules of $\mathscr{AOPL}$ with natural
language statements of the original policy via a new predicate $text$ as in
the following example for the strict policy rule in (3c) where $s_{1}$ is the
label for the strict authorization rule:

$\begin{array}[]{ll}s_{1}:&\neg permitted(authorize\\_command(C,M))\textbf{ if
}observer(C)\\\ &text(s_{1},``\mbox{A military observer can never authorize a
mission.}")\end{array}$

Additionally, we define a different translation of $\mathscr{AOPL}$ into ASP,
which we will denote by $rei\\_lp$ as it reifies policy rules. We define the
$rei\\_lp$ translation in the next section.

##  4 Reification of Policy Rules

The new translation of $\mathscr{AOPL}$ into ASP that we propose follows
previous methods for the reification of rules in other domains, such as
reasoning about prioritized defaults Gelfond and Son (1997) or belief states
Balduccini et al. (2020). Similar to the definition of the $lp$ translation
function, the signature of $rei\\_lp(\mathscr{P})$ for a policy $\mathscr{P}$
applying in a dynamic domain described by $\mathscr{T}$ contains the sorts,
fluents, and actions of $\mathscr{T}$. To simplify the presentation, we limit
ourselves to boolean fluents and use the general syntax

$r:[{\bf normally}]\ hd\ {\bf if}\ cond$ (4)

to refer to both strict and defeasible, authorization and obligation rules
from $\mathscr{P}$. We use the term head of rule $r$ to refer to the $hd$ part
in (4), where $hd\in HD$,

$HD=\bigcup\limits_{e\in E}\\{permitted(e),\neg permitted(e),obl(e),obl(\neg
e),\neg obl(e),\neg obl(\neg e)\\}$

and $E$ is the set of all elementary actions in $\mathscr{T}$. The signature
of $rei\\_lp(\mathscr{P})$ also includes the elements of $HD$ and the
following predicates:

  * •

$rule(r)$ – where $r$ is a rule label (referred shortly as “rule” below)

  * •

$type(r,ty)$ – where $ty\in\\{strict,$ defeasible, prefer$\\}$ is the type of
rule $r$

  * •

$text(r,t)$ – to denote that rule $r$ corresponds to policy statement $t$

  * •

$head(r,hd)$ – to denote the head $hd$ of rule $r$

  * •

$body(r,b(r))$ – where $b(r)$ denotes the condition $cond$ in rule $r$ and $b$
is a new function added to the signature of $rei\\_lp(\mathscr{P})$

  * •

$mbr(b(r),l)$ – for every $l$ in the condition $cond$ of rule $r$ ($mbr$
stands for “member”)

  * •

$ab(r)$ – for every defeasible rule $r$

  * •

$holds(x)$ – where $x$ may be a rule $r$, the head $hd$ of a rule, function
$b(r)$ representing the $cond$ of a rule $r$, literal $l$ of $\mathscr{T}$, or
$ab(r)$ from above

  * •

$opp(r,\overline{hd})$ – where $r$ is a defeasible rule and $\overline{hd}\in
HD$ ($opp$ stands for “opposite”)

  * •

prefer$(d_{1},d_{2})$ – where $d_{1}$ and $d_{2}$ are defeasible rule labels

The predicate $holds$ helps determine which policy rules are applicable, based
on what fluents are true/false in a state and the interactions between policy
rules. The predicate $opp(r,\overline{hd})$ indicates that $\overline{hd}$ is
the logical complement of $r$’s head $hd$.

The translation $rei\\_lp(\mathscr{P})$ consists of facts encoding the rules
in $\mathscr{P}$ using the predicates $rule$, $type$, $head$, $mbr$, and
prefer, as well as the set of policy-independent rules below, which define
predicates $holds$ and $opp$, where $L$ is a fluent literal, $E$ an elementary
action, and $H$ a happening (i.e., an elementary action or its negation).

$\begin{array}[]{lll}body(R,b(R))&\leftarrow&rule(R)\\\
holds(R)&\leftarrow&type(R,strict),holds(b(R))\\\
holds(R)&\leftarrow&type(R,defeasible),holds(b(R)),\\\ &&opp(R,O),\mbox{not
}holds(O),\mbox{not }holds(ab(R))\\\
holds(B)&\leftarrow&body(R,B),N=\\#count\\{L:mbr(B,L)\\},\\\
&&N=\\#count\\{L:mbr(B,L),holds(L)\\}\\\
holds(ab(R2))&\leftarrow&\mbox{{prefer}}(R1,R2),holds(b(R1))\\\
holds(Hd)&\leftarrow&rule(R),holds(R),head(R,Hd)\\\
opp(R,permitted(E))&\leftarrow&head(R,\neg permitted(E))\\\ opp(R,\neg
permitted(E))&\leftarrow&head(R,permitted(E))\\\
opp(R,obl(H))&\leftarrow&head(R,\neg obl(H))\\\ opp(R,\neg
obl(H))&\leftarrow&head(R,obl(H))\end{array}$

######  Definition 7 (Reified ASP Translation of a Policy and State)

Given a state $\sigma$ of $\mathscr{T}$, $rei\\_lp(\mathscr{P},\sigma)$
$=_{def}$ $rei\\_lp(\mathscr{P})$ $\cup\ \\{holds(l):l\in\sigma\ \\}$.

This definition will be used in conducting various policy analysis tasks in
Section 5.

######  Proposition 1 (Relationship between the Original and Reified ASP
Translations)

Given a state $\sigma$ of $\mathscr{T}$, there is a one-to-one correspondence
$map:{\cal A}\rightarrow{\cal B}$ between the collection of answer sets ${\cal
A}$ of $lp(\mathscr{P},\sigma)$ and the collection of answer sets ${\cal B}$
of $rei\\_lp(\mathscr{P},\sigma)$ such that if $map(A)=B$ then $\forall hd\in
HD\cap A,\exists holds(hd)\in B$.

##  5 Policy Analysis

In what follows, we assume that the $cond$ part of a policy rule cannot
include atoms from the set $HD$ (i.e., atoms obtained from predicates
$permitted$ and $obl$). We plan to consider more general policies in future
work. Lifting this restriction complicates the task of finding explanations
beyond the goal of the current work.

###  5.1 Analyzing Authorization Policies

Our goal in analyzing policies is to assist a policy author in refining their
policies by indicating to them the rules that cause concern. Thus, when
analyzing an authorization policy $\mathscr{P}$ with respect to an elementary
action $e$ in a state $\sigma$, we focus on the tasks:

  * •

Explain the causes of inconsistencies – determining the rules that cause a
policy to derive both $holds(permitted(e))$ and $holds(\neg permitted(e))$
when using the $rei\\_lp$ translation

  * •

Detect and explain underspecification – determining whether rules about $e$
exist or not, and, if they exist, explain why they do not fire. (Craven et al.
2009 call this situation coverage gaps.)

  * •

Detect and explain ambiguity – determining whether there are conflicting
defeasible rules that produce $holds(permitted(e))$ in some answer sets and
$holds(\neg permitted(e))$ in others, and indicating which rules these are.

####  5.1.1 Inconsistency

To detect and explain inconsistencies with respect to an elementary action $e$
and state $\sigma$ we introduce the following predicates:

  * •

$inconsistency(e,r_{1},r_{2})$ – indicates that the pair of rules $r_{1}$ and
$r_{2}$ both fire and cause the inconsistency; $r_{1}$ produces $permitted(e)$
and $r_{2}$ produces $\neg permitted(e)$

  * •

$inconsistency\\_expl(e,t_{1},t_{2})$ – does the same but indicates the
natural language texts of the corresponding policy statements

  * •

$inconsistency\\_expl\\_pos(e,l)$ – indicates that $l$ is a fluent/static that
holds in $\sigma$ and contributes to the inconsistency in a rule that produces
$permitted(e)$

  * •

$inconsistency\\_expl\\_neg(e,l)$ – similar to the previous predicate, but for
rules that produce $\neg permitted(e)$

We define a logic program I consisting of the rules below:

$\begin{array}[]{lll}inconsistency(E,R1,R2)&\leftarrow&holds(permitted(E)),holds(\neg
permitted(E)),\\\ &&holds(R1),head(R1,permitted(E)),\\\
&&holds(R2),head(R2,\neg permitted(E))\end{array}$
$\begin{array}[]{lll}inconsistency\\_expl(E,T1,T2)&\leftarrow&inconsistency(E,R1,R2),\\\
&&text(R1,T1),text(R2,T2)\\\
inconsistency\\_expl\\_pos(E,L)&\leftarrow&inconsistency(E,R1,\\_),head(R1,permitted(E)),\\\
&&mbr(b(R1),L),holds(L)\\\
inconsistency\\_expl\\_neg(E,L)&\leftarrow&inconsistency(E,\\_,R2),head(R2,\neg
permitted(E)),\\\ &&mbr(b(R2),L),holds(L)\end{array}$

We restate Definition 3 in terms of the $rei\\_lp(\mathscr{P},\sigma)$
translation.

######  Definition 8 (Inconsistency Redefined)

An authorization policy $\mathscr{P}$ is inconsistent with respect to an
elementary action $e$ and a state $\sigma$ if the answer set of
$rei\\_lp(\mathscr{P},\sigma)$ $\cup$ I contains
$inconsistency(e,r_{1},r_{2})$ for a pair of rules $r_{1}$ and $r_{2}$.

######  Definition 9 (Explaining the Causes of Inconsistency)

$\bullet\ $ An explanation for the inconsistency of $e$ in $\sigma$ is the set
of pairs of strings

$\\{(t_{1},t_{2}):inconsistency\\_expl(e,t_{1},t_{2})\in$
$rei\\_lp(\mathscr{P},\sigma)$ $\cup$ I$\\}$.

$\bullet\ $ A fluent literal $l$ contributes positively (or negatively) to the
inconsistency of $e$ in $\sigma$ if the answer set of
$rei\\_lp(\mathscr{P},\sigma)$ $\cup$ I contains
$inconsistency\\_expl\\_pos(e,l)$ (or $inconsistency\\_expl\\_neg(e,l)$,
respectively).

The collection of atoms identified in Definition 9 can be collected from the
answer set of $rei\\_lp(\mathscr{P},\sigma)$ $\cup$ I and post-processed to
provide more human-friendly output.

####  5.1.2 Underspecification

We define the notion of underspecification of an elementary action $e$ in a
state $\sigma$ as the lack of explicit information as to whether $e$ is
permitted or not permitted in that state, similar to the concept of coverage
gap defined by Craven et al. 2009. Note that underspecification is different
from non-categoricity, where a policy may be ambiguous because $e$ is deemed
permitted in some answer sets and not permitted in others.

######  Definition 10 (Categoricity and Underspecification of an Action in a
State)

A consistent authorization policy $\mathscr{P}$ is categorical with respect to
an elementary action $e$ and state $\sigma$ if one of the following cases is
true:

  1. 1.

$rei\\_lp(\mathscr{P},\sigma)$ entails $holds(permitted(e))$, or

  2. 2.

$rei\\_lp(\mathscr{P},\sigma)$ entails $holds(\neg permitted(e))$, or

  3. 3.

For every answer set $S$ of $rei\\_lp(\mathscr{P},\sigma)$,

$\\{holds(permitted(e)),holds(\neg permitted(e))\\}\cap\ S=\emptyset$

In this last case, we say that $e$ is underspecified in state $\sigma$.

Underspecification is important because it may reflect an oversight from the
policy author. If it’s unintended, it can have negative consequences in
planning domains for example, when an agent may want to choose the most
compliant plan and thus actions that are mistakenly underspecified may never
be selected. To test whether an action $e$ is underspecified in a state, we
define the set of rules $Check_{und}(e)$ consisting of the set of constraints:

$\begin{array}[]{ll}\\{&\leftarrow holds(permitted(e)),\\\ &\leftarrow\
holds(\neg permitted(e))\ \ \\}\end{array}$

######  Definition 11 (Detecting Underspecification)

Action $e$ is underspecified in $\sigma$ if the logic program
$lp(\mathscr{P},\sigma)\cup Check_{und}(e)$ is consistent.

Whenever an elementary action is underspecified in a state, there may be two
explanations: (Case 1) the authorization policy contains no rules about $e$,
or (Case 2) rules about $e$ exist in the policy but none of them apply in
state $\sigma$. Once we establish that an elementary action is underspecified,
we want to explain to the policy author why that is the case. For the first
case, we just want to inform the policy author about the situation. In the
second case, we want to report, for each authorization rule about $e$, which
fluents make the rule non-applicable. Note that a defeasible rule $r$ with
head $hd$ (see (4)) cannot be made unapplicable by the complement
$\overline{hd}$, as the complement is underivable as well in an underspecified
policy. Similarly, a preference rule cannot disable a defeasible rule either,
as this can only be the case when the complement $\overline{hd}$ can be
inferred.

Let U be the logic program

$\begin{array}[]{lll}rules\\_exist(E)&\leftarrow&head(R,\ permitted(E);\neg
permitted(E))\\\ underspec\\_1(E)&\leftarrow&\mbox{not }rules\\_exist(E)\\\
underspec\\_1\\_expl(\mbox{``Case 1"},E)&\leftarrow&underspec\\_1(E)\\\
underspec\\_2(E)&\leftarrow&rules\\_exist(E)\\\
underspec\\_2(E,R,L)&\leftarrow&underspec\\_2(E),rule(R),\\\ &&head(R,\
permitted(E);\neg permitted(E)),\\\ &&mbr(b(R),L),\\\ &&\mbox{not }holds(L)\\\
underspec\\_2\\_expl(\mbox{``Case
2"},E,R,L,T)&\leftarrow&underspec\\_2(E,R,L),\\\ &&text(R,T)\end{array}$

######  Definition 12 (Explaining the Causes of Underspecification)

An explanation for the underspecification of $e$ in $\sigma$ is the set of
atoms formed by predicates $underspec\\_1\\_expl$ and $underspec\\_2\\_expl$
found in the answer set of $rei\\_lp(\mathscr{P},\sigma)$ $\cup$ U.

For a more human-friendly explanation, an atom
$underspec\\_1\\_expl(\mbox{``Case 1"},e)$ in the answer set can be replaced
with an explanation of the form “There are no authorization rules about $e$”
in the post-processing phase. A collection of atoms of the form

$\\{underspec\\_2\\_expl(\mbox{``Case
2"},e,r,l_{1},t),\dots,underspec\\_2\\_expl(\mbox{``Case 2"},e,r,l_{n},t)\\}$

can be replaced with the explanation “Rule $r$ about action $e$ (stating that
“$t$”) is rendered inapplicable by the fact that fluent(s) $l_{1},\dots,l_{n}$
do not hold in this state.”

####  5.1.3 Ambiguity

We define ambiguity as the case when the policy allows a choice between
$permitted(e)$ and $\neg permitted(e)$. This notion of ambiguity overlaps with
that of a non-categorical policy. However, given our assumption that
$permitted$ atoms are not included in the condition $cond$ of policy rules,
ambiguity is a much more specific case. We claim that, if $\mathscr{P}$ is a
consistent, non-categorical policy with respect to $e$ in $\sigma$ (see
Definition 10), then $holds(permitted(e))$ will be in some answer sets of
$rei\\_lp(\mathscr{P},\sigma)$ and $holds(\neg permitted(e))$ will be in
others, but it cannot be the case that an answer set does not contain
either.555Note that, if we lift our restriction and allow $cond$ to contain
$permitted$ (or $obl$) atoms, then for a weakly compliant action $e$, there
can be a combination of answer sets containing $holds(permitted(e))$ and
answer sets not containing neither $holds(permitted(e))$ nor $holds(\neg
permitted(e))$, if $cond$ contains a $permitted(e_{1})$ atom such that $e_{1}$
is an action that is ambiguous in $\sigma$.

The justification is that the body $cond$ of policy rules is fully determined
by the unique values of fluents in $\sigma$. Hence, strict rules either fire
or do not. If a strict ruled fired, it would automatically override the
defeasible rules with the complementary head, and thus lead either to
inconsistency (depending on which other strict rules fire) or categoricity.
The only source of non-categoricity can be the presence of defeasible rules
with complementary heads and satisfied conditions, and which are not overriden
by preference rules.

######  Definition 13 (Ambiguity of an Action in a State)

Let $\mathscr{P}$ be a policy that is consistent and non-categorical with
respect to elementary action $e$ and state $\sigma$. Let
$rei\\_lp(\mathscr{P},\sigma)$ have $n$ answer sets, out of which $n_{p}$
answer sets contain $holds(permitted(e))$ and $n_{np}$ contain $holds(\neg
permitted(e))$.

$\mathscr{P}$ is ambiguous with respect to $e$ and $\sigma$ if $n\neq n_{p}$,
$n\neq n_{np}$ and $n=n_{p}+n_{np}$.

Next, let’s describe how we detect ambiguity.

######  Definition 14 (Detecting Ambiguity)

Action $e$ is ambiguous in $\sigma$ if $holds(permitted(e))$ and $holds(\neg
permitted(e))$ are not entailed by $rei\\_lp(\mathscr{P},\sigma)$ and $e$ is
not underspecified in $\sigma$.

Once ambiguity is established, an explanation for ambiguity is needed. To
produce it, we define the logic program A consisting of the rules:

$\begin{array}[]{lll}ambiguous(E,R1,R2)&\leftarrow&defeasible\\_rule(R1),head(R1,permitted(E)),\\\
&&defeasible\\_rule(R2),head(R2,\neg permitted(E)),\\\
&&holds(b(R1)),holds(b(R2)),\\\ &&\mbox{not }holds(ab(R1)),\mbox{not
}holds(ab(R2))\\\
ambiguity\\_expl(E,T1,T2)&\leftarrow&ambiguous(E,R1,R2),text(R1,T2),text(R2,T2)\\\
\end{array}$

######  Definition 15 (Explaining the Causes of Ambiguity)

An explanation for the ambiguity of $e$ in $\sigma$ is the set of pairs of
strings:

$\\{(t_{1},t_{2}):ambiguity\\_expl(e,t_{1},t_{2})\in
rei\\_lp(\mathscr{P},\sigma)\cup\mbox{ {A}}\\}$

####  5.1.4 Observation about Strongly vs Weakly Compliant Policies

Gelfond and Lobo distinguish between actions that are strongly compliant in a
state versus weakly compliant (see Definition 4). In planning, as shown by
Meyer and Inclezan 2021, it seems reasonable to prefer strongly compliant
actions over weakly compliant ones. However, in the theorem below we show that
the class of weakly compliant actions includes strongly compliant ones. What
we really need for planning purposes is distinguishing between strongly
compliant and underspecified actions in a state, so that we can create a
preference order between actions.

######  Theorem 1 (Strongly vs Weakly Compliant Actions)

All elementary actions that are strongly compliant in a state $\sigma$ are
also weakly compliant.

######  Proof 5.2.

Note that, in this proof, we consider the original $lp$ translation of
$\mathscr{AOPL}$, which is equivalent with, but more convenient to use here
than, the reified translation $rei\\_lp$ as stated in Proposition 1. According
to Definition 4 borrowed from Gelfond and Lobo’s work, elementary action $e$
is strongly compliant with authorization policy $\mathscr{P}$ if
$lp(\mathscr{P},\sigma)$ entails $permitted(e)$, and it is weakly compliant if
$lp(\mathscr{P},\sigma)$ does not entail $\neg permitted(e)$. For consistent
policies, the latter condition is obviously true if $e$ is strongly compliant
in $\sigma$, as having $permitted(e)$ in every answer set of
$lp(\mathscr{P},\sigma)$ implies that $\neg permitted(e)$ must be absent from
each such answer set. If the policy is inconsistent, the theorem is vacuously
true.

Given our assumption that $permitted$ (and $obl$) atoms cannot appear in the
$cond$ part of policy rules, an elementary action $e$ can only be either
strongly compliant in $\sigma$ or underspecified.666If this restriction is
lifted and the condition $cond$ of a policy rule for $e$ contains a
$permitted(e_{1})$ atom, such that $e_{1}$ is ambiguous, then $e$ may be a
weakly compliant action because it will be permitted in some answer sets and
unknown in others.

We formulate the following proposition, which is useful in creating an
ordering of actions based on compliance (relevant in planning).

######  Proposition 5.3 (Properties of Authorization Policies).

$\bullet\ $ If condition $cond$ of authorization rules is not allowed to
contain $permitted$ (or $obl$) atoms and $\mathscr{P}$ is categorical with
respect to $e$ and $\sigma$, then $e$ is either strongly compliant, non-
compliant, or underspecified in $\sigma$.

$\bullet\ $ If condition $cond$ of authorization rules is not allowed to
contain $permitted$ (or $obl$) atoms and $\mathscr{P}$ is non-categorical with
respect to $e$ and $\sigma$, then $e$ is neither strongly compliant nor non-
compliant; it may be either underspecified or ambiguous.

###  5.2 Obligation Policy Analysis

The techniques from Section 5.1 for determining rules that create
inconsistencies, underspecification, and ambiguity with respect to an
elementary action and a state can be easily adapted to obligation policies as
well. Obligation policies apply to happenings, which are actions or their
negations. For instance, given an elementary action $e$, the following
literals are part of the signature of the policy: $obl(e)$, $obl(\neg e)$,
$\neg obl(e)$, and $\neg obl(\neg e)$. Inconsistencies between $obl(e)$ and
$\neg obl(e)$ on one hand, or between $obl(\neg e)$ and $\neg obl(\neg e)$ are
easy to detect. However, there are additional incongruencies that may decrease
the quality of a policy, and we may want to alert the policy writer about them
as well.

For instance, if a policy $\mathscr{P}$ entails both $obl(e)$ and $obl(\neg
e)$ in a state $\sigma$, then any event $\langle\sigma,a\rangle$ will be non-
compliant, no matter whether $e\in a$ or $e\notin a$. In actuality, it means
that the policy does not allow for the agent to be compliant with respect to
obligations in state $\sigma$. Thus the notions of inconsistency and ambiguity
should be adapted or expanded to include this situation. We propose the
following definition:

######  Definition 5.4 (Conflicting Policy).

Given a consistent obligation policy $\mathscr{P}$, a state $\sigma$ and an
elementary action $e$, we call $\mathscr{P}$ a conflicting obligation policy
with respect to $\sigma$ and $e$ if the logic program
$rei\\_lp(\mathscr{P},\sigma)$ entails both $holds(obl(e))$ and
$holds(obl(\neg e))$.

Explanations for conflicting obligation policies can be found using techniques
similar to the ones in Section 5.1.

###  5.3 The Intersection between Authorization and Obligation Policies

When combining an authorization policy with an obligation policy, there are a
few cases that, while not necessarily inconsistent, certainly seem to require
non-compliant behavior from the agent. This is especially the case when an
event $\langle\sigma,e\rangle$ is strongly-compliant with the obligation
policy but non-compliant with the authorization policy (i.e., in terms of the
original translation $lp$ of $\mathscr{AOPL}$ into ASP,
$lp(\mathscr{P},\sigma)$ entails both $obl(e)$ and $\neg permitted(e)$
according to Definitions 5 and 4). Other situations that may require the
policy authors’ attention, though to a lesser degree, are when an action is
permitted but the agent is obligated not to execute it (i.e.,
$lp(\mathscr{P},\sigma)$ entails both $permitted(e)$ and $obl(\neg e)$) or
when the agent is obligated to execute an action that is underspecified in
that state. We indicate the level of urgency of each of these situations by
adding a number from 1 to 3, with 1 being the most needing of re-consideration
and 3 being the least urgent.

Once it has been established that the policies are strongly compliant, non-
compliant, or underspecified with respect to the state and elementary action,
the following ASP rules determine which policy rules need to be re-visited.

$\begin{array}[]{lll}require\\_cons(E,R1,R2,1)&\leftarrow&holds(R1),head(R1,obl(E)),\\\
&&holds(R2),head(R2,\neg permitted(E))\\\
require\\_cons(E,R1,R2,2)&\leftarrow&holds(R1),head(R1,obl(\neg E)),\\\
&&holds(R2),head(R2,permitted(E))\\\
require\\_cons(E,R1,R2,3)&\leftarrow&holds(R1),head(R1,obl(E)),\\\ &&\mbox{not
}holds(permitted(E)),\\\ &&\mbox{not }holds(\neg permitted(E))\\\
require\\_cons\\_expl(E,T1,T2,N)&\leftarrow&require\\_cons(E,R1,R2,N),\\\
&&text(R1,T1),text(R2,T2).\end{array}$

##  6 Related Work

Meyer and Inclezan 2021 developed an architecture for policy-aware intentional
agents ($\mathscr{APIA}$) by leveraging Blount et al.’s theory of intentions
2015. An agent’s behavior was ensured to be compliant with authorization and
obligation policies specified in $\mathscr{AOPL}$ and translated into ASP.
Meyer and Inclezan’s work first highlighted the issues that may arise at the
intersection between $\mathscr{AOPL}$ authorization and obligation and
policies. In the $\mathscr{APIA}$ architecture, conflicts of this nature were
resolved by modifying the policy’s ASP encoding to state that such conflicts
render a policy inconsistent. In the current work our intention is to alert
policy authors about such situations and provide them with the opportunity to
decide which policy statements to modify in order to restore consistency.
Additionally, in the current work we delve deeper into the tasks associated
with policy analysis and look at underspecification and ambiguity as well. We
also focus on providing explanations as to why such issues arise.

Craven et al.’s work 2009 is the closest to ours in its intent. The authors
define language $\mathscr{L}$ for policy specification and include both
authorization and obligation policies. They define a solid set of tasks that
an automated analysis of a policy should accomplish, such as discovering
modality conflicts and coverage gaps, which we target in our work as well.
Their research assumes that the underlying dynamic domain is specified in
Event Calculus Kowalski and Sergot (1989). Explanations are found via an
abductive constraint logic programming proof procedure. Given the absence of a
comparison between languages $\mathscr{L}$ and $\mathscr{AOPL}$, it is
important to study the problem of policy analysis with respect to language
$\mathscr{AOPL}$ as well. $\mathscr{AOPL}$ has clear advantages, including its
ability to express defeasible policies and preferences between policies.
Moreover, $\mathscr{AOPL}$ can be seamlessly integrated with ASP-based dynamic
system descriptions, as different properties of $\mathscr{AOPL}$ policies can
be checked by finding the answer sets of an ASP program. This would allow
coupling policies with system descriptions specified in higher-level action
languages that translate into ASP, such as the modular action language
$\mathscr{ALM}$ Inclezan and Gelfond (2016), and associated libraries about
action and change Inclezan (2016, 2019).

Other research on policy modeling or analysis using ASP exists, but the goals
tend to be different from ours. Corapi et al. 2011 use inductive logic
programming and software engineering-inspired processes to assist policy
authors with policy refinement. In their work, refinement suggestions are
provided, but this process is driven by use cases that need to be manually
created. As a result, the quality of the resulting policy depends on the
quality and coverage of the use cases that are provided as an input. In turn,
our approach is meant to be more comprehensive and transparent, as it is
guided by the policy rules themselves. Another work that uses ASP for policy
modeling is that of De Vos et al. 2019. Their work encompasses the same types
of policies as $\mathscr{AOPL}$, but their focus is on compliance checking and
providing explanations for the compliance or non-compliance of events. In
contrast, we focus on policy analysis, not compliance checking; our
explanations highlight potential problems with a policy and indicate
statements that need to be refined. Pellegrini et al. 2019 present a framework
called DALICC for comparing and resolving compatibility issues with licenses.
The goal of their framework is more narrow than ours in the sense that it only
focuses on licences and not normative statements in general. For a survey on
other policy analysis methods and tools, not necessarily ASP-related, we
direct the reader to the paper by Jabal et al. 2019.

In general, in the policy specification and analysis community, there is a
intense focus on access control policies, which may involve the Role-Based
Access Control (RBAC) model outlined by Ferraiolo et al. 2001; the Attribute-
Based Access Control Model (ABAC) explored for instance by Davari and
Zulkernine 2021 and Xu et al. 2016; or the Category-based Access Control Model
explored by Alves and Fernández 2014. A secondary focus falls on policies for
the management of computer systems. In contrast, $\mathscr{AOPL}$ is more
general and could be used to represent social norms, for example.

Finally, our work touches upon explainability and finding the causes of issues
encountered in $\mathscr{AOPL}$ policies. To find even deeper causes that
reside in the inner-workings of the dynamic system, we can leverage existing
work on explainability in reasoning about action and change, such as the
research by LeBlanc et al. 2019; planning domains, as in the work by Vasileiou
et al. 2022; or logic programming in general, including research by Fandinno
and Schultz 2019 or Cabalar et al. 2020.

##  7 Conclusions

In this paper we introduced a framework for analyzing policies described in
the language $\mathscr{AOPL}$ with respect to inconsistencies,
underspecification, ambiguity, and modality conflict. We reified policy rules
in order to detect which policy statements cause the particular issue and (if
relevant), which fluents of the domain contribute to such problems. In doing
so, we defined new properties of $\mathscr{AOPL}$ policies and took a special
look at what happens at the intersection of authorization and obligation
policies.

As part of future work, we plan to create a system that implements this
framework in a way that is user-friendly for policy writers and knowledge
engineers. We also intend to extend the framework by lifting some of the
simplifying restrictions that we imposed here, for instance by studying the
case when there is incomplete information about a state or allowing
$permitted$ and $obl$ atoms in the conditions of policy rules.

## References

  * Alves and Fernández (2014) Alves, S. and Fernández, M. 2014\.  A framework for the analysis of access control policies with emergency management.  In Ninth Workshop on Logical and Semantic Frameworks, with Applications, LSFA 2014, Brasília, Brazil, September 8-9, 2014, M. Ayala-Rincón and I. Mackie, Eds. Electronic Notes in Theoretical Computer Science, vol. 312. Elsevier, 89–105.
  * Balduccini et al. (2020) Balduccini, M., Gelfond, M., Pontelli, E., and Son, T. C. 2020\.  An Answer Set Programming Framework for Reasoning about Agents’ Beliefs and Truthfulness of Statements.  In Proceedings of the 17th International Conference on Principles of Knowledge Representation and Reasoning. 69–78.
  * Blount et al. (2015) Blount, J., Gelfond, M., and Balduccini, M. 2015\.  A theory of intentions for intelligent agents - (Extended Abstract).  In Proceedings of the 13th International Conference on Logic Programming and Nonmonotonic Reasoning. LNCS, vol. 9345. Springer, 134–142.
  * Cabalar et al. (2020) Cabalar, P., Fandinno, J., and Muñiz, B. 2020\.  A system for explainable answer set programming.  In Proceedings 36th International Conference on Logic Programming (Technical Communications). EPTCS, vol. 325. 124–136.
  * Corapi et al. (2011) Corapi, D., Russo, A., De Vos, M., Padget, J., and Satoh, K. 2011\.  Normative design using inductive learning.  Theory and Practice of Logic Programming 11, 4-5, 783–799.
  * Craven et al. (2009) Craven, R., Lobo, J., Ma, J., Russo, A., Lupu, E., and Bandara, A. 2009\.  Expressive policy analysis with enhanced system dynamicity.  In Proceedings of the 4th International Symposium on Information, Computer, and Communications Security. Association for Computing Machinery, New York, NY, USA, 239–250.
  * Davari and Zulkernine (2021) Davari, M. and Zulkernine, M. 2021\.  Policy modeling and anomaly detection in ABAC policies.  In Risks and Security of Internet and Systems: 16th International Conference, CRiSIS 2021. Springer-Verlag, Berlin, Heidelberg, 137–152.
  * De Vos et al. (2019) De Vos, M., Kirrane, S., Padget, J., and Satoh, K. 2019\.  ODRL policy modelling and compliance checking.  In Rules and Reasoning, P. Fodor, M. Montali, D. Calvanese, and D. Roman, Eds. Springer International Publishing, Cham, 36–51.
  * Fandinno and Schulz (2019) Fandinno, J. and Schulz, C. 2019\.  Answering the “why” in answer set programming - A survey of explanation approaches.  Theory Pract. Log. Program. 19, 2, 114–203.
  * Ferraiolo et al. (2001) Ferraiolo, D. F., Sandhu, R., Gavrila, S., Kuhn, D. R., and Chandramouli, R. 2001\.  Proposed NIST standard for role-based access control.  ACM Trans. Inf. Syst. Secur. 4, 3 (aug), 224–274.
  * Gelfond and Inclezan (2013) Gelfond, M. and Inclezan, D. 2013\.  Some properties of system descriptions of ALd.  J. Appl. Non Class. Logics 23, 1-2, 105–120.
  * Gelfond and Kahl (2014) Gelfond, M. and Kahl, Y. 2014\.  Knowledge Representation, Reasoning, and the Design of Intelligent Agents.  Cambridge University Press.
  * Gelfond and Lifschitz (1991) Gelfond, M. and Lifschitz, V. 1991\.  Classical Negation in Logic Programs and Disjunctive Databases.  New Generation Computing 9, 3/4, 365–386.
  * Gelfond and Lobo (2008) Gelfond, M. and Lobo, J. 2008\.  Authorization and Obligation Policies in Dynamic Systems.  In Logic Programming, M. Garcia de la Banda and E. Pontelli, Eds. Lecture Notes in Computer Science. Springer, Berlin, Heidelberg, 22–36.
  * Gelfond and Son (1997) Gelfond, M. and Son, T. C. 1997\.  Reasoning with prioritized defaults.  In Third International Workshop on Logic Programming and Knowledge Representation, Third International Workshop. LNCS, vol. 1471. Springer, 164–223.
  * Inclezan (2016) Inclezan, D. 2016\.  CoreALMlib: An ALM library translated from the component library.  Theory and Practice of Logic Programming 16, 5-6, 800–816.
  * Inclezan (2019) Inclezan, D. 2019\.  RestKB: A library of commonsense knowledge about dining at a restaurant.  In Proceedings 35th International Conference on Logic Programming (Technical Communications), ICLP 2019 Technical Communications, Las Cruces, NM, USA, September 20-25, 2019. EPTCS, vol. 306. 126–139.
  * Inclezan and Gelfond (2016) Inclezan, D. and Gelfond, M. 2016\.  Modular action language ALM.  Theory and Practice of Logic Programming 16, 2, 189–235.
  * Jabal et al. (2019) Jabal, A. A., Davari, M., Bertino, E., Makaya, C., Calo, S., Verma, D., Russo, A., and Williams, C. 2019\.  Methods and tools for policy analysis.  ACM Comput. Surv. 51, 6 (feb).
  * Kowalski and Sergot (1989) Kowalski, R. and Sergot, M. 1989\.  A Logic-Based Calculus of Events.  Springer Berlin Heidelberg, Berlin, Heidelberg, 23–55.
  * LeBlanc et al. (2019) LeBlanc, E. C., Balduccini, M., and Vennekens, J. 2019\.  Explaining actual causation via reasoning about actions and change.  In Proceedings of the 16th European Conference on Logics in Artificial Intelligence, JELIA. LNCS, vol. 11468. Springer, 231–246.
  * Marek and Truszczynski (1999) Marek, V. W. and Truszczynski, M. 1999\.  Stable models and an alternative logic programming paradigm.  In The Logic Programming Paradigm - A 25-Year Perspective, K. R. Apt, V. W. Marek, M. Truszczynski, and D. S. Warren, Eds. Artificial Intelligence. Springer, 375–398.
  * Meyer and Inclezan (2021) Meyer, J. and Inclezan, D. 2021\.  APIA: an architecture for policy-aware intentional agents.  In Proceedings of the 37th International Conference on Logic Programming (Technical Communications). EPTCS, vol. 345. 84–98.
  * Pellegrini et al. (2019) Pellegrini, T., Havur, G., Steyskal, S., Panasiuk, O., Fensel, A., Mireles-Chavez, V., Thurner, T., Polleres, A., Kirrane, S., and Schönhofer, A. 2019\.  DALICC: A license management framework for digital assets.
  * Vasileiou et al. (2022) Vasileiou, S. L., Yeoh, W., Son, T. C., Kumar, A., Cashmore, M., and Magazzeni, D. 2022\.  A logic-based explanation generation framework for classical and hybrid planning problems.  J. Artif. Intell. Res. 73, 1473–1534.
  * Xu et al. (2016) Xu, D., Wang, Z., Peng, S., and Shen, N. 2016\.  Automated fault localization of XACML policies.  In Proceedings of the 21st ACM on Symposium on Access Control Models and Technologies. SACMAT ’16. Association for Computing Machinery, New York, NY, USA, 137–147.