Abstract Base Classes#

Position#

class theodias.Position#

Bases: ABC

Class representing a position.

A position \(\mathcal{A}\) is a subset \(\mathcal{A}\subset S\) over a sentence pool \(S = \{ s_1, s_2, \dots, s_N, \neg s_1, \neg s_2, \dots, \neg s_N \}\).

Note

Implementations of this abstract class do not necessarily adhere to a set-theoretic representation.
Positions are immutable—that is, you cannot change them once instantiated. In this way, you can use them as keys in, e.g., dictionaries and form sets of positions.
A position is determined by its sentences and the corresponding sentence pool. Consequently, whether two numerically distinct positions are considered the same (as in pos1 == pos2) does not depend on the implementation.
A position is bound to a specific sentence pool. If you pass positions to functions that have non-matching sentence pools, the function will raise a ValueError.

Methods

`as_bitarray`()	Position as `BitarrayPosition`.
`as_list`()	Position as integer list.
`as_set`()	Position as integer set.
`as_ternary`()	Position as ternary.
`difference`(other)	The set theoretic difference of two positions.
`domain`()	Determines the domain of the position.
`from_set`(position, n_unnegated_sentence_pool)	Instanciating a `Position` from a set.
`intersection`(*positions)	The set theoretic intersection of positions.
`is_accepting`(sentence)	Checks whether `sentence` is in the position.
`is_in_domain`(sentence)	Checks whether `sentence` is in the domain of the position.
`is_minimally_compatible`(position)	Checks for minimal compatibility with `position`.
`is_minimally_consistent`()	Checks for minimal consistency.
`is_subposition`(position)	Checks for set-theoretic inclusion.
`neighbours`(depth)	Neighbours of the position.
`sentence_pool`()	Returns the sentences (without negations) of a position's sentence pool.
`size`()	size of the position
`subpositions`([n, only_consistent_subpositions])	Iterator over subsets of size n.
`union`(*positions)	The set theoretic union of positions.

__init__()#

abstract as_bitarray()#

Position as BitarrayPosition.

A pair of bits represents a sentence: The first bit represents acceptance and the second bit rejection. Suspension of a sentence corresponds to both bits being False/0 and (minimal or flat) contradiction is present if both bits are True/1. For instance, the position \(\{ s_1, s_3, \neg s_4 \}\) is represented by 10001001.

Return type:: bitarray
Returns:: a bitarray representation of the position if possible, otherwise should return None

abstract as_list()#

Position as integer list.

The position \(\mathcal{A}\) represented by a python list of integer values. \(s_i \in \mathcal{A}\) is represented by \(i\) and \(\neg s_i \in \mathcal{A}\) by \(-i\). For instance, the position \(\{ s_1, s_3, \neg s_4 \}\) is represented by [1, 3, -4].

Note

The returned order of the values is not specified.

Return type:: List[int]
Returns:: a representation of the position as a list of integer values

abstract as_set()#

Position as integer set.

The position \(\mathcal{A}\) represented by a python set of integer values. \(s_i \in \mathcal{A}\) is represented by \(i\) and \(\neg s_i \in \mathcal{A}\) by \(-i\). For instance, the position \(\{ s_1, s_3, \neg s_4 \}\) is represented by {1, 3, -4}.

Return type:: Set[int]
Returns:: a representation of the position as a set of integer values

abstract as_ternary()#

Position as ternary.

The position \(\mathcal{A}\) represented by an integer of base 4. \(s_i \in \mathcal{A}\) is represented by \(1*10^{i-1}\), \(\neg s_i \in \mathcal{A}\) by \(2*10^{i-1}\), \(s_i, \neg s_i \notin \mathcal{A}\) by zero and \(s_i, \neg s_i \notin \mathcal{A}\) by 3. For instance, the position \(\{ s_1, s_3, \neg s_4 \}\) is represented by the integer 2101.

Return type:: int
Returns:: a ternary representation of the position if possible, otherwise should return None

abstract difference(other)#

The set theoretic difference of two positions.

Return type:: Position
Returns:: The set-theoretic difference of the two positions (sentences that are in the position but not in the other position).
Raises:: a ValueError if the sentence pools do not match.
Parameters:: other (Position) –

abstract domain()#

Determines the domain of the position.

The domain of a position \(\mathcal{A}\) is the closure of \(\mathcal{A}\) under negation.

