% EPTCS Style distribution v1.7.0 released May 23, 2022. % https://github.com/EPTCS/style \documentclass[submission,copyright,creativecommons]{eptcs} \providecommand{\event}{40th International Conference on Logic Programming - ICLP 2024} % Name of the event you are submitting to \usepackage{iftex} %\usepackage{graphicx} \usepackage{graphicx} \newcommand{\cfs}{\mathcal{CS}} \newtheorem{postulate}{Postulate} \newtheorem{definition}{Definition} %\newtheorem{corollary}{Corollary} \newtheorem{lemma}{Lemma} \newtheorem{example}{Example} %\newtheorem{theorem}{Theorem} % \newcommand{\wrt}{{\it w.r.t.} } % with respect to \newcommand{\eg}{\emph{e.g.}, } % for example \newcommand{\ie}{\emph{i.e.}, } % that is \newcommand{\etal}{\emph{et al.}} % and others \newcommand\etc{\emph{etc}} \newcommand{\sem}{\texttt{SEM}} \newcommand{\HEAD}{\texttt{HEAD}} \newcommand{\CONC}{\texttt{CONC}} \newcommand{\SUPP}{\texttt{SUPP}} \newcommand{\SUB}{\texttt{SUB}} \newcommand{\WFS}{\texttt{WFS} } \newcommand{\STABLE}{\texttt{STABLE}} \newcommand{\REL}{\texttt{REL}} \newcommand{\MIN}{\texttt{MIN}} \newcommand{\attacks}{\texttt{attacks} } %\renewcommand{\algorithmiccomment}[1]{\texttt{\hspace{1.7cm}// #1}} \ifpdf \usepackage{underscore} % Only needed if you use pdflatex. \usepackage[T1]{fontenc} % Recommended with pdflatex \else \usepackage{breakurl} % Not needed if you use pdflatex only. \fi \title{Semantic Argumentation using Rewriting Systems} \author{Esteban Guerrero \institute{Department of Computing Science, Ume\aa{} University, Sweden} \email{esteban.guerrero@umu.se} \and Juan Carlos Nieves \institute{Department of Computing Science, Ume\aa{} University, Sweden} \email{juan.carlos.nieves@umu.se} } \def\titlerunning{Semantic argumentation} \def\authorrunning{E. Guerrero, J.C. Nieves} \begin{document} \maketitle \begin{abstract} In this article, we introduce a general framework for \textit{structured argumentation} providing consistent and well-defined \textit{justification} for conclusions that \textit{can} and \textit{cannot} be inferred and there is certainty about them, which we call semantic and NAF-arguments, respectively. We propose the so-called \textit{semantic argumentation} guaranteeing well-known principles for quality in structured argumentation, with the ability to generate semantic and NAF-arguments, those where the \textit{conclusion} atoms are semantically interpreted as \textit{true}, and those where the conclusion is assumed to be \textit{false}. This framework is defined on the set of all logic programs in terms of \textit{rewriting systems} based on a \textit{confluent set} of \textit{transformation rules}, the so-called \textit{Confluent Logic Programming Systems}, making this approach a general framework. We implement our framework named \textit{semantic argumentation solver} available open source. \end{abstract} %#################### SECTION ##################################### \section{Motivation}\label{sec:Introduction} %\todo[inline]{NAF as \textit{defeasible} } We propose a general argument construction based on the partial interpretation of programs using different \textit{families} of \textit{logic programming semantics } induced by \textit{rewriting systems} \textit{functions} \cite{dix2001general}. \textit{Rewriting rules} are used to replace parts of a logic program based on the concept of a \textit{normal form}, which is the least expression of a program that cannot be rewritten any further \cite{nieves2016ideal}. %\begin{mdframed}[hidealllines=true,backgroundcolor=yellow!20] %In the \textit{formal argumentation} literature, most of the proposed \textit{structured argumentation} approaches focused on building arguments where the set of rules defining the \textit{support} of an \textit{argument} have a proven deductive relationship with the argument's \textit{conclusion}, which can be obtained with approaches where the argument's support is interpreted through a \textit{logic programming semantics} (\eg WFS \cite{VanGelder:1991:WSG:116825.116838} or Stable~\cite{gelfond1991classical}) {and the conclusion belongs to the set of atoms interpreted as \textit{true}} \cite{guerrero2015semantic}. For example, having a program with the only rule: $innocent(x)$ $\leftarrow \ not\ guilty(x)$, current structured argumentation approaches \cite{prakken2010abstract} generate the only consistent argument: {$\langle \underbrace{\{ \emph{innocent(X)} \leftarrow \ not \ \emph{guilty(x)} \}}_{Support}, \ \underbrace{\emph{innocent(x)}}_{Conclusion} \rangle$, expressing that person $x$ is innocent if $x$ can not be proved guilty}. However, in domain applications that need the generation of argument-based \textit{reason explanations}, {providing structured and well-defined reasons why $x$ is not guilty ($not \ guilty(x)$) are needed.} We emphasize the role of investigating such computational mechanisms that can also build arguments justifying conclusions based on the atoms that are inferred as \textit{false}, \eg to state that \textit{there is \underline{certainty} in affirming that the guiltiness of $x$ is false (there is no evidence), therefore the $x$ must be innocent}, \ie {$\langle \underbrace{\{ \emph{innocent(X)} \leftarrow \ not \ \emph{guilty(x)} \}}_{Support}, \ \underbrace{not \ \emph{guilty(x)}}_{Conclusion} \rangle$}. These types of arguments have been less explored in the formal argumentation theory, except for \textit{assumption-based argumentation} (ABA) \cite{DungKT09}. %The rest of this article is structured as follows, in Section \ref{sec:background} we provide a short introduction to normal logic programs and three-valued logic programming semantics that are characterized in terms of rewriting systems, then in Section \ref{sec:wfs-argumentation}, we introduce our approach for building argumentation systems by considering three valued-logic semantics. In Section \ref{sec:related-work}, we discuss our contributions contrasted with the state-of-the-art. Finally, we summarize our results in Section \ref{sec:conclusions}. % \begin{center} % \begin{tikzpicture}[thick,scale=1, every node/.style={scale=0.8,shape=rounded rectangle,draw=black!80}] % \begin{scope}[] % % \node (A11) at (3.6,0) {}; % \node (Ajn) at (7,0) {$A_{i}^{-}=\langle \{\textnormal{take a taxi} \leftarrow not \ \textnormal{coming bus}\}, \; not \ \textnormal{take a taxi} \rangle$}; % \node (Ajp) at (0,0) {$A_{i}^{+}=\langle \{\textnormal{coming bus} \leftarrow not \ \textnormal{take a taxi}\}, \; \textnormal{coming bus} \rangle$}; % \node (Ain) at (7,2) {$A_{j}^{-}=\langle \{\textnormal{coming bus} \leftarrow not \ \textnormal{take a taxi}\}, \; not \ \textnormal{coming bus} \rangle$}; % \node (Aip) at (0,2) {$A_{j}^{+}=\langle \{\textnormal{take a taxi} \leftarrow not \ \textnormal{coming bus}\}, \; \textnormal{take a taxi} \rangle$}; % % \node (A31) at (1.3,2) {}; % % \node (A21) at (3.2,1) {}; % \end{scope} % % \begin{scope}[>={Stealth[red]}, % % every node/.style={fill=white,circle}, % every edge/.style={draw=red,very thick}] % % \path [->] (A) edge node {$5$} (B); % % \path [->] (B) edge node {$3$} (C); % % \path [->] (A) edge node {$4$} (D); % % \path [->] (D) edge node {$3$} (C); % % \path [->] (A) edge node {$3$} (E); % % \path [->] (D) edge node {$3$} (E); % % \path [->] (D) edge node {$3$} (F); % % \path [->] (C) edge node {$5$} (F); % % \path [->] (E) edge node {$8$} (F); % % \path [->] (A5p) edge[bend left=60] node [pos=0.5, above right] {} (A6p); % % \path [->] (A5p) edge[bend left=60] node [pos=0.5, above right] {} (A6n); % \end{scope} % \end{tikzpicture} % \end{center} %%%%%%%%%%%%%%%%%%%%%% %\section{RAW TEXT} % %Negative arguments help address uncertainty by explicitly stating what cannot be inferred due to missing or conflicting evidence. % %Positive arguments contribute to soundness by providing evidence for conclusions, but negative arguments are equally crucial for completeness. % %For instance, in legal contexts, proving innocence (a negative claim) is as crucial as proving guilt (a positive claim). % %Overreliance on positive arguments can lead to fallacies, such as affirming the consequent or hasty generalization. %Negative arguments act as safeguards against these fallacies. For instance, in the example you provided (a:- not b), the negative argument prevents hasty conclusions based solely on the absence of evidence for taking the bus. % % % %Formal argumentation frameworks traditionally emphasize constructing arguments that support a specific conclusion, often referred to as "positive arguments." This research, however, underscores the crucial role of investigating mechanisms that can also build arguments justifying "negative conclusions." These negative arguments, also known as arguments against a proposition, offer a more comprehensive understanding of the argumentative landscape. % %Consider the scenario of choosing between taking a bus (b) or a taxi (a). The rule a :- not b translates to "If there is no evidence of a bus coming, then take a taxi." This exemplifies a positive argument for taking a taxi under the absence of a bus. However, a complete analysis requires acknowledging the "negative" counterpart. % %Here's why negative arguments are essential in formal argumentation: % %Enriched Argument Landscape: Building negative arguments fosters a richer and more nuanced understanding of the available options. In the taxi/bus example, a negative argument could be not a :- b, meaning "If you are taking a bus, then you are not taking a taxi." This clarifies the mutually exclusive nature of the choices. % %Robustness and Undermining: Negative arguments expose potential weaknesses in positive arguments. For instance, an argument for taking a taxi (a) might be undermined by a negative argument highlighting limited taxi availability (not a :- c, where c represents "scarcity of taxis"). This promotes a more robust analysis by identifying potential counter-arguments. % %Addressing Uncertainty: Many real-world situations involve incomplete information. Negative arguments can highlight the limitations of positive arguments based on missing knowledge. In our example, the positive argument a :- not b doesn't guarantee a taxi's immediate availability (not a :- d, where d represents "long taxi wait time"). This emphasizes the need to consider uncertainties. % %Formalization and Reasoning: Integrating negative arguments into formal argumentation frameworks necessitates developing robust logics and reasoning mechanisms capable of handling both positive and negative justifications. This fosters the advancement of formal argumentation theory and its applicability to complex scenarios. % %The field of formal argumentation has primarily focused on positive arguments, overlooking the crucial role of negative arguments in capturing the full spectrum of reasoning processes. By emphasizing the construction of negative arguments, we pave the way for a more comprehensive, robust, and nuanced approach to formal argumentation. This aligns with the principles of rigorous analysis and comprehensive reasoning that are fundamental to various scientific disciplines. \vspace{-3mm} %#################### SECTION ##################################### \section{Syntax and semantics} \label{sec:background} \vspace{-2mm} %In this section, we present a short introduction to normal logic programs and three-valued logic semantics that are characterized by rewriting systems. %In this section, we introduce the logic programming and formal argumentation syntax used throughout the paper. %\noindent \textbf{Syntax} We use propositional logic with the following connectives $ \wedge,\leftarrow,\;not$, and $\top$ where $\wedge$, and $\leftarrow$ are 2-place connectives, $\;not$ and $ \top$. The negation symbol \emph{not} is regarded as the so-called \emph{negation as failure} (NAF). We follow standard logic programming syntax, \eg \cite{Dix95}, for lack of space we do not include some basic and well-established syntax. %A (propositional) normal clause, \emph{C}, is denoted as $a \leftarrow b_1 \wedge \dots \wedge b_j \wedge \emph{not }b_{j+1} \wedge \dots \wedge \emph{not }b_{j+n}$, where \emph{a} and each $ b_i $ ($1\leq i\leq j+n$) are atoms and $ j+n\geq 0$. We write a clause \emph{C} as $ a \leftarrow \mathcal{B}^{+} \wedge \emph{not } \mathcal{B}^{-}$, in which $\mathcal{B}^{+} := \{b_1,\dots,b_j\}$ and $\mathcal{B}^{-} := \{b_{j+1},\dots,b_{j+n}\}$. We call the \textit{body} of a clause, the set of atoms to the right of $\leftarrow$ of any clause; accordingly, we name the \textit{head} of a clause ($\HEAD(x)$) the atom to the left of $\leftarrow$. A \textit{logic program} \emph{P} is a finite set of normal clauses, and we denote the set of atoms that appear in \emph{P} as $\mathcal{L}_P$. %We use \textit{strong negation} following the Answer Set Programming literature \cite{baral2003knowledge}, where, each atom of the form $ \neg\;a$ is replaced by a new atom symbol $ a^{'}$ that does not appear in the language of the program. Then, a program without extended atoms will be called a \textit{normal logic program}. %Therefore, we can induce a normal logic program from an extended normal logic program by replacing each extended atom with a new symbol. For instance, let $ P$ be the program: $a \leftarrow q; \; \neg q \leftarrow r$, then, by replacing each extended atom with a new atom symbol, we will have: $ a \leftarrow q; \; q^{'} \leftarrow r$. In order not to allow inconsistent models of a logic program, usually a constraint of the form: $f \leftarrow q,\;q^{'}, \; not \; f$ is added, such that $f$ does not appear in the program. %We use the function $\REL(P,x)$ to determine the set of dependencies of an atom $x$ \wrt $P$, and we call those clauses \textit{related}. The notion of \emph{dependency} says that $a$ \textbf{depends immediately on} $b$ if and only if $b$ appears in the body of a clause in $P$, such that $a$ appears in its head \cite{Dix95}. %\vspace{-2mm} %\begin{definition}\label{def_dependencies-of} % Let $P$ be a normal logic program. We %\end{definition} %\vspace{-2mm} %REMOVED EXAMPLE % As an example of atom dependency, let $P_1$ be a program where $c$ and $d$ depend on each other, in contrast to atom $a$. More specifically, we have that $\REL(P_1,c)=\{d\}$, $\REL(P_1,d)=\{c\}$, and $\REL(P_1,a)=\{\}$. % \[P_1:= % \begin{Bmatrix} % c \leftarrow not \; d\\ % d \leftarrow not \; c\\ % a \leftarrow \top\\ % % n \leftarrow \top\\ % % a \leftarrow \top\\ % \end{Bmatrix} % \] % %\[P_1:= %\begin{Bmatrix} % c \leftarrow not \; d\\ % d \leftarrow not \; c %\end{Bmatrix} %P_2:= %\begin{Bmatrix} % a \leftarrow n\\ % n \leftarrow \top\\ % a \leftarrow \top\\ %\end{Bmatrix} %\] %The concept of \emph{dependency} as described in Definition \ref{def_dependencies-of} is essential in analyzing \emph{connectivity} between clause literals. The $\mathsf{dependencies\_of}(x)$ definition is straightforwardly extended to arbitrary atoms by setting $\mathsf{dependencies\_of}(\neg x):=\mathsf{dependencies\_of}(x)$ \cite{DBLP:journals/fuin/DixClassifII95a,dix1994partial}. %\begin{figure}[tbph] % \centering % \includegraphics[width=0.7\linewidth]{fig1-program-example} % \caption{A program containing a cycle through negation.} % \label{fig:programP} %\end{figure} % In this article we call \textit{cycles} those atoms that are waiting for other atoms to either succeed or fail.% (\textit{e.g.,} $a,b$ \wrt $P_1$). %When positive and negative literals are \emph{connected} generating cycles, they are ``deadlocked'', each waiting for the other to either succeed or fail. An example of these cycles is the loop formed by the literals $ c$ and $ d$ in the program $ P$ as shown in Figure \ref{fig:programP}\footnote{Graphical notation: we represent a dependency relationship through negation as failure with the arrow: \NegArrowG \;and a dependency through positive atoms with the arrow: \ArrowG}. % In the logic programming literature, cycles have been formally addressed in different ways \cite{Przymusinski89everylogic,van1989negation,Lifschitz:2006:WSM:1131313.1131316}. A class of logic programs is called \emph{stratified} if there is no cycles through negative literals, which are defined as follows: %\begin{definition} % \label{def:stratf} % A normal logic program $P$ is called \textbf{stratified}, if it can be \textit{partitioned} as $P=P_1 \cup \dots \cup P_n$, such that the following holds to true (for $i=1,\dots,n$): 1) If a literal \emph{x} occurs $positively $ in a clause in $P_i$, then all clauses containing \emph{x} in their heads are contained in $\bigcup_{j\leq i}P_j$. 2) If a literal \emph{x} occurs $ negatively $ in a clause in $P_i$, then all clauses containing \emph{x} in their heads are contained in $\bigcup_{j< i}P_j$. {We call every $P_i$ a \textit{strata}}. % \cite{przymusinski1989every}. % %\end{definition} %{Intuitively, a stratified program is defined in terms of a hierarchy of clauses, and in this work, every \textit{layer} is called a \textit{strata}} \cite{przymusinski1989every}.% . Suppose a set $S\subseteq P$, each clause in the hierarchy of $S$ is assigned to a \textit{stratum} defined as $S_\alpha = \{\}$, and the inference rules of the program are defined in such a way that predicates from higher strata cannot define predicates in lower strata \cite{przymusinski1989every}. %An example of a \emph{stratified program} is the subprogram $P_2$ introduced in Figure \ref{fig:programP}, in contrast with $P_1$, which contains a cycle through the negative literal $c$ and $d$ and is not a stratified logic program. %\noindent \textbf{Semantics} An \emph{interpretation} of the signature $\mathcal{L}_P$ is a function from $\mathcal{L}_P$ to \{false,true\}. A \textit{partial interpretation} of $\mathcal{L}_P$, are the sets $\langle I_1, I_2\rangle$ where $I_1 \cup I_2 \subseteq \mathcal{L}_P$. We use $\sem (P) = \langle P^{true}, P^{false} \rangle $, where $P^{true} := \{ p |\ p \leftarrow \top \in P\}$ and $P^{false} := \{ p |\ p \in \mathcal{L}_P \backslash \HEAD(P)\}$. $\sem (P)$ is also called model of $P$ \cite{dix2001general}. We use three value semantics that are characterized by \textbf{\textit{rewriting systems}} following a set of \textbf{Basic Transformation Rules} for \textbf{Rewriting Systems} (see details in \cite{dix2001general}), those rules are named: \textbf{RED+}, \textbf{RED-}, \textbf{Success}, \textbf{Failure}, \textbf{Loop}, \textbf{SUB}, and \textbf{TAUT}. Then, two rewriting systems ($\cfs$) can be defined based on the previous basic transformations: $CS_0$ = $\{RED^+$, $RED^-$, $Success$, $Failure$, $Loop$ $\}$, induces the WFS \cite{BrassZF96}. $CS_1$ = $CS_0 \cup \{SUB,TAUT,LC\}$, induces WFS+ \cite{dix2001general}. The \emph{normal form} of a normal logic program $P$ with respect to a rewriting system $\cfs$ is denoted by $\mathit{norm}_\cfs(P)$. Every rewriting system $\cfs$ induces a 3-valued logic semantics $\sem_{\cfs}$ as $\sem_{\cfs}(P):= \sem(\mathit{norm}_\cfs(P))$. To simplify the presentation, we use the entailment $\models_{\sem_{\cfs}}$ applied to a logic program $P$ is defined by $\sem_{\cfs}(P)=\langle T,F\rangle$ in which $P \models_{\sem_{\cfs}^{T}} a$ if and only if $a \in T$, similarly, if $P \models_{\sem_{\cfs}^{F}} a$ if and only if $a \in F$. We use the entailment $\models_{\sem_{\cfs_0}}$ and $\models_{\sem_{\cfs_1}}$ for confluent rewriting system $CS_0$ and $CS_1$ respectively; and the form $\models_{\sem_{\cfs}}$ to indicate that any rewriting system can be used. %We also use the notion of \textit{reduction} introduced in terms of the \textit{Stable model semantics} \cite{gelfond1988stable}. %\vspace{-1.5mm} %\begin{definition}\cite{gelfond1988stable}\label{def:stable} % Let \emph{P} be a normal logic program. For any set $S \subseteq {\cal % L}_P$, let $P^S$ be the definite logic program obtained from \emph{P} by % deleting: 1) each rule that has a formula $not \; l$ in its body with $l \in S$, and then 2) all formul\ae\ of the form $not \; l$ in the bodies of the remaining rules. We denote $P^{S}$ as the \textit{Gelfond-Lifschitz} (GL) \textit{reduction}. % %\end{definition} % % \vspace{-3mm} %#################### SECTION ##################################### \section{Semantic and NAF-arguments} \label{sec:wfs-argumentation} %\vspace{-2mm} Let us introduce a formal definition of semantic arguments. \begin{definition}[Semantic argument]\label{def:argument} Given a normal logic program $P$ and $S \subseteq P $. $Arg_P = \langle S, \;g \rangle$ is a \textbf{semantic argument} under $\sem_{\cfs}$ \wrt $P$, if the following conditions hold true: % \vspace{-3mm} \begin{enumerate}%[leftmargin=+.5in] \item $S \models_{\sem_{\cfs}^{T}} g$ \item $S$ is minimal \wrt the set inclusion satisfying 1. % \item $ \nexists \; g \in \mathcal{L}_P$ such that $S \models_{\sem_{\cfs}^{T}} g$%, and $S \models_{\sem_{\cfs}^{T}} \; not \; g$, and $S \models_{\sem_{\cfs}^{F}} g$. \end{enumerate} \end{definition} %\begin{definition}[confluent arguments] % \label{def:argument} % Given an extended logic program $P$, $R \subseteq P$, and $\sem_{\cfs}(R) = \langle R^{+},R^{-} \rangle $, we called a \textbf{confluent argument} the structure: $arg^{+} = \langle S, c \rangle$ where the following conditions hold true: % \begin{enumerate}%[leftmargin=+.5in] % \item $S \subseteq \REL(R,c)$ % \item $c \in R^{+} $ % \item $S$ is minimal \wrt the set inclusion. % \end{enumerate} %\end{definition} We simplify the notation of these semantic arguments as $\mathcal{A}rg^{+}$. Condition 1 states that the interpretation of conclusion $g$ is \textit{true} \wrt $T$ in $\sem_{\cfs}(S)$. Condition 2 in Definition \ref{def:argument} guarantees the support minimality. %{Now, let us consider arguments where the conclusion is interpreted as \textit{false}, \ie when a conclusion $g \in \sem_{\cfs}^{F}$, which we call \textbf{\textit{NAF-arguments}}. In the argumentation literature, a class of related arguments have been proposed as \textit{assumption arguments} in \cite{schulz2017labellings} from Assumption-based Argumentation (ABA) \cite{DungKT09}, {however, NAF-arguments have notable differences contrasted to assumption arguments, such as the consistency and minimality of the support.} Now, let us define NAF-arguments as follows: % \vspace{-2mm} \begin{definition}[NAF-arguments] \label{def:nafArgument} Given a normal logic program $P$ and $S \subseteq P $. $Arg_P = \langle S, \; not \;g \rangle$ is a \textbf{NAF-argument} under the $\sem_{\cfs}$ \wrt $P$, if the following conditions hold true: % \vspace{-3mm} \begin{enumerate}%[leftmargin=+.5in] \item $S \models_{\sem_{\cfs}^{F}} g$, \item $S$ is minimal \wrt the set inclusion satisfying 1. % \item $ \nexists \; g \in \mathcal{L}_P$ such that $S \models_{\sem_{\cfs}^{F}} g$, and $S \models_{\sem_{\cfs}^{T}} g$. \end{enumerate} \end{definition} Condition 1 in Definition \ref{def:nafArgument} is the interpretation of the conclusion \textit{w.r.t.} $\models_{\sem_{\cfs}^{F}}$, with the set of all the NAF-arguments noted as $\mathcal{A}rg^{-}$. The addition of $\; not$ in the conclusion of a NAF-argument stresses that such an atom is interpreted as false by $\sem_{\cfs}$. %Let us exemplify the generation of semantic and NAF-arguments as follows: %\vspace{-2mm} \begin{example}\label{ex:argPlusargMinus} Let us consider a program $P_3$ for building semantic and NAF-arguments considering $\cfs_0$ and $\cfs_1$. % \vspace{5mm} \begin{figure} % \centering \includegraphics[width=0.4\linewidth,bb=-3cm -1cm 20cm 7.1cm]{fig14.pdf} % \includegraphics[width=0.7\linewidth]{fig14.pdf} % \caption{} \label{fig:fig14-attacks-joint} \end{figure} % \vspace{-6mm} % \[P_3:= % \begin{Bmatrix} % \begin{array}{rl} % &a \leftarrow b, not \; c\\ % &b \leftarrow\\ % &d \leftarrow not \; d\\ % &e \leftarrow e\\ % \end{array} % \end{Bmatrix} % \] % \vspace{-1mm} We build semantic and NAF-arguments as follows: 1) get related clauses of atoms ($S_i$); 2) for every related clause compute $ \sem_{\cfs_{0}}(S_i) $ and $\sem_{\cfs_{1}}(S_i)$; 3) the \textit{support} (every $S_i$) is joined to the \textit{conclusion}\footnote{We implemented this procedure and the sources are open, then can be found in \url{https://people.cs.umu.se/~esteban/argumentation/}}. Then, the following sets of arguments are built considering $\cfs_0$ and $\cfs_1$: Case $\cfs_0$: $\mathcal{A}rg_{P_{3}} = \{A_1^{+},A_2^{+},A_3^{+},A_1^{-},A_2^{-},A_3^{-},A_4^{-},A_6^{-}\}$. Case $\cfs_1$: $\mathcal{A}rg_{P_{3}} = \{A_1^{+},A_2^{+},A_3^{+},A_5^{+},A_1^{-},A_2^{-},A_3^{-},A_4^{-},A_6^{-}\}$. % % %\vspace{-2mm} % % \usepackage{tabularray} % \begin{table}[h] % \vspace{-3mm} % \centering % \caption{Generation of semantic and NAF-arguments for the Example \ref{ex:argPlusargMinus} considering $\cfs_0$ and $\cfs_1$ rewriting systems. Note the treatment of the rule $S_4 = $ $\{d \leftarrow not \ d \}$ for $\sem_{\cfs_{0}}(S_4) $ and $\sem_{\cfs_{1}}(S_4) $} %% \begin{mdframed}[hidealllines=true,backgroundcolor=yellow!50] % \vspace{-2mm} % \resizebox{\columnwidth}{!}{% % % \begin{tblr}{ % width = 0.6\linewidth, % row{1} = {c}, % cell{1}{1} = {r=2}{}, % cell{1}{2} = {r=2}{}, % cell{1}{3} = {c=2}{}, % cell{1}{5} = {r=2}{}, % cell{1}{6} = {r=2}{}, % cell{2}{3} = {c}, % cell{3}{1} = {r=4}{}, % vlines, % hline{1,3,7-9} = {-}{}, % hline{2} = {3-4}{}, % hline{4-6} = {2-6}{}, % } % \textbf{Atoms} & {\textbf{Related clauses }} & \textbf{Interpretation} & & \textbf{$\mathcal{A}^{+}$} & \textbf{$\mathcal{A}^{-}$} \\ % & & $\sem_{\cfs_{0}}(S_i) $ & $\sem_{\cfs_{1}}(S_i) $ & & \\ % a b c & $S_0 = \{\}$ & $\langle \emptyset, \emptyset \rangle $ & $\langle \emptyset, \emptyset \rangle $ & & \\ % & {$S_1 = \{a \leftarrow b, $\\\hspace*{9mm}$not \ c\} $} & $\langle \{ \}, \{a,b,c \} \rangle $ & $\langle \{ \}, \{a,b,c \} \rangle $ & & {$A^-_1= \langle S_1, \ not \; a \rangle$\\$A^-_2= \langle S_1, \ not \; b \rangle$\\$A^-_3= \langle S_1, \ not \; c \rangle$} \\ % & {$S_2 = \{a \leftarrow b, $\\\hspace*{7mm}$\; not \ c, \; b \leftarrow \}$} & $\langle \{ a,b\}, \{c\} \rangle $ & $\langle \{ a,b\}, \{c\} \rangle $ & {$A^+_1= \langle S_2, \ a \rangle$\\$A^+_2= \langle S_2, \ b \rangle$} & $A^-_4= \langle S_2, \ not \; c \rangle$ \\ % & $S_3 = \{b \leftarrow \}$ & $\langle \{ b\}, \{\} \rangle $ & $\langle \{ b\}, \{\} \rangle $ & $A^+_3= \langle S_3, \ b \rangle$ & \\ % d & $S_4 = $ $\{d \leftarrow not \ d \}$ & $\langle \{ \}, \{\} \rangle $ & $\langle \{ d\}, \{\} \rangle $ & $A^+_5= \langle S_4, \ d \rangle$ & \\ % e & $S_5 = $ $\{e \leftarrow e \}$ & $\langle \{ \}, \{e\} \rangle $ & $\langle \{ \}, \{e\} \rangle $ & & $A^{-}_{6}= \langle S_5, \ not \ e \rangle$ % \end{tblr} % % % } %% \end{mdframed} % \vspace{-4mm} % % \label{tbl:example1_S_i_WFS} % \end{table} % % \vspace{-4mm} \end{example} %\vspace{-3mm} %\subsection{Attack relationship between semantic arguments}\label{sub_sec_attacks} %In the argumentation theory literature, specifically in abstract argumentation, the concept of \textit{attack} between to arguments is diverse (see different attack notions in \cite{gorogiannis2011instantiating}), but in general, an attack is a binary relation on a set of arguments. An effect of interpreting argument supports under $\sem_{\cfs}$ is that some atoms (or sets of them) are evaluated in \textit{opposition} to other arguments (\textit{e.g.}, $A_1^{+} = \langle S_2,a \rangle$ and $A_1^{-} = \langle S_1,\; not \; a \rangle$ in Example \ref{ex:argPlusargMinus}), suggesting a \textit{semantic attack} relationship. \begin{definition}[Semantic attack]\label{def:semanticAttack} Let $A = \langle S_A, a\rangle \in \mathcal{A}rg^{+}$, $B = \langle S_B, not \; b \rangle \in \mathcal{A}rg^{-}$ be two semantic arguments where $\sem_{\cfs}(S_A) = \langle T_A, F_A \rangle$ and $\sem_{\cfs}(S_B ) = \langle T_B, F_B \rangle$. %, we define a \textit{direct undercut} relationships as follows: We say that $A$ \textit{attacks} $B$ if $x \in T_A$ and $x \in F_B$, denoted $\attacks(x,y)$. \end{definition} %\begin{example}\label{ex_args_attacks} % % Cont. Example \ref{ex:argPlusargMinus}. We have that $A_{2}^{+}$ attacks $A_{1}^{-}$, which is represented as red arrows in Figure 1. % %\end{example} %\vspace{-3mm} \begin{lemma}\label{lemma:consistentSupport} {Semantic and NAF-arguments built from any normal logic program are always consistent.} \end{lemma} % We can see that fewer strata are suggested and evaluated using a $\sem_{\cfs}$ interpretation than using other argumentation approaches where the atoms' dependency graph is used, implying that a computational procedure for building semantic arguments (see next section) would take fewer \textit{steps} to evaluate the totality of a program. % % \begin{proposition}\label{proposition_strata for CSargument less than dependency graphs} % The number of strata for building semantic arguments is smaller or equal to using dependency graphs for building structured arguments. % \end{proposition} % %\vspace{-3mm} % {%\small % \begin{proof} % % Sketch. Consider $\alpha$ as the stratum $S_{\alpha}$ of a normal program $P$ at any level $\alpha$. The last well-founded model of $P$ can be seen as an iterated least model of $P$ with level $\delta$. Then, the number strata, \ie the true/false atoms added at every level/strata (partial interpretation), are less or equal comparatively with the ``steps'' or levels of $P$ as a graph-related structure. See a full technical proof in \cite{przymusinski1989every}. % % \end{proof} %} % % The characteristic mechanism for building arguments in our approach resembles the concept of \textit{dynamic stratification} in \cite{przymusinski1989every} that evaluates partial models of a program. Theorem \ref{proposition_strata for CSargument less than dependency graphs} highlights that it is possible to build arguments of the forms $\mathcal{A}rg^{+}$ and $\mathcal{A}rg^{-}$ by using a meaning-oriented approach for every atom, which differs to the ``standard stratification'' using the program as a directed graph. However, in the Przymusinski's approach ($Prz$), the generation of strata for local clusters are not restricted as it is in our case using $\sem_{\cfs}$. Moreover, if a \textit{syntactic} graph-oriented mechanism is used, \eg using \textit{connected components} ($CC$) as usual in many formal argumentation approaches, the number of strata is also different. Let us illustrate this property extending a key example from \cite{przymusinski1989every} as follows: % %\begin{example}\label{ex_2} % Let $ P_{2} = \{ b\leftarrow not \ a; \ c \leftarrow p, \ not \ b; \ d \leftarrow not \ e,\ f; \ f\}$ be a normal program. Then, we can represent the \textit{centrum} of the related rules (\REL) by a superscript $x$ in every strata, $ S_{\alpha}^{x}$, and the other types of stratification methods, $ Prz_{\beta},$ and $ CC_{\gamma}$ as follows: % \begin{equation*} % \begin{aligned} % % \tikzmk{A} % S_{1}^{b}&=\{a\}\\ % S_{2}^{b}&=\{b\}\\ % % \tikzmk{B}\boxit{blue} % % \tikzmk{A} % S_{3}^{d}&=\{f\}\\ % S_{4}^{d}&=\{d,e\}\\ % % \tikzmk{B}\boxit{blue} % \\ % \\ % \\ % \end{aligned} % \qquad % \begin{aligned} % Prz_{1}&=\{a\}\\ % Prz_{2}&=\{b\}\\ % Prz_{3}&=\{f\}\\ % Prz_{4}&=\{d,e\}\\ % \\ % \\ % \\ % \end{aligned} % \qquad % \begin{aligned} % CC_{1}&=\{a\}\\ % CC_{2}&=\{b\}\\ % CC_{3}&=\{p\}\\ % CC_{4}&=\{c\}\\ % CC_{5}&=\{f\}\\ % CC_{6}&=\{e\}\\ % CC_{7}&=\{d\} % \end{aligned} % \end{equation*} % In consequence, the dynamic stratification combined with the $\sem_{\cfs}$ evaluation makes an efficient approach for finding the meaning of only relevant atoms in a program. % \begin{theorem}\label{theo_comparison_S_Prz_CC} % Let $ P $ be a labeled program, and $ S_{\alpha}$, $ Prz_{\beta} $, $ CC_{\gamma} $ be a dynamic relevant stratification mechanism, a dynamic stratification (\textit{w.r.t.} \cite{przymusinski1989every}), a connected components-oriented mechanism respectively, for finding strata for every atom $ a \in P$. Then, we have that: $ \alpha = \beta\leq \gamma $ % \end{theorem} % \begin{proof} % Directly from Theorem \ref{proposition_strata for CSargument less than dependency graphs}. % \end{proof} % % % %\vspace{-2mm} %\vspace{-2mm} %\begin{lemma}[Monotonic grow of semantic arguments] % Let $\beta = |\mathcal{A}rg_{P}|$ the number of semantic arguments built from a program $P$. If $P \cup R$ with $\delta = |\mathcal{A}rg_{P \cup R}|$, then $\beta \leq \delta$. %\end{lemma} %\vspace{-4mm} % We could also establish a \textit{rebuttal} relationship between two arguments by extending the first condition of Definition \ref{def:semanticAttack}, as follows: % \begin{definition}[Rebuttal]\label{def:sem_rebuttal} % Argument $A$ \textit{rebuts} $B$ if the following holds: % % \begin{enumerate}%[leftmargin=+.5in] % \item $x \in T_A \equiv \lnot x \in T_B$. % \item $x \in T_A \equiv x \in F_B$. % \end{enumerate} % % \end{definition} % Moreover, we could extend also the same definition for capturing the notion of \textit{undercut} as follows: % \begin{definition}[Undercut]\label{def:sem_undercut} % If we consider a $U\subseteq \sem_{\cfs}(S_A)$, we say that $A$ \textit{undercuts} $B$ if the following conditions hold: % % \begin{enumerate}%[leftmargin=+.5in] % \item $U \subseteq T_A$ and $not \bigwedge U \subseteq T_B$. % \item $U \subseteq T_A$ and $U \subseteq F_B$. % \end{enumerate} % % \end{definition} % The attack relationships of our confluent arguments framework can be extended to other attack relationships found in the argumentation literature such as undercut and canonical undercut (see a survey in \cite{gorogiannis2011instantiating}). % Example \ref{ex_args_attacks} highlights an interesting consequence of the direct undercut in Definition \ref{def:semanticAttack}, specifically condition 2, which induces a \textit{preference} between $\mathcal{A}rg^{+}$ vs. $\mathcal{A}rg^{-}$, being not possible that a NAF-argument defeats an argument $arg_i^{+} \in \mathcal{A}rg^{+}$; this effect is presented in the following lemma. % % \begin{lemma}[Direct undercut preference against NAF-arguments]\label{lemma_direct_undercut} % Let $arg_A^{+}, arg_B^{-} \in \mathcal{A}rg$, with $a \in T_A \subseteq \sem_{\cfs}(S_A)$, and $b \in F_B \subseteq \sem_{\cfs}(S_B)$. Then $arg_A^{+}$ undercuts $ arg_B^{-}$, and $arg_A^{+}$ will always \textit{defeat} $arg_B^{-}$. % \end{lemma} %Following Dung's standard argumentation \cite{Dung1995}, we say in this article that two arguments are \textit{conflict-free} if no attacks exist among them. In this context, we can notice that all the sets of $\mathcal{A}rg^{+}$ and $\mathcal{A}rg^{-}$ obtained from a strata interpretation are always conflict-free, \eg $A_1^{+},A_2^{+}$ and $A_4^{-}$ \wrt $S_2$ in Ex. \ref{ex:argPlusargMinus}. %\begin{proposition}\label{prop_non-conflicting-Arg+Arg-} % Let $S_a \subseteq P$ be a set of clauses, and let the evaluation $\sem_{\cfs}(S_a) = \langle T_A, F_A \rangle$ be their interpretation. Then, the set of sub-arguments $\mathcal{A}rg = \mathcal{A}rg^+ \cup \mathcal{A}rg^-$ built from $\sem_{\cfs}(S_a)$ is conflict-free. %\end{proposition} % %\begin{proposition}\label{proposition_no_self_attacks} % Semantic arguments have no self-attacks. %\end{proposition} % %% \subsubsection{Semantic argumentation framework} %Let us introduce the concept of a \textbf{\textit{semantic argumentation framework} (SAF)}, which is based on \cite{Dung1995} that considers a directed graph where the nodes are arguments (\textit{i.e.} $\mathcal{A}rg^{+} \cup \mathcal{A}rg^{-} = \mathcal{A}rg_P$), and the arrows are attack-relations (noted as $\mathcal{A}tt$) among those nodes. %\vspace{-3mm} \begin{definition}[Semantic Argumentation Framework (SAF)]\label{def:semanticArgumentFramework} Let $P$ be a normal program. Then, a \textbf{semantic argumentation framework} is the tuple: $ SAF_{P}= \langle \mathcal{A}rg_P, \mathcal{A}tt\rangle$ \end{definition} We can straightforward extend the definitions of \emph{argumentation semantics} in \cite{Dung1995} as follows: \begin{definition}\label{def:semArg} Let $ SAF_{P}= \langle \mathcal{A}rg_P, \mathcal{A}tt\rangle$ be a semantic argumentation framework. An \textit{admissible} set of arguments $S \subseteq AR$ is: \vspace{-2mm} \begin{itemize}%[leftmargin=+.5in] \item \emph{stable} if and only if $S$ attacks each argument which does not belong to $S$. \item {\emph{preferred} if and only if $S$ is a maximal (\emph{w.r.t.} inclusion) admissible set of $AF$.} \item \emph{complete} if and only if each argument, which is acceptable with respect to $S$, belongs to $S$. \item {\emph{grounded} if and only if $S$ is the minimal (\emph{w.r.t.} inclusion) \emph{complete} extension of $AF$}\footnote{In \cite{baroni2011introduction} it is shown that grounded can be characterized in terms of complete extensions.}. \end{itemize} \end{definition} \begin{example}\label{ex:semantics} Let us consider $ P_5= \{a \leftarrow not \ b; \ b \leftarrow not \ a; \ c \leftarrow not \ c, not \ a; \ d \leftarrow not \ d, not \ b; \}$. $\sem_{\cfs}$ will remove rules involving atoms $c$ and $d$. {Then, applying Definition} \ref{def:semanticArgumentFramework}, we have the framework: $SAF_{P_5} = $ $\langle \{A_{6}^{-} = \langle \{a \leftarrow not \ b\}, \; not \ a \rangle$,$A_{6}^{+} = \langle \{b \leftarrow not \ a\}, \; b \rangle$, $A_{5}^{-} = \langle \{b \leftarrow not \ a\}, \; not \ b \rangle$, $A_{5}^{+} = \langle \{a \leftarrow not \ b\}, \; a \rangle \}, \ \texttt{attacks}(A_{5}^{+},A_{6}^{+}), $ $\texttt{attacks}(A_{5}^{+},A_{6}^{-}),$ $ \texttt{attacks}(A_{6}^{+},A_{5}^{+}),$ $ \texttt{attacks}(A_{6}^{+},A_{5}^{-})\rangle$. % \begin{figure}[h] % \centering % %\vspace{-2mm} % \includegraphics[width=0.7\linewidth]{fig13-attacks-rebbutal} % % \caption{} % \label{fig:fig13-attacks-rebbutal} % %\vspace{-2mm} % \end{figure} When we apply Definition \ref{def:semArg} to $SAF_{P_5}$ we obtained the following extensions: \vspace{-2mm} \begin{itemize}%[leftmargin=+.5in] \item Stable = preferred: $\{ \{A_{5}^{+},A_{5}^{-}\}, \ \{A_{6}^{+},A_{6}^{-}\}\}$ \item Complete: $\{ \{A_{5}^{+},A_{5}^{-}\}, \ \{A_{6}^{+},A_{6}^{-}\}, \ \{\}\}$ \item Grounded: $\{ \}$ \end{itemize} \end{example} \vspace{-4mm} \section{Conclusions}\label{sec:conclusions} \vspace{-2.5mm} %{Informally, \textit{semantic} and \textit{NAF-arguments} are \textit{support-conclusion} structures guaranteeing}: 1) \textit{consistency} \textit{i.e.,} there are no atoms that ``contradict'' each other in the support interpretation, 2) \textit{relatedness}, the conclusion is inferred from only related atoms \wrt the support interpretation, and 3) the $\sem_{\cfs}$ interpretation of related clauses suggests support structures for \textit{true} and \textit{false} conclusions. {Note that the last two properties are unique compared to other argumentation approaches \textit{e.g.,} ABA.} % where roughly speaking, the \textit{syntactic} characteristics of the clauses dictate relations and contradictions among arguments. %The most closely related framework is Assumption-Based Argumentation (ABA) \cite{bondarenko1997abstract}. We consider this proximity a remarkable characteristic of our framework, however, we can highlight four key differences: 1) \textit{argument consistency}. It is well-established that ABA, in general, does demand argument consistency arguing that such characteristic is costly to check/ensure \cite{DungKT09}. 2) \textit{No argument minimality and/or relevance}. ABA does not impose any requirement to ensure relevance through minimality of arguments \wrt the conclusion \cite{toni2014tutorial}. However, we acknowledge that in \cite{schulz2017labellings}, a specific ABA interpretation, the authors proposed that the support of the assumption-based arguments should have only clauses related to the root of their argument trees, without a technical specification about it. 3) \textit{NAF-like arguments requirements}. In some ABA translations to logic programs ( \eg \cite{schulz2017labellings,bondarenko1997abstract}), the frameworks require a \textit{total mapping} from assumptions to the signature of the logic program $\mathcal{L}$ for obtaining similar assumptions, whose rationale was discussed in \cite{toni2014tutorial}. On the contrary, the requirements for well-founded and NAF-arguments rely only on the $\sem_{\cfs}$ interpretation without any additional mapping. The main contributions are: 1) \textit{Semantic Argumentation Frameworks} (SAF) can be used for justifying \textit{true} and \textit{false } interpreted conclusions. 2) SAF is based on \textit{families} of rewriting confluent systems. 3) Satisfies all the well-known argumentation postulates \cite{amgoud2014postulates,caminada2007evaluation}. Future work will involve the exploration of our framework under other Confluent Logic Programming Systems, the satisfaction of other argumentation principles, and the investigation of commonalities between ABA and semantic argumentation. %The ultimate goal remains the improvement of the current semantic argumentation solver that is openly available. This solver would not only handle the current framework but also seamlessly integrate these diverse rewriting systems, offering a more comprehensive and adaptable argumentation. \bibliographystyle{eptcs} \bibliography{ref} \end{document}