mvlogics.protocols¶

Classes¶

`AbstractLogicBase`	All the operators are technically abstract, but they are not marked so here to avoid type annotation duplication.
`DecimalLogicBase`	Logics with infinitely many truth values between 0 and 1, represented as instances of `decimal.Decimal`.
`GödelLogic`	All the operators are technically abstract, but they are not marked so here to avoid type annotation duplication.
`InfiniteLogicBase`	All the operators are technically abstract, but they are not marked so here to avoid type annotation duplication.
`LogicBase`	All the operators are technically abstract, but they are not marked so here to avoid type annotation duplication.
`MemberlessLogicBase`	All the operators are technically abstract, but they are not marked so here to avoid type annotation duplication.
`PostLogic`	All the operators are technically abstract, but they are not marked so here to avoid type annotation duplication.
`RationalLogicBase`	Logics with infinitely many truth values between 0 and 1, represented as instances of `fractions.Fraction`.
`RationalTNormLogic`	Logics with infinitely many truth values between 0 and 1, represented as instances of `fractions.Fraction`.
`StrictLogicBase`	All the operators are technically abstract, but they are not marked so here to avoid type annotation duplication.
`TNormLogic`	Logics with infinitely many truth values between 0 and 1, represented as instances of `decimal.Decimal`.
`ŁukasiewiczLogic`	All the operators are technically abstract, but they are not marked so here to avoid type annotation duplication.

Module Contents¶

class mvlogics.protocols.AbstractLogicBase[R]¶

Bases: MemberlessLogicBase[R]

All the operators are technically abstract, but they are not marked so here to avoid type annotation duplication.

class mvlogics.protocols.DecimalLogicBase¶

Bases: InfiniteLogicBase[decimal.Decimal]

Logics with infinitely many truth values between 0 and 1, represented as instances of decimal.Decimal.

class mvlogics.protocols.GödelLogic¶

Bases: LogicBase[fractions.Fraction]

All the operators are technically abstract, but they are not marked so here to avoid type annotation duplication.

class mvlogics.protocols.InfiniteLogicBase[R]¶

Bases: AbstractLogicBase[R]

All the operators are technically abstract, but they are not marked so here to avoid type annotation duplication.

F: Self¶

T: Self¶

falsum: Self¶

members: dict[R, Self]¶: A dictionary mapping truth values to members of the logic.

verum: Self¶

class mvlogics.protocols.LogicBase[V]¶

Bases: AbstractLogicBase[V]

All the operators are technically abstract, but they are not marked so here to avoid type annotation duplication.

class MemberContainer[R](values: dict[str, R])¶

Initialize the member container from a mapping of names to unique values.

__iter__() → _collections_abc.Generator[LogicBase[R]]¶: Generate the members of the logic in ascending order of truth value.

__set_name__(owner: type, name: str, /) → None¶

from_name(name: str) → LogicBase[R]¶: Construct the member of the logic with the specified name.

generate(value: R) → LogicBase[R]¶: Construct the member of the logic with the specified truth value.

member_values() → _collections_abc.Generator[R]¶: Generate the truth values of the logic members in ascending order.

name_from_value(value: R, /) → str¶: Get the name of the logic member with the specified truth value.

value_from_name(name: str, /) → R¶: Get the truth value of the logic member with the specified name.

property names: tuple[str, Ellipsis]¶: The names of the truth values of the logic in ascending order of truth value.

members: LogicBase.MemberContainer[V]¶: A special object holding the members of the logic.

class mvlogics.protocols.MemberlessLogicBase[R]¶

All the operators are technically abstract, but they are not marked so here to avoid type annotation duplication.

__and__(other: Self, /) → Self¶

__invert__() → Self¶

__neg__() → Self¶

__or__(other: Self, /) → Self¶

__pos__() → Self¶

__xor__(other: Self, /) → Self¶

abjunction(other: Self, /) → Self¶

converse_abjunction(other: Self, /) → Self¶

converse_implies(other: Self, /) → Self¶

convert_to[L: MemberlessLogicBase[Any]](cls: type[L]) → L¶: Convert the member to a member of the specified logic class, or report an error if impossible.

classmethod from_logic_member(member: MemberlessLogicBase[Any]) → Self¶: Convert a member of any logic class to a member of the current class, or report an error if impossible.

classmethod from_normalized(val: fractions.Fraction) → Self¶: Construct a member of the class from a normalized value, that is, an instance of fractions.Fraction between 0 and 1, or report an error if impossible.

iff(other: Self, /) → Self¶

implies(other: Self, /) → Self¶

nand(other: Self, /) → Self¶

nor(other: Self, /) → Self¶

normalized() → fractions.Fraction¶: Return the normalized value of the member, that is, a fractions.Fraction between 0 and 1 representing its degree of truth.

xnor(other: Self, /) → Self¶

property name: str¶

property value: R¶

class mvlogics.protocols.PostLogic¶

Bases: LogicBase[fractions.Fraction]

All the operators are technically abstract, but they are not marked so here to avoid type annotation duplication.

class mvlogics.protocols.RationalLogicBase¶

Bases: InfiniteLogicBase[fractions.Fraction]

Logics with infinitely many truth values between 0 and 1, represented as instances of fractions.Fraction.

class mvlogics.protocols.RationalTNormLogic¶

Bases: RationalLogicBase

Logics with infinitely many truth values between 0 and 1, represented as instances of fractions.Fraction.

strong_conjunction(other: Self, /) → Self¶

class mvlogics.protocols.StrictLogicBase[R]¶

Bases: LogicBase[R]

All the operators are technically abstract, but they are not marked so here to avoid type annotation duplication.

consensus(other: Self, /) → Self¶

gullibility(other: Self, /) → Self¶

class mvlogics.protocols.TNormLogic¶

Bases: DecimalLogicBase

Logics with infinitely many truth values between 0 and 1, represented as instances of decimal.Decimal.

strong_conjunction(other: Self, /) → Self¶

class mvlogics.protocols.ŁukasiewiczLogic¶

Bases: LogicBase[fractions.Fraction]

All the operators are technically abstract, but they are not marked so here to avoid type annotation duplication.

box() → Self¶

diamond() → Self¶

doubtful() → Self¶

strong_conjunction(other: Self, /) → Self¶

strong_disjunction(other: Self, /) → Self¶