Return type:: Position
Returns:: the domain of the position

abstract static from_set(position, n_unnegated_sentence_pool)#

Instanciating a Position from a set.

Return type:

Position

Returns:

Position

Parameters:

position (Set[int]) –
n_unnegated_sentence_pool (int) –

abstract intersection(*positions)#

The set theoretic intersection of positions.

Return type:: Position
Returns:: The set-theoretic intersection of the position with the given positions. If no argument is provided, the empty position is returned.
Raises:: a ValueError if the sentence pools do not match.
Parameters:: positions (Position) –

abstract is_accepting(sentence)#

Checks whether sentence is in the position.

Parameters:: sentence (int) – A sentence \(s_i\) represented by i.
Return type:: bool
Returns:: True iff sentence is in the position.

abstract is_in_domain(sentence)#

Checks whether sentence is in the domain of the position.

Parameters:: sentence (int) – A sentence \(s_i\) represented by i.
Return type:: bool
Returns:: True iff sentence is in the domain of the position.

abstract is_minimally_compatible(position)#

Checks for minimal compatibility with position.

Two positions \(\mathcal{A}\) and \(\mathcal{A}'\) are minimally compatible iff \(\mathcal{A} \cup \mathcal{A}'\) is minimally consistent.

Return type:: bool
Returns:: True iff the position-instance is compatible with position
Parameters:: position (Position) –

abstract is_minimally_consistent()#

Checks for minimal consistency.

A position \(\mathcal{A}\) is minimally consistent iff \(\forall s \in S: s\in \mathcal{A} \rightarrow \neg s \notin \mathcal{A}\)

Return type:: bool
Returns:: True iff the position is minimally consistent

abstract is_subposition(position)#

Checks for set-theoretic inclusion.

The position \(\mathcal{A}\) is a subposition of \(\mathcal{A}'\) iff \(\mathcal{A} \subseteq \mathcal{A}'\).

Return type:: bool
Returns:: True iff the position-instance is a subposition of position
Parameters:: position (Position) –

abstract neighbours(depth)#

Neighbours of the position.

Generates all neighbours of the position that can be reached by at most depth many adjustments of individual sentences (including the position itself). The number of neighbours is \(\sum_{k=0}^d {n\choose k}*2^k)\), where n is the number of unnegated sentences and d is the depth of the neighbourhood.

Return type:: Iterator[Position]
Parameters:: depth (int) –

abstract sentence_pool()#

Returns the sentences (without negations) of a position’s sentence pool.

Returns from \(S = \{ s_1, s_2, \dots, s_N, \neg s_1, \neg s_2, \dots, \neg s_N \}\) only \(\{ s_1, s_2, \dots, s_N\}\)

Return type:: Position
Returns:: “Half” of the full sentence pool \(S\) as Position (sentences without their negation).

abstract size()#

size of the position

Return type:: int
Returns:: The amount of sentences in that position (\(|S|\)).

abstract subpositions(n=-1, only_consistent_subpositions=True)#

Iterator over subsets of size n.

Parameters:

n (int) – The size of the returned positions. If n is \(-1\), the method returns all subpositions including the empty position and itself.
only_consistent_subpositions (bool) – If True only consistent subpositions will be returned.

Return type:

Iterator[Position]

Returns:

A python iterator over subpositions of size n.

abstract union(*positions)#

The set theoretic union of positions.

Return type:: Position
Returns:: The set-theoretic union of the position with the given positions. If no argument is provided, the positions is returned.
Raises:: a ValueError if the sentence pools do not match.
Parameters:: positions (Position) –

DialecticalStructure#

class theodias.DialecticalStructure#

Bases: ABC

Class representing a dialectical structure.

A dialectical structure is a tupel \(\left< S,A\right>\) of a sentence pool \(S = \{ s_1, s_2, \dots, s_N, \neg s_1, \neg s_2, \dots, \neg s_N \}\) and a set \(A\) of arguments.

An argument \(a=(P_a, c_a)\) is defined as a pair consisting of premises \(P_a \subset S\) and a conclusion \(c_a \in S\).

Methods

