Positions#

Positions are belief sytems of agents#

(Valid) arguments are relations between propositions: if the premises were true, the conclusion would be as well. Agents can accept arguments as valid without agreeing to the premises. The mere existence of an argument does not force an agent to assert the conclusion if it does not accept one or more of the premises.

The theory of dialectical structures represents belief systems of agents as mappings from the propositions discussed in a debate to truth values – positions can only be held relative to a debate. A position that assigns True to a proposition is often said to “accept” it, and to “reject” it if it assigns False.

Let us look at a debate \(\tau_1\) with five propositions: a, b, c, d and e, and a position \(\text{Pos}_1\) that assigns truth values to these propositions.

\[\begin{split}\begin{align*} \tau_1 = & ((a\land b) \implies \neg c) \\ & \land (( \neg d \land e) \implies \neg a)\\ \\ \text{Pos}_1 = & \left\{ \begin{array}{l} a \to \text{True}\\ b \to \text{False}\\ c \to \text{True}\\ d \to \text{True}\\ e \to \text{False}\\ \end{array} \right\} \end{align*}\end{split}\]

In taupy, positions are input with as instances of Position.

class taupy.basic.positions.Position(debate, *args, introduction_strategy=None, update_strategy=None)[source]#

A position in terms of the theory of dialectical structure, used to model agent’s belief systems.

As positions can only be held relative to a debate, it is given as the first argument when creating a new Position object. The truth-value assignments are given as a mapping in the second argument:

from taupy import Argument, Debate, Position
from sympy import symbols
a, b, c, d, e = symbols("a b c d e")
tau1 = Debate(Argument(a&b, ~c), Argument(~d&e, ~a))
pos1 = Position(tau1, {a: True, b: False, c: True, d: True, e: False})

Properties of positions#

Completeness#

Positions do not necessarily assign a truth value to every sentence in the pool. A position that does not is called “partial”. A “complete” position assigns a truth value to every proposition in the debate.

Position.is_complete()[source]#
pos1 = Position(tau1, {a: True, b: False, c: True})
# Check whether it is complete, i.e. assigns True or False to every sentence in its Debate:
pos1.is_complete()

Closedness#

A position is closed if it follows its dialectical obgliations: if a position assigns True to all premises in an argument, it must also assign True to the conclusion.

taupy.basic.positions.closedness(pos, debate=None, return_alternative=False)[source]#

A position pos is closed relative to a debate when it follows its dialectical obligations: if a position assigns True to all of the premises of an argument in the debate, it must also assign True to the conclusion of that argument.

This function assumes that the input pos is coherent. If in doubt, you should perform a coherence check first. Incoherent positions can be labelled as closed by this algorithm, although this is nonsensical.

Returns a Boolean by default indicating the closedness status of pos. However, if return_alternative is True, the function will return a tuple containing the closedness value and an alternative. The alternative is obtained by checking if the position follows entailment. If the position is closed, the alternative will be the position itself, but in case of closeness violation, the function will close the position by filling up the position via entailment.

A shortcut of this function exists under Position.is_closed().

Position.is_closed()[source]#

Coherence#

There are two ways to express coherence for a position relative to a debate:

  1. The position (a) assigns identical truth values to sentences that are equivalent give the debate and complementary truth values to incompatible ones and (b) does not contradict its inferential obligations, i.e. if it accepts all premises of an argument, it can not reject the conclusion.

  2. The position satisfies the Boolean formula that represents the debate. In other words, if \(\text{SAT}(\tau)\) returns the set of satisfying assignments of the Boolean formula for the debate \(\tau\), then a position \(\text{pos}\) is coherent just in case \(\text{pos} \in \text{SAT}(\tau)\).

Note

Coherence does not imply closedness. Under condition (1b), a coherent position is only required not to contradict its inferential obligations. But a coherent position can still not follow some of them, e.g. by being a partial position and not assigning a value to the conclusion.

Coherence and completeness jointly imply closedness.

Position.is_coherent()[source]#
pos1 = Position(Debate(Argument(a&~b, c)), {a: True, b: False, c: False})
# Will return False:
pos1.is_coherent()

The set of coherent and complete positions#

A central concept to the theory of dialectical structures is the collection of all positions that are coherent and complete (and thus closed) given a debate.

Given a debate tau, this set can be obtained with taupy.satisfiability(tau, all_models=true).

taupy.basic.utilities.satisfiability(formula, all_models=False)[source]#

Return a generator of models for the given Boolean formula, using BDDs

When interpreted as a graph, this set is called the space of coherent and complete positions, or SCCP, often expressed by the Greek letter Gamma (\(\Gamma\)). The SCCP yields insights about the debate itself, such as its inferential density.

Debate.sccp(return_attributions=False)#

Returns a dictionary of lists (position: [neighbour1, neighbour2, …]) that resembles the space of coherent and complete positions. This structure serves as the basis for graph analysis and graph drawing.

Iteration is done over the possible neighbours of a position rather than with all other positions, b/c the searches’ complexity will be lower.

If return_attributions is set to True, this function returns a tuple. The first object then is the graph representation in a dict of lists format, the second object is a mapping from the string representation of a position to its dictionary format. This is useful because non-hashable objects like dictionaries can not be used as identifiers of nodes in graphs.

tau1 = Debate(Argument(a&~b, c))
tau1.sccp()