Bitarray Implementation#

BitarrayPosition#

class theodias.BitarrayPosition#

Bases: Position

Implementing Position on the basis of bitarrays.

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`(pos2)	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])	Returns an iterator over subpositions of size n, with n being an optional argument (defaulting to -1, returning all subpositions.
`union`(*positions)	The set theoretic union of positions.

__init__(ba, n_unnegated_sentence_pool=None)#

Instantiates a BitarrayPosition from a bitarray or a set of ints.

A pair of bits, which can take the values True/1 or False/0, represents a sentence in a position. The first bit represents acceptance and the second bit rejection. Suspension of a sentence corresponds to both bits being False/0, (minimal or flat) contradiction obtains when both bits are True/1.

A position is represented by an array of bits. The status of sentence \(s_{i}\) (\(i=1,\dots,n\)) corresponds to the bits at indices \(2 \cdot (i - 1)\) and \(2 \cdot (i - 1) + 1\)

For example, for a sentence pool of 7 unnegated sentences, \(\mathcal{A} = \lbrace s_{1}, \neg s_{2}, s_{6} \rbrace\) correponds to bitarray('10010000001000'), which can be handed over to BitarrayPosition.

Note

A BitarrayPosition may be created by a bitarray, e.g. BitarrayPosition(bitarray('10001001')), or more comfortably, by a set of integer-represented sentences and the number of unnegated sentences in the sentencepool, e.g. BitarrayPosition({1, 3, -4}, n_unnegated_sentence_pool=4) or BitarrayPosition.from_set({1, 3, -4}, 4).

Parameters:

ba (bitarray | Set[int]) –
n_unnegated_sentence_pool (int | None) –

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

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

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

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

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) –

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

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) –

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) –

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.

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.

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) –

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

is_subposition(pos2)#

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:

self (Position) –
pos2 (Position) –

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) –

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).

size()#

size of the position

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

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

Returns an iterator over subpositions of size n, with n being an optional argument (defaulting to -1, returning all subpositions. If only_consistent_subposition is set to true (by default), only minimally consistent subpositions are returned, which is less costly than returning all subpositions (if the parameter is set to false)).

Return type:

Iterator[Position]

Parameters:

n (int) –
only_consistent_subpositions (bool) –

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) –

DAGBitarrayDialecticalStructure#

class theodias.DAGBitarrayDialecticalStructure#

Bases: DialecticalStructure

Implementing DialecticalStructure on the basis of BitarrayPosition and directed acyclic graphs (DAG).

Note

This class calculates and stores information about all positions in a dialectical structure. The number of positions grows exponentially in the number of sentences in the sentence pool (\(3^{n}\)). Consequently, it is not suitable for larger sentence pool sizes, for which BDDNumpyDialecticalStructure is recommended.

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.
`complete_extensions`(position)	Returns complete extensions of position by retrieving corresponding node in the graph that stores complete extensions.
`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.
`to_bitarray_position`(position)	Convert a position to an instance of `BitarrayPosition`.

complete_minimally_consistent_positions

__init__(n, initial_arguments=None, name=None)#

Parameters:

n (int) –
initial_arguments (List[List[int]] | None) –
name (str | None) –

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.

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.

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) –

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) –

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.

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) –

complete_extensions(position)#

Returns complete extensions of position by retrieving corresponding node in the graph that stores complete extensions.

Return type:: Set[Position]
Parameters:: position (Position) –

complete_minimally_consistent_positions()#

Return type:: Iterator[Position]

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) –

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) –

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) –

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) –

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) –

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.

get_name()#

Get the name of the dialectical structure.

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

is_closed(position)#

Checks whether a position is dialectically closed.

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

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) –

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) –

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) –

minimal_positions()#

Iterator over all dialectically minimal positions.

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

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.

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) –

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).

set_name(name)#

Set the name of the dialectical structure.

Parameters:: name (str) –

to_bitarray_position(position)#

Convert a position to an instance of BitarrayPosition.

Return type:: BitarrayPosition
Parameters:: position (Position) –