`add_argument`(argument)	Adds an argument to the dialectical structure.
`add_arguments`(arguments)	Adds arguments to the dialectical structure.
`are_compatible`(position1, position2)	Checks for dialectical compatibility of two positions.
`axioms`(position[, source])	Iterator over all axiomatic bases from source.
`closed_positions`()	Iterator over all dialectically consistent and closed positions.
`closure`(position)	Dialectical closure.
`consistent_complete_positions`([position])	Iterator over all dialectically consistent and complete positions that extend `position`.
`consistent_positions`([position])	Iterator over all dialectically consistent positions that extend `position`.
`degree_of_justification`(position1, position2)	Conditional degree of justification.
`entails`(position1, position2)	Dialectical entailment.
`from_arguments`(arguments, ...[, name])	Instanciating a `DialecticalStructure` from a list of int lists.
`get_arguments`()	The arguments as a list.
`get_name`()	Get the name of the dialectical structure.
`is_closed`(position)	Checks whether a position is dialectically closed.
`is_complete`(position)	Checks whether `position` is complete.
`is_consistent`(position)	Checks for dialectical consistency.
`is_minimal`(position)	Checks dialectical minimality.
`minimal_positions`()	Iterator over all dialectically minimal positions.
`minimally_consistent_positions`()	Iterator over all minimally consistent positions.
`n_complete_extensions`([position])	Number of complete and consistent extension.
`sentence_pool`()	Returns the sentences (without negations) of a dialetical structure's sentence pool.
`set_name`(name)	Set the name of the dialectical structure.

abstract add_argument(argument)#

Adds an argument to the dialectical structure.

Parameters:: argument (List[int]) – An argument as an integer list. The last element represents the conclusion the others the premises.
Return type:: DialecticalStructure
Returns:: The dialectical structure for convenience.

abstract add_arguments(arguments)#

Adds arguments to the dialectical structure.

Parameters:: arguments (List[List[int]]) – A list of arguments as a list of integer lists.
Return type:: DialecticalStructure
Returns:: The dialectical structure for convenience.

abstract are_compatible(position1, position2)#

Checks for dialectical compatibility of two positions.

Two positions are dialectically compatible iff there is a complete and consistent positition that extends both.

Return type:

bool

Returns:

True iff position1 it dialectically compatible to position2.

Parameters:

position1 (Position) –
position2 (Position) –

abstract axioms(position, source=None)#

Iterator over all axiomatic bases from source. The source defaults to all consistent positions if it is not provided.

A position \(\mathcal{B}\) (\(\in\) source) is an axiomatic basis of another position \(\mathcal{A}\) iff \(\mathcal{A}\) is dialectically entailed by \(\mathcal{B}\) and there is no proper subset \(\mathcal{C}\) of \(\mathcal{B}\) such that \(\mathcal{A}\) is entailed by \(\mathcal{C}\).

Return type:

Iterator[Position]

Returns:

A (possibly empty) python-iterator over all axiomatic bases of position from source. The iterator will be empty ([]) if there is no axiomatic basis in the source.

Raises:

A ValueError if the given position is inconsistent.

Parameters:

position (Position) –
source (Iterator[Position] | None) –

abstract closed_positions()#

Iterator over all dialectically consistent and closed positions.

This iterator will include the empty position if it is closed.

Return type:: Iterator[Position]
Returns:: A python-iterator over all dialectically consistent and closed positions.

abstract closure(position)#

Dialectical closure.

The dialectical closure of a position \(\mathcal{A}\) is the intersection of all consistent and complete positions that extend \(\mathcal{A}\). Note that in consequence, the empty position can have a non-empty closure.

Return type:: Position
Returns:: The dialectical closure of position.
Parameters:: position (Position) –

abstract consistent_complete_positions(position=None)#

Iterator over all dialectically consistent and complete positions that extend position.

Return type:: Iterator[Position]
Returns:: An iterator over all dialectically consistent and complete positions that extend position. If no position is given, the function returns an iterator over all dialectically consistent and complete positions.
Parameters:: position (Position | None) –

abstract consistent_positions(position=None)#

Iterator over all dialectically consistent positions that extend position.

This iterator will include the empty position.

Return type:: Iterator[Position]
Returns:: A python iterator over all dialectically consistent positions that extend position. If no position is given, the function returns an iterator over all dialectically consistent positions.
Parameters:: position (Position | None) –

abstract degree_of_justification(position1, position2)#

Conditional degree of justification.

