Abstract Base Classes#
Position#
-
class
tau.Position# Bases:
abc.ABCClass 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.
Methods
are_minimally_compatible(position)Checks for minimal compatibility with
position.Position as
BitarrayPosition.as_list()Position as integer list.
as_set()Position as integer set.
Position as ternary.
domain()Determines the domain of the position.
from_set(position, n_unnegated_sentence_pool)Instanciating a
Positionfrom a set.intersection(positions)set-theoretic intersection
is_accepting(sentence)Checks whether
sentenceis in the position.is_in_domain(sentence)Checks whether
sentenceis in the domain of the position.Checks for minimal consistency.
is_subposition(position)Checks for set-theoretic inclusion.
neighbours(depth)Neighbours of the position.
Size of sentence pool.
size()size of the position
subpositions([n, only_consistent_subpositions])Iterator over subsets of size n.
union(positions)set-theoretic union
-
abstract
are_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
Trueiff the position-instance is compatible withposition- Parameters
position (tau.base.Position) –
-
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 integer 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 3 (at least). \(s_i \in \mathcal{A}\) is represented by \(1*10^{i-1}\), \(\neg s_i \in \mathcal{A}\) by \(2*10^{i-1}\) and \(s_i, \neg s_i \notin \mathcal{A}\) by zero. For instance, the position \(\{ s_1, s_3, \neg s_4 \}\) is represented by the integer 2101.
Note
Positions that are not minimally consistent cannot be represented in this way.
- Return type
int- Returns
a ternary representation of the position if possible, otherwise should return
None
-
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
Positionfrom a set.- Return type
Position- Returns
- Parameters
position (Set[int]) –
n_unnegated_sentence_pool (int) –
-
abstract static
intersection(positions)# set-theoretic intersection
- Return type
Position- Returns
The set-theoretic intersection of the given set of :code:`position`s.
- Parameters
positions (Set[tau.base.Position]) –
-
abstract
is_accepting(sentence)# Checks whether
sentenceis in the position.- Parameters
sentence (
int) – A sentence \(s_i\) represented by i.- Return type
bool- Returns
Trueiffsentenceis in the position.
-
abstract
is_in_domain(sentence)# Checks whether
sentenceis in the domain of the position.- Parameters
sentence (
int) – A sentence \(s_i\) represented by i.- Return type
bool- Returns
Trueiffsentenceis in the domain of the 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
Trueiff 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} \subset \mathcal{A}'\).
- Return type
bool- Returns
Trueiff the position-instance is a subposition ofposition- Parameters
position (tau.base.Position) –
-
abstract
neighbours(depth)# Neighbours of the position.
Generates all neighbours of the position that can be reached by at most
depthmany 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()# Size of sentence pool.
- Return type
int- Returns
the size of the unnegated sentence pool.
-
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. Ifnis \(-1\), the method returns all subpositions including the empty position and itself.only_consistent_subpositions (
bool) – IfTrueonly consistent subpositions will be returned.
- Return type
Iterator[Position]- Returns
A python iterator over subpositions of size n.
-
abstract
DialecticalStructure#
-
class
tau.DialecticalStructure# Bases:
abc.ABCClass 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.
Iterator over all dialectically closed positions.
closure(position)Dialectical closure.
Iterator over all dialectically consistent and complete positions.
Iterator over all dialectically consistent positions.
degree_of_justification(position1, position2)Conditional degree of justification.
entails(position1, position2)Dialectical entailment.
from_arguments(arguments, …)Instanciating a
DialecticalStructurefrom a list of int lists.The arguments as a list.
is_closed(position)Checks whether a position is dialectically closed.
is_complete(position)Checks whether :code:`position’ is complete.
is_consistent(position)Checks for dialectical consistency.
is_minimal(position)Checks dialectical minimality.
Iterator over all dialectically minimal positions.
Iterator over all minimally consistent positions.
n_complete_extensions(position)Number of complete and consistent extension.
sentence pool.
-
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
Trueiffposition1it dialectically compatible toposition2.- Parameters
position1 (tau.base.Position) –
position2 (tau.base.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}\) 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}\).
This method should throw a
ValueErrorif the given position is inconsistent.- Return type
Iterator[Position]- Returns
A python-iterator over all axiomatic bases of
positionfromsourceandNoneif there is no axiomatic basis in the source.- Parameters
position (tau.base.Position) –
source (Optional[Iterator[tau.base.Position]]) –
-
abstract
closed_positions()# Iterator over all dialectically closed positions.
This iterator will include the empty position, if it is closed.
- Return type
Iterator[Position]- Returns
A python-iterator over all dialectically 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 (tau.base.Position) –
-
abstract
consistent_complete_positions()# Iterator over all dialectically consistent and complete positions.
- Return type
Iterator[Position]- Returns
A python iterator over all dialectically consistent and complete positions.
-
abstract
consistent_positions()# Iterator over all dialectically consistent positions.
This iterator will include the empty position.
- Return type
Iterator[Position]- Returns
A python iterator over all dialectically consistent positions.
-
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
position1with respect toposition2.- Parameters
position1 (tau.base.Position) –
position2 (tau.base.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
Trueiffposition2is dialectically entailed byposition1.- Parameters
position1 (tau.base.Position) –
position2 (tau.base.Position) –
-
abstract static
from_arguments(arguments, n_unnegated_sentence_pool)# Instanciating a
DialecticalStructurefrom a list of int lists.- Return type
DialecticalStructure- Returns
- Parameters
arguments (List[List[int]]) –
n_unnegated_sentence_pool (int) –
-
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
is_closed(position)# Checks whether a position is dialectically closed.
- Return type
bool- Returns
Trueiffpositionis dialectically closed.- Parameters
position (tau.base.Position) –
-
abstract
is_complete(position)# Checks whether :code:`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
Trueiff thePositionis complete.- Parameters
position (tau.base.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
Trueiffpositionit dialectically consistent.- Parameters
position (tau.base.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
Trueiffpositionis dialectically minimal.- Parameters
position (tau.base.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
A python iterator over all minimally consistent positions.
-
abstract
n_complete_extensions(position)# Number of complete and consistent extension.
- Return type
int- Returns
The number of complete and consistent positions that extend
position.- Parameters
position (tau.base.Position) –
-
abstract
sentence_pool()# 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