The conditional degree of justification \(DOJ\) of two positions \(\mathcal{A}\) and \(\mathcal{B}\) is defined by \(DOJ(\mathcal{A}| \mathcal{B}):=\frac{\sigma_{\mathcal{AB}}}{\sigma_{\mathcal{B}}}\) with \(\sigma_{\mathcal{AB}}\) the set of all consistent and complete positions that extend both \(\mathcal{A}\) and \(\mathcal{B}\) and \(\sigma_{\mathcal{B}}\) the set of all consistent and complete positions that extend \(\mathcal{B}\).

Return type:

float

Returns:

The conditional degree of justification of position1 with respect to position2.

Parameters:

position1 (Position) –
position2 (Position) –

abstract entails(position1, position2)#

Dialectical entailment.

A position \(\mathcal{A}\) dialectically entails another position \(\mathcal{B}\) iff every consistent and complete position that extends \(\mathcal{A}\) also extends \(\mathcal{B}\).

Return type:

bool

Returns:

True iff position2 is dialectically entailed by position1.

Parameters:

position1 (Position) –
position2 (Position) –

abstract static from_arguments(arguments, n_unnegated_sentence_pool, name=None)#

Instanciating a DialecticalStructure from a list of int lists.

Return type:

DialecticalStructure

Returns:

DialecticalStructure

Parameters:

arguments (List[List[int]]) –
n_unnegated_sentence_pool (int) –
name (str | None) –

abstract get_arguments()#

The arguments as a list.

Return type:: List[List[int]]
Returns:: The arguments as a list of integer lists. The last element of each inner list represents the conclusion, the others the premises.

abstract get_name()#

Get the name of the dialectical structure.

Return type:: str
Returns:: The name of the dialectical structure as a string (default: None)

abstract is_closed(position)#

Checks whether a position is dialectically closed.

Return type:: bool
Returns:: True iff position is dialectically closed.
Parameters:: position (Position) –

abstract is_complete(position)#

Checks whether position is complete.

A position \(\mathcal{A}\) is complete iff the domain of \(\mathcal{A}\) is identical with the sentence pool \(S\).

Return type:: bool
Returns:: True iff the Position is complete.
Parameters:: position (Position) –

abstract is_consistent(position)#

Checks for dialectical consistency.

A complete position \(\mathcal{A}\) is dialectically consistent iff it is a minimally consistent and for all arguments \(a=(P_a, c_a) \in A\) holds: If \((\forall p \in P_a:p \in \mathcal{A})\) then \(c_a \in \mathcal{A}\)

A partial position \(\mathcal{A}\) is dialectically consistent iff there is a complete and consistent position that extends \(\mathcal{A}\).

Return type:: bool
Returns:: True iff position it dialectically consistent.
Parameters:: position (Position) –

abstract is_minimal(position)#

Checks dialectical minimality.

A position \(\mathcal{A}\) is dialectically minimal if every subposition \(\mathcal{B}\subseteq\mathcal{A}\) that entails \(\mathcal{A}\) is identical with \(\mathcal{A}\).

Return type:: bool
Returns:: True iff position is dialectically minimal.
Parameters:: position (Position) –

abstract minimal_positions()#

Iterator over all dialectically minimal positions.

Return type:: Iterator[Position]
Returns:: A python iterator over all dialectically minimal positions.

abstract minimally_consistent_positions()#

Iterator over all minimally consistent positions.

A position \(\mathcal{A}\) is minimally consistent iff \(\forall s \in S: s\in \mathcal{A} \rightarrow \neg s \notin \mathcal{A}\)

This iterator will include the empty position.

Return type:: Iterator[Position]
Returns:: An iterator over all minimally consistent positions.

abstract n_complete_extensions(position=None)#

Number of complete and consistent extension.

Return type:: int
Returns:: The number of complete and consistent positions that extend position. If none is given, the function returns the number of all complete consistent extensions. If the given position is dialectically inconsistent, there are no consistent extensions.
Parameters:: position (Position | None) –

abstract sentence_pool()#

Returns the sentences (without negations) of a dialetical structure’s sentence pool.

Returns from \(S = \{ s_1, s_2, \dots, s_N, \neg s_1, \neg s_2, \dots, \neg s_N \}\) only \(\{ s_1, s_2, \dots, s_N\}\)

Return type:: Position
Returns:: “Half” of the full sentence pool \(S\) as Position (sentences without their negation).

abstract set_name(name)#

Set the name of the dialectical structure.

Parameters:: name (str) –