mvlogics 0.9.0__py3-none-any.whl

mvlogics/__init__.py

@@ -0,0 +1,104 @@
+from .base import Fraction, Decimal, _AllLogicMeta, _FakeProtocolMeta, _DecimalLogicMeta, _RationalLogicMeta, _FastEnumLogicMeta, _SubmoduleMeta, _singleton_new, REQUIRED_ATTRS, FORBIDDEN, ALL_LOGICS, ALL_LOGICS_TUPLE, ALL_METHODS, FAKE_PROTOCOLS, FAKE_PROTOCOLS_TUPLE, RECOMMENDED_METHODS, MIXIN_METHODS, EXTENSION_METHODS, _all as __all__
+def is_logic(typ): return isinstance(typ, _AllLogicMeta)
+def is_logic_member(obj): return is_logic(type(obj))
+def is_builtin_logic(typ): return typ.__name__ in ALL_LOGICS and typ.__module__ == __name__
+def is_builtin_logic_member(obj): return is_builtin_logic(type(obj))
+def convert(member, cls):
+    if isinstance(member, type): cls, member = member, cls
+    return member.convert_to(cls)
+class Unit(metaclass=_AllLogicMeta):
+    __new__ = _singleton_new; box = diamond = __invert__ = lambda self: self; __and__ = __or__ = implies = gullibility = consensus = lambda self, _, /: self
+    def __bool__(self): raise TypeError('cannot convert Unit to bool')
+    def __repr__(self): return 'Unit.T'
+    def normalized(self): return Fraction(1)
+    @classmethod
+    def from_normalized(cls, val):
+        if val == Fraction(1): return cls()
+        raise ValueError(f'could not construct instance from val {val}')
+    def __reduce__(self): return type(self), ()
+Unit.T = Unit()
+class Boolean(metaclass=_FastEnumLogicMeta):
+    members = {'F': False, 'T': True}
+    box = diamond = lambda self: self
+    def __and__(self, other, /): return self and other
+    def __or__(self, other, /): return self or other
+    def __invert__(self): return type(self)(not self)
+    def __reduce__(self): return type(self), (self.value,)
+K3, LP = map(lambda n, g: _FastEnumLogicMeta(n, (), {'members': {'F': -1, 'I': 0, 'T': 1}, '__and__': lambda self, other, /: min(self, other), '__or__': lambda self, other, /: max(self, other), '__invert__': lambda self: type(self)(-self.value), '__bool__': lambda self: self.value >= (n == 'K'), 'gullibility': g, 'consensus': lambda self, other, /: self if self is other else other if self is (I := type(self).I) else self if other is I else I, 'normalized': lambda self: Fraction(self.value+1, 2), 'from_normalized': classmethod(lambda cls, val: cls(int(val*2-1)))}), ('K3', 'LP'), (lambda self, other, /: self if self is other else type(self).I, lambda self, other, /: self if self is other else other if self is (I := type(self).I) else self if other is I else type(self).F))
+class BI3(metaclass=_FastEnumLogicMeta):
+    members = {'F': -1, 'I': 0, 'T': 1}
+    def __and__(self, other, /): return I if (I := __class__.I) in (self, other) else type(self)(min(self.value, other.value))
+    def __or__(self, other, /): return I if (I := __class__.I) in (self, other) else type(self)(max(self.value, other.value))
+    def __invert__(self): return type(self)(-self.value)
+    def implies(self, other, /): return I if (I := __class__.I) in (self, other) else __class__.F if self is (T := __class__.T) and other is __class__.F else T
+    def gullibility(self, other, /): return self if self is other else __class__.I
+    def consensus(self, other, /): return self if len(s := {self, other}) == 1 else s.discard(__class__.I) or (s.pop() if len(s) == 1 else __class__.I)
+    def normalized(self): return Fraction(self.value+1, 2)
+    @classmethod
+    def from_normalized(cls, val): return cls(int(val*2-1))
+    def __reduce__(self): return type(self), (self.value,)
+class RM3(metaclass=_FastEnumLogicMeta):
+    members = {'F': -1, 'B': 0, 'T': 1}
+    def __and__(self, other, /): return type(self)(min(self.value, other.value))
+    def __or__(self, other, /): return type(self)(max(self.value, other.value))
+    def __invert__(self): return type(self)(-self.value)
+    def implies(self, other, /): return self if self is other else T if (self is (F := __class__.F))^(other is (T := __class__.T)) else F
+    def normalized(self): return Fraction(self.value+1, 2)
+    @classmethod
+    def from_normalized(cls, val): return cls(int(val*2-1))
+    def __reduce__(self): return type(self), (self.value,)
+def _check_names(n: tuple[str, ...], k: int|None, p: str):
+    if k is None: k = len(n)
+    elif n: raise ValueError('do not pass k with names')
+    if k < 2: raise ValueError('k should be >= 2')
+    return k, iter(n or map((p+'%s').__mod__, range(k)))
+def _to_members(K: int, N): return {x: Fraction(i, K-1) for i, x in enumerate(N)}
+def gödel_logic(*names, k=None, prefix='x_', clsname=None): K, N = _check_names(names, k, prefix); return _FastEnumLogicMeta(clsname or f'G{K}', (), {'members': _to_members(K, N), '__and__': lambda self, other, /: type(self)(min(self.value, other.value)), '__or__': lambda self, other, /: type(self)(max(self.value, other.value)), '__invert__': lambda self: type(self)(self.value == 0), 'implies': lambda self, other, /: type(self)(1) if self.value <= other.value else other, '__doc__': f"Godel's {K}-valued logic. See https://plato.stanford.edu/entries/logic-manyvalued/#GodLog."})
+G3, SmT = gödel_logic('F', 'NF', 'T'), gödel_logic('F', 'NF', 'T', clsname='SmT')
+def łukasiewicz_logic(*names, k=None, prefix='x_', clsname=None): K, N = _check_names(names, k, prefix); return _FastEnumLogicMeta(clsname or f'L{K}', (), {'members': _to_members(K, N), 'implies': (f := lambda self, other, /: type(self)(1+min(0, other.value-self.value))), '__invert__': lambda self: type(self)(1-self.value), '__and__': lambda self, other, /: f(f(self, other), other), '__or__': lambda self, other, /: ~(~self&~other), 'strong_disjunction': lambda self, other, /: f(~self, other), 'strong_conjunction': lambda self, other, /: ~f(self, ~other), 'diamond': (d := lambda self: f(~self, self)), 'box': lambda self: ~d(~self), 'doubtful': lambda self: self.iff(~self)})
+L3 = łukasiewicz_logic('F', 'U', 'T')
+def post_logic(*names, k=None, prefix='x_', clsname=None): K, N = _check_names(names, k, prefix); U = Fraction(1, K-1); return _FastEnumLogicMeta(clsname or f'P{K}', (), {'members': _to_members(K, N), '__invert__': lambda self: type(self)(v-U if (v := self.value) else 1), '__and__': lambda self, other, /: type(self)(min(self.value, other.value)), '__or__': lambda self, other, /: type(self)(max(self.value, other.value))})
+P3 = post_logic('F', 'U', 'T')
+class B4(metaclass=_FastEnumLogicMeta):
+    members = {'F': 0, 'N': 1, 'B': 2, 'T': 3}
+    def __invert__(self): return self if self in (__class__.B, __class__.N) else type(self)(3-self.value)
+    def __bool__(self): return self.value >= 2
+    def __and__(self, other, /):
+        if (F := __class__.F) in (self, other): return F
+        if self is (T := __class__.T): return other
+        if other is T: return self
+        return self if self is other else F
+    def __or__(self, other, /):
+        if (T := __class__.T) in (self, other): return T
+        if self is (F := __class__.F): return other
+        if other is F: return self
+        return self if self is other else T
+    def implies(self, other, /): return ~self|other
+    def gullibility(self, other, /): return self if self is other else __class__.N
+    def consensus(self, other, /): return self if len(s := {self, other}) == 1 else s.discard(__class__.N) or (s.pop() if len(s) == 1 else __class__.B)
+    def normalized(self): return Fraction(self.value, 3)
+    @classmethod
+    def from_normalized(cls, val): return cls(int(val*3))
+Π, Π_aleph_0 = map(lambda name, meta: meta(name, (), {'__and__': lambda self, other, /: type(self)(self.value*other.value), '__or__': lambda self, other, /: type(self)(min(self.value, other.value)), '__invert__': lambda self: self.implies(type(self).F), 'implies': lambda self, other, /: type(self)(b/a if (a := self.value) > (b := other.value) else 1)}), ('Π', 'Π_aleph_0'), (_DecimalLogicMeta, _RationalLogicMeta))
+G_inf, G_aleph_0 = map(lambda name, meta: meta(name, (), {'__and__': lambda self, other, /: type(self)(self.value*other.value), '__or__': lambda self, other, /: type(self)(min(self.value, other.value)), '__invert__': lambda self: type(self)(self.value == 0), 'implies': lambda self, other, /: type(self).T if self.value <= other.value else other}), ('G_inf', 'G_aleph_0'), (_DecimalLogicMeta, _RationalLogicMeta))
+L_inf, L_aleph_0 = map(lambda name, meta: meta(name, (), {'implies': lambda self, other, /: type(self)(1+min(0, other.value-self.value)), '__invert__': lambda self: type(self)(1-self.value), '__and__': lambda self, other, /: self.implies(other).implies(other), '__or__': lambda self, other, /: ~(~self&~other), 'strong_disjunction': lambda self, other, /: (~self).implies(other), 'strong_conjunction': lambda self, other, /: ~self.implies(~other), 'diamond': lambda self: (~self).implies(self), 'box': lambda self: ~(~self).diamond(), 'doubtful': lambda self: self.iff(~self)}), ('L_inf', 'L_aleph_0'), (_DecimalLogicMeta, _RationalLogicMeta))
+def t_norm_logic(*, name=None, rational=False, **k):
+    def dec(strong_conjunctionf):
+        x, y, z = map(Decimal, ('0.3', '0.7', '0.5'))
+        if strong_conjunctionf(x, y) != strong_conjunctionf(y, x): raise ValueError('t-norm must be commutative')
+        if strong_conjunctionf(x, Decimal(1)) != x: raise ValueError('degree 1 must be neutral element')
+        if strong_conjunctionf(Decimal('0.2'), z) > strong_conjunctionf(x, z): raise ValueError('t-norm must be non-decreasing')
+        def implies(self, other, /):
+            f = Decimal('0.001').__mul__
+            if self is (_ := type(self)).F: return _.T
+            s, u, v = 0, self.value, other.value
+            for i in range(1001):
+                if strong_conjunctionf(u, z := f(i)) <= v: s = z
+            return type(self)(s)
+        return (_RationalLogicMeta if rational else _DecimalLogicMeta)(name or strong_conjunctionf.__name__, (), {'strong_conjunction': lambda self, other, /: type(self)(strong_conjunctionf(self.value, other.value)), 'implies': implies, '__invert__': lambda self: self.implies(self.F), '__and__': lambda self, other: type(self)(min(self.value, other.value)), '__or__': lambda self, other, /: type(self)(max(self.value, other.value))}|k)
+    return dec
+def logic_from_implication(*, name=None, rational=False, **k): return lambda impliesf: (_RationalLogicMeta if rational else _DecimalLogicMeta)(name or impliesf.__name__, (), {'implies': impliesf, '__invert__': lambda self: self.implies(self.F), '__and__': lambda self, other: type(self)(min(self.value, other.value)), '__or__': lambda self, other, /: type(self)(max(self.value, other.value))}|k)
+decimal_t_norm_logic, rational_t_norm_logic, decimal_logic_from_implication, rational_logic_from_implication = t_norm_logic(), t_norm_logic(rational=True), logic_from_implication(), logic_from_implication(rational=True)
+NP, NP_aleph_0 = t_norm_logic(name='NP')(f := lambda u, v: min(u, v) if u+v > 1 else Decimal()), t_norm_logic(name='NP_aleph_0', rational=True)(f)
+class protocols(metaclass=_SubmoduleMeta, _supermodule_default_name_='logics'): __all__, __dir__ = FAKE_PROTOCOLS_TUPLE, (lambda: FAKE_PROTOCOLS_TUPLE)
+for _ in FAKE_PROTOCOLS_TUPLE: setattr(protocols, _, _FakeProtocolMeta(_))

mvlogics/__init__.pyi

@@ -0,0 +1,186 @@
+'''Implementations of various logics, not necessarily with two truth values. A logic is a propositional calculus, with an example being Aristotle's
+logical calculus, where the only truth values are T and F and the law of the excluded middle holds. Logics do not support subclassing, analogously
+to the built-in type bool. Members of all classes in this module are lazily generated to avoid significant memory overhead.'''
+from typing import final, overload, Self, ClassVar, NoReturn, TypeGuard, Callable, Literal, Any
+from fractions import Fraction
+from decimal import Decimal
+from .protocols import MemberlessLogicBase, LogicBase, StrictLogicBase, GödelLogic, ŁukasiewiczLogic, PostLogic, DecimalLogicBase, RationalLogicBase, TNormLogic, RationalTNormLogic, _L
+REQUIRED_ATTRS: frozenset[str]
+RECOMMENDED_METHODS: frozenset[str]
+MIXIN_METHODS: frozenset[str]
+EXTENSION_METHODS: frozenset[str]
+FORBIDDEN: frozenset[str]
+ALL_METHODS: frozenset[str]
+FAKE_PROTOCOLS: frozenset[str]
+ALL_LOGICS: frozenset[str]
+FAKE_PROTOCOLS_TUPLE: tuple[str, ...]
+ALL_LOGICS_TUPLE: tuple[str, ...]
+__all__: tuple[str, ...]
+def convert(member: MemberlessLogicBase, cls: type[_L]) -> _L: ...
+def is_logic(typ: type) -> TypeGuard[type[MemberlessLogicBase[Any]]]: ...
+def is_logic_member(obj: object) -> TypeGuard[MemberlessLogicBase[Any]]: ...
+def is_builtin_logic(typ: type) -> TypeGuard[type[LogicBase[Any]|Unit]]: ...
+def is_builtin_logic_member(obj: object) -> TypeGuard[LogicBase[Any]|Unit]: ...
+@final
+class Unit(MemberlessLogicBase):
+    '''An implementation of a single-valued logic. May be useful as a base case in various recursive operations.'''
+    T: ClassVar[Self]
+    def __new__(cls) -> Self: ...
+    def __and__(self, other: Self, /): ...
+    def __or__(self, other: Self, /) -> Self: ...
+    def __invert__(self) -> Self: ...
+    def box(self) -> Self: ...
+    def diamond(self) -> Self: ...
+    def gullibility(self, other: Self, /) -> Self: ...
+    def consensus(self, other: Self, /) -> Self: ...
+    def __bool__(self) -> NoReturn: ...
+@final
+class Boolean(LogicBase[bool]):
+    '''Boolean or Aristotelian logic, where the law of the excluded middle holds.
+    Actually just a wrapper around the built-in class bool which satisfies the interface.'''
+    T: ClassVar[Self]
+    F: ClassVar[Self]
+    def __and__(self, other: Self, /) -> Self: ...
+    def __or__(self, other: Self, /) -> Self: ...
+    def __invert__(self) -> Self: ...
+    def box(self) -> Self: ...
+    def diamond(self) -> Self: ...
+@final
+class K3(StrictLogicBase[int]):
+    '''Kleene's strong logic of indeterminancy (K_3), in which besides the truth values T and F, a new 'indeterminate' truth value I is introduced.
+    T is the only designated truth value.'''
+    T: ClassVar[Self]
+    I: ClassVar[Self]
+    F: ClassVar[Self]
+    def __and__(self, other: Self, /) -> Self: ...
+    def __or__(self, other: Self, /) -> Self: ...
+    def __invert__(self) -> Self: ...
+    def gullibility(self, other: Self, /): ...
+    def consensus(self, other: Self, /) -> Self: ...
+@final
+class LP(StrictLogicBase[int]):
+    '''Priest's 'logic of paradox' (P_3), provisionally named LP because P_3 refers to ternary Post logic here. The truth tables are equivalent to those of Kleene's, except I is also designated as a truth value. The gullibility operation is thus not as well-defined as in K_3, and in the case that one operand is T and the other F, the arbitrary convention to return F is chosen.'''
+    T: ClassVar[Self]
+    I: ClassVar[Self]
+    F: ClassVar[Self]
+    def __and__(self, other: Self, /) -> Self: ...
+    def __or__(self, other: Self, /) -> Self: ...
+    def __invert__(self) -> Self: ...
+    def gullibility(self, other: Self, /): ...
+    def consensus(self, other: Self, /) -> Self: ...
+@final
+class BI3(StrictLogicBase[int]):
+    '''Dmitry Bochvar's internal three-value logic, also known as Kleene's weak three-value logic. The indeterminate truth value is contagious in the sense that it propagates as the result of any operation that involves it.'''
+    T: ClassVar[Self]
+    I: ClassVar[Self]
+    F: ClassVar[Self]
+    def __and__(self, other: Self, /) -> Self: ...
+    def __or__(self, other: Self, /) -> Self: ...
+    def __invert__(self) -> Self: ...
+    def gullibility(self, other: Self, /): ...
+    def consensus(self, other: Self, /) -> Self: ...
+@final
+class RM3(LogicBase[int]):
+    '''The R-mingle 3 logic, whose significance lies in its material implication implementation. The axiom of weakening does not hold in RM3.'''
+    T: ClassVar[Self]
+    B: ClassVar[Self]
+    F: ClassVar[Self]
+    def __and__(self, other: Self, /) -> Self: ...
+    def __or__(self, other: Self, /) -> Self: ...
+    def __invert__(self) -> Self: ...
+@final
+class B4(StrictLogicBase[int]):
+    '''Belnap's logic B_4, a combination of K_3 and P_3, such that the overdetermined I is called B for 'both', and the underdetermined N for 'neither' The truth tables are derived accordingly.'''
+    T: ClassVar[Self]
+    B: ClassVar[Self]
+    N: ClassVar[Self]
+    F: ClassVar[Self]
+    def __and__(self, other: Self, /) -> Self: ...
+    def __or__(self, other: Self, /) -> Self: ...
+    def __invert__(self) -> Self: ...
+    def gullibility(self, other: Self, /): ...
+    def consensus(self, other: Self, /) -> Self: ...
+@final
+class SmT(GödelLogic):
+    '''Smetanov logic, also known as the logic of here and there and Gödel G3 logic. Introduced by Arend Heyting in 1930 to study intuitionistic logic, it is a three-valued intermediate logic where the intermediate value can be understood as 'not false'.'''
+    T: ClassVar[Self]
+    NF: ClassVar[Self]
+    F: ClassVar[Self]
+@final
+class G3(GödelLogic):
+    '''A three-valued logic of Gödel's, also known as Smetanov logic and the logic of here and there. Belongs to a larger family of 'Gödel' logics G_k with truth values 0, 1/(k-1), 2/(k-1), ..., (k-2)/(k-1), 1, with 1 designated as a 'true' truth value.'''
+    T: ClassVar[Self]
+    NF: ClassVar[Self]
+    F: ClassVar[Self]
+@final
+class L3(ŁukasiewiczLogic):
+    '''Jan Łukasiewicz's three-valued logic; the truth values for 0, 1/2, 1 are called F, U and T respectively.'''
+    T: ClassVar[Self]
+    U: ClassVar[Self]
+    F: ClassVar[Self]
+@final
+class P3(PostLogic):
+    '''Ternary Post logic, with a cyclic implementation of the negation operator.'''
+    T: ClassVar[Self]
+    U: ClassVar[Self]
+    F: ClassVar[Self]
+@final
+class Π(DecimalLogicBase): '''Product logic, with truth values between 0 and 1. For precision, please pass in a string (e.g. '3.14159' instead of 3.14159) to the constructor; however, passing an int, float or decimal.Decimal instance is also acceptable.'''
+@final
+class G_inf(DecimalLogicBase): '''Gödel's infinite-valued logic, with real numbers between 0 and 1 as truth values.'''
+@final
+class L_inf(DecimalLogicBase):
+    '''Łukasiewicz's infinite-valued logic, with real numbers between 0 and 1 as truth values.'''
+    def strong_disjunction(self, other: Self, /) -> Self: ...
+    def strong_conjunction(self, other: Self, /) -> Self: ...
+    def diamond(self) -> Self: ...
+    def box(self) -> Self: ...
+    def doubtful(self) -> Self: ...
+@final
+class NP(TNormLogic): '''A t-norm logic with the nilpotent minimum norm as the implication operator.'''
+@final
+class Π_aleph_0(RationalLogicBase): '''Product logic, with rational numbers between 0 and 1 as truth values. Pass in what Fraction takes to the constructor.'''
+@final
+class G_aleph_0(RationalLogicBase): '''Gödel's infinite-valued logic, with rational numbers between 0 and 1 as truth values.'''
+@final
+class L_aleph_0(RationalLogicBase):
+    '''Łukasiewicz's infinite-valued logic, with rational numbers between 0 and 1 as truth values.'''
+    def strong_disjunction(self, other: Self, /) -> Self: ...
+    def strong_conjunction(self, other: Self, /) -> Self: ...
+    def diamond(self) -> Self: ...
+    def box(self) -> Self: ...
+    def doubtful(self) -> Self: ...
+@final
+class NP_aleph_0(RationalTNormLogic): '''A t-norm logic with the nilpotent minimum norm as the implication operator and rational truth values only.'''
+@overload
+def gödel_logic(name_1: str, name_2: str, /, *names: str, clsname: str|None=...) -> type[GödelLogic]: '''Returns a Gödel logic class with name clsname and truth values of names name_1 (0), name_2 (1/(k-1)), ..., name_(k-1) ((k-2)/(k-1)), name_k (1).'''
+@overload
+def gödel_logic(*, k: int, prefix: str='x_', clsname: str|None=...) -> type[GödelLogic]: ...
+@overload
+def łukasiewicz_logic(name_1: str, name_2: str, /, *names: str, clsname: str|None=...) -> type[ŁukasiewiczLogic]: '''Returns a Łukasiewicz logic class with name clsname and truth values of names name_1 (0), name_2 (1/(k-1)), ..., name_(k-1) ((k-2)/(k-1)), name_k (1).'''
+@overload
+def łukasiewicz_logic(*, k: int, prefix: str='x_', clsname: str|None=...) -> type[ŁukasiewiczLogic]: ...
+@overload
+def post_logic(name_1: str, name_2: str, /, *names: str, clsname: str|None=...) -> type[PostLogic]: '''Returns a Postlogic class with name `clsname` and truth values of names `name_1` (0), `name_2` (1/(k-1)), ..., `name_(k-1)` ((k-2)/(k-1)), `name_k` (1).'''
+@overload
+def post_logic(*, k: int, prefix: str='x_', clsname: str|None=...) -> type[PostLogic]: ...
+@overload
+def t_norm_logic(*, name: str, rational: Literal[False]=False, **additional: Any) -> Callable[[Callable[[Decimal, Decimal], Decimal]], type[TNormLogic]]: '''A decorator factory whose products return t-norm logic classes given the strong conjunction operator, given whether the members should be constrained to rational numbers.'''
+@overload
+def t_norm_logic(*, name: str, rational: Literal[True], **additional: Any) -> Callable[[Callable[[Fraction, Fraction], Fraction]], type[RationalTNormLogic]]: ...
+@overload
+def t_norm_logic(*, rational: Literal[False]=False, **additional: Any) -> Callable[[Callable[[Decimal, Decimal], Decimal]], type[TNormLogic]]: ...
+@overload
+def t_norm_logic(*, rational: Literal[True], **additional: Any) -> Callable[[Callable[[Fraction, Fraction], Fraction]], type[RationalTNormLogic]]: ...
+@overload
+def logic_from_implication(*, name: str, rational: Literal[False]=False, **additional: Any) -> Callable[[Callable[[Decimal, Decimal], Decimal]], type[DecimalLogicBase]]: '''A decorator factory whose products return logic classes given the implication operator only, given whether the members should be constrained to rational numbers.'''
+@overload
+def logic_from_implication(*, name: str, rational: Literal[True], **additional: Any) -> Callable[[Callable[[Fraction, Fraction], Fraction]], type[RationalLogicBase]]: ...
+@overload
+def logic_from_implication(*, rational: Literal[False]=False, **additional: Any) -> Callable[[Callable[[Decimal, Decimal], Decimal]], type[DecimalLogicBase]]: ...
+@overload
+def logic_from_implication(*, rational: Literal[True], **additional: Any) -> Callable[[Callable[[Fraction, Fraction], Fraction]], type[RationalLogicBase]]: ...
+def decimal_t_norm_logic(strong_conjunctionf: Callable[[Decimal, Decimal], Decimal]) -> type[TNormLogic]: '''Version of t_norm_logic specific to decimals.'''
+def rational_t_norm_logic(strong_conjunctionf: Callable[[Fraction, Fraction], Fraction]) -> type[RationalTNormLogic]: '''Version of t_norm_logic specific to fractions.'''
+def decimal_logic_from_implication(impliesf: Callable[[Decimal, Decimal], Decimal]) -> type[DecimalLogicBase]: '''Version of logic_from_implication specific to decimals.'''
+def rational_logic_from_implication(impliesf: Callable[[Fraction, Fraction], Fraction]) -> type[RationalLogicBase]: '''Version of logic_from_implication specific to fractions.'''

mvlogics/base.py

@@ -0,0 +1,108 @@
+import sys
+from weakref import WeakKeyDictionary
+from fractions import Fraction
+from decimal import Decimal, getcontext
+def _weak_cache(name=None):
+    def dec(f):
+        def g(self, _=WeakKeyDictionary()):
+            if (r := _.get(self, s := _SlowEnumLogicMeta.MemberContainer._NOT_GENERATED)) is s: _[self] = r = f(self)
+            return r
+        g.__name__ = name or f.__name__; return g
+    return dec
+_normalized_cache, _repr_cache = map(_weak_cache, ('normalized', '__repr__'))
+REQUIRED_ATTRS, FORBIDDEN = map(frozenset, (('__and__', '__or__', '__invert__'), ('__new__', 'value')))
+(_singleton_new := lambda cls: _singleton_new.cache.get(cls, False) or object.__new__(cls)).cache, getcontext().prec = WeakKeyDictionary(), 100
+_all, ALL_METHODS, ALL_LOGICS, FAKE_PROTOCOLS = ('ALL_METHODS', 'FORBIDDEN', 'ALL_LOGICS', 'ALL_LOGICS_TUPLE', 'FAKE_PROTOCOLS', 'FAKE_PROTOCOLS_TUPLE', 'REQUIRED_ATTRS', 'RECOMMENDED_METHODS', 'MIXIN_METHODS', 'EXTENSION_METHODS', 'protocols', 'is_logic', 'is_logic_member', 'is_builtin_logic', 'is_builtin_logic_member', 'convert', 'gödel_logic', 'łukasiewicz_logic', 'post_logic', 't_norm_logic', 'logic_from_implication', 'decimal_t_norm_logic', 'rational_t_norm_logic', 'decimal_logic_from_implication', 'rational_logic_from_implication', *(ALL_LOGICS_TUPLE := ('Unit', 'Boolean', 'K3', 'LP', 'BI3', 'RM3', 'G3', 'SmT', 'L3', 'P3', 'B4', 'Π', 'Π_aleph_0', 'G_inf', 'G_aleph_0', 'L_inf', 'L_aleph_0', 'NP', 'NP_aleph_0'))), REQUIRED_ATTRS|(RECOMMENDED_METHODS := frozenset(('implies', '__bool__', 'gullibility', 'consensus')))|(MIXIN_METHODS := frozenset(('iff', 'implies', '__pos__', '__neg__', '__xor__', 'value', 'nand', 'nor', 'xnor', 'abjunction', 'converse_implies', 'converse_abjunction')))|(EXTENSION_METHODS := frozenset(('strong_disjunction', 'strong_conjunction', 'diamond', 'box', 'doubtful'))), frozenset(ALL_LOGICS_TUPLE), frozenset(FAKE_PROTOCOLS_TUPLE := ('MemberlessLogicBase', 'AbstractLogicBase', 'LogicBase', 'InfiniteLogicBase', 'DecimalLogicBase', 'RationalLogicBase', 'StrictLogicBase', 'GödelLogic', 'ŁukasiewiczLogic', 'PostLogic', 'TNormLogic', 'RationalTNormLogic'))
+class _SubmoduleMeta(type):
+    def __new__(mcls, name, bases, namespace, /, *, _supermodule_default_name_='<unknown>'):
+        if bases: raise TypeError('Submodule cannot inherit from other classes')
+        try: name = f'{sys._getframemodulename(1) or _supermodule_default_name_}.{name}'
+        except AttributeError: name = f'{_supermodule_default_name_}.{name}'
+        sys.modules[name] = r = type(sys)(name, namespace.pop('__doc__', None)); return r
+class _AllLogicMeta(type):
+    __defaults, __repr__ = None, _repr_cache(lambda cls: f'logics.{cls.__name__}')
+    def __new__(mcls, name, bases, namespace, /, **k):
+        if bases: raise ValueError('logics cannot inherit from anything')
+        if not REQUIRED_ATTRS.issubset(namespace): raise TypeError('missing methods')
+        return super().__new__(mcls, name, bases, mcls.__default_factory__()|namespace, **k)
+    @classmethod
+    def __default_factory__(mcls):
+        if (r := mcls.__defaults) is None: mcls.__defaults = r = {'__xor__': lambda self, other, /: (self&~other)|(other&~self), 'implies': lambda self, other, /: ~self|other, 'iff': (g := lambda self, other: self.implies(other)&other.implies(self)), 'nand': lambda self, other, /: ~(self&other), 'nor': lambda self, other, /: ~(self|other), 'xnor': g, 'abjunction': lambda self, other, /: ~self.implies(other), 'converse_implies': lambda self, other, /: self|~other, 'converse_abjunction': lambda self, other, /: other&~self, '__bool__': lambda self: self.value == 1, '__pos__': lambda self: self, 'normalized': _normalized_cache(lambda self: Fraction(self.value)), 'from_normalized': classmethod(lambda cls, val: cls(val)), 'from_logic_member': classmethod(lambda cls, member: cls.from_normalized(member.normalized())), 'convert_to': lambda self, cls: cls.from_normalized(self.normalized())}
+        return r
+class _InfLogicMetaBase(_AllLogicMeta):
+    @property
+    def T(cls): return cls.from_normalized(Fraction(1))
+    @property
+    def F(cls): return cls.from_normalized(Fraction())
+    verum, falsum = T, F
+    @classmethod
+    def _ret_new_and_value(mcls): raise NotImplementedError('do not use this metaclass; inherit from it and implement this method or use either _DecimalLogicMeta or _RationalLogicMeta')
+    @classmethod
+    def __default_factory__(mcls): return _AllLogicMeta.__default_factory__()|{'members': {}, '__repr__': _repr_cache(lambda self: f'{type(self).__name__}({self.value})')}|mcls._ret_new_and_value()
+class _DecimalLogicMeta(_InfLogicMetaBase):
+    @classmethod
+    def _ret_new_and_value(mcls):
+        _ = WeakKeyDictionary()
+        def __new__(cls, val='0', /):
+            if (v := (c := cls.members).get(d := Decimal(val), None)) is None: c[d] = v = object.__new__(cls); _[v] = d
+            return v
+        return {'__new__': __new__, 'value': property(_.__getitem__)}
+class _RationalLogicMeta(_InfLogicMetaBase):
+    @classmethod
+    def _ret_new_and_value(mcls):
+        _ = WeakKeyDictionary()
+        def __new__(cls, /, *a):
+            if (v := (c := cls.members).get(f := Fraction(*a), None)) is None: c[f] = v = object.__new__(cls); _[v] = f
+            return v
+        return {'__new__': __new__, 'value': property(_.__getitem__)}
+class _SlowEnumLogicMeta(_AllLogicMeta):
+    class MemberContainer:
+        __cache, __cache2, _NOT_GENERATED = WeakKeyDictionary(), WeakKeyDictionary(), type('NotGenerated', (), {'__new__': _singleton_new, '__repr__': lambda _, /: '<not generated>'})()
+        def __init__(self, values): self.__values, self.value_from_name, self.name_from_value, self.names = dict.fromkeys(values.values(), self._NOT_GENERATED), values.__getitem__, {v: k for k, v in values.items()}.__getitem__, tuple(values.keys())
+        def generate(self, value):
+            if (x := self.__values[value]) is self._NOT_GENERATED: self.__values[value] = x = object.__new__(self.typ); self.__cache[x], self.__cache2[x] = value, self.name_from_value(value)
+            return x
+        def from_name(self, name):
+            if (x := self.__values[v := self.value_from_name(name)]) is self._NOT_GENERATED: self.__values[v] = x = object.__new__(self.typ); self.__cache[x], self.__cache2[x] = v, name
+            return x
+        def member_values(self): yield from self.__values.keys()
+        def __set_name__(self, owner, name, /): assert name == 'members'; self.typ = owner
+        @_repr_cache
+        def __repr__(self): return f'({', '.join(map(lambda i: str(self.generate(i)), self.__values))})'
+        def __iter__(self): yield from map(self.generate, self.__values)
+    def __getattr__(cls, name, /):
+        if name in cls.members.names: super().__setattr__(name, r := cls(name)); return r
+        raise AttributeError(f'class {cls.__name__} has no attribute {name!r}')
+    def __setattr__(cls, name, value, /):
+        if name in cls.members.names: raise TypeError(f'attribute {name!r} is read-only')
+        super().__setattr__(name, value)
+    def __new__(mcls, name, bases, namespace, /, **k):
+        if FORBIDDEN.intersection(namespace): raise TypeError('attempted to override forbidden attributes')
+        c = mcls.MemberContainer(namespace['members']); return super().__new__(mcls, name, bases, {'__repr__': _repr_cache(lambda self: f'{type(self).__name__}.{self.name}'), 'value': property(c._MemberContainer__cache.__getitem__), 'name': property(c._MemberContainer__cache2.__getitem__), '__neg__': namespace['__invert__']}|namespace|{'members': c, '__new__': lambda cls, v, /: c.from_name(v) if isinstance(v, str) else c.generate(v)}, **k)
+class _FastEnumLogicMeta(_SlowEnumLogicMeta):
+    class MemberContainer(_SlowEnumLogicMeta.MemberContainer):
+        @_repr_cache
+        def __repr__(self): return f'({(n := self.typ.__name__)}.{f', {n}.'.join(self.names)})'
+class _FakeProtocolMeta(type):
+    _cache, _meta_map, _requirement_map, _prefix_map, _mcont_allowed = [None]*12, (_AllLogicMeta, _AllLogicMeta, _SlowEnumLogicMeta, _InfLogicMetaBase, _DecimalLogicMeta, _RationalLogicMeta, _SlowEnumLogicMeta, _FastEnumLogicMeta, _FastEnumLogicMeta, _FastEnumLogicMeta, _DecimalLogicMeta, _RationalLogicMeta), tuple(map(frozenset, ((), ('values',), ('members', 'values'), (), (), (), ('gullibility', 'consensus'), (), ('strong_disjunction', 'strong_conjunction', 'diamond', 'box', 'doubtful'), (), ('strong_conjunction',), ('strong_conjunction',)))), ('', '', '', '', '', '', '', 'G', 'L', 'P', '', ''), frozenset((2, 6, 7, 8, 9))
+    def __new__(mcls, name, bases=(), namespace={}, /, **k):
+        try: r = (c := mcls._cache)[i := FAKE_PROTOCOLS_TUPLE.index(name)]
+        except ValueError: raise TypeError(f'cannot create protocol class with name {name!r}') from None
+        def __init_subclass__(_, /): raise TypeError(f'cannot inherit from protocol class {name!r}')
+        def __new__(*_): raise TypeError(f'cannot create instance of protocol {name!r}')
+        namespace['__init_subclass__'], namespace['__new__'] = __init_subclass__, __new__
+        if r is None: c[i] = r = super().__new__(mcls, name, bases, namespace, **k); r._idx, r._meth_cache = i, {}
+        return r
+    def __getattr__(cls, name, /):
+        if name == 'MemberContainer' and cls._idx in cls._mcont_allowed:
+            class MemberContainer(_FastEnumLogicMeta.MemberContainer):
+                def __new__(cls, values): raise TypeError(f'cannot instantiate MemberContainer with values {values!r}')
+                def __init_subclass__(cls): raise TypeError('cannot subclass MemberContainer')
+            cls.MemberContainer = MemberContainer; return MemberContainer
+        if name in ALL_METHODS:
+            if (r := (c := cls._meth_cache).get(name)) is None: exec('@property\n'*(name == 'value')+f'def {name}(*_): raise NotImplementedError("method {name!r} of protocol {cls.__name__!r} is abstract")', locals=c); r = c[name]
+            return r
+        raise AttributeError(f'class {cls.__name__!r} has no attribute {name!r}')
+    def __init_subclass__(mcls, /, **_): raise TypeError('cannot subclass _FakeProtocolMeta')
+    def __instancecheck__(cls, instance): return cls.__subclasscheck__(type(instance))
+    def __subclasscheck__(cls, sub): return isinstance(sub, cls._meta_map[i := cls._idx]) and sub.__name__.startswith(cls._prefix_map[i]) and (cls._requirement_map[i]|MIXIN_METHODS).issubset(sub.__dict__)   

mvlogics/protocols.pyi

@@ -0,0 +1,89 @@
+from typing import final, overload, Final, Generic, TypeVar, Self, Any, Generator, ClassVar, Sequence, TYPE_CHECKING
+from fractions import Fraction
+from decimal import Decimal
+if TYPE_CHECKING:
+    _T = TypeVar('_T')
+    _L = TypeVar('_L', bound=MemberlessLogicBase)
+    _R = TypeVar('_R', bound=LogicBase)
+class MemberlessLogicBase(Generic[_T]):
+    @classmethod
+    def from_normalized(cls, val: Fraction) -> Self: ...
+    @classmethod
+    def from_logic_member(cls, member: MemberlessLogicBase[Any]) -> Self: ...
+    def __and__(self, other: Self, /) -> Self: ...
+    def __or__(self, other: Self, /) -> Self: ...
+    def __invert__(self) -> Self: ...
+    def __pos__(self) -> Self: ...
+    def __neg__(self) -> Self: ...
+    def __xor__(self) -> Self: ...
+    def implies(self, other: Self, /) -> Self: ...
+    def iff(self, other: Self, /) -> Self: ...
+    def nor(self, other: Self, /) -> Self: ...
+    def nand(self, other: Self, /) -> Self: ...
+    def xnor(self, other: Self, /) -> Self: ...
+    def abjunction(self, other: Self, /) -> Self: ...
+    def converse_implies(self, other: Self, /) -> Self: ...
+    def converse_abjunction(self, other: Self, /) -> Self: ...
+    def normalized(self) -> Fraction: ...
+    def convert_to(self, cls: type[_L]) -> _L: ...
+class AbstractLogicBase(MemberlessLogicBase[_T]):
+    @property
+    def value(self) -> _T: ...
+    def __new__(cls, v: _T, /) -> Self: ...
+class LogicBase(AbstractLogicBase[_T]):
+    @final
+    class MemberContainer(Generic[_R]):
+        @property
+        def names(self) -> tuple[str, ...]: '''Is not a property at runtime.'''
+        def __init__(self, values: dict[str, _T]): ...
+        def generate(self, value: _T) -> _R: ...
+        def from_name(self, name: str) -> _R: ...
+        def value_from_name(self, name: str, /) -> _T: ...
+        def name_from_value(self, value: _T, /) -> str: ...
+        def member_values(self) -> Generator[_T, None, None]: ...
+        def __set_name__(self, owner: type, name: str, /) -> None: ...
+        def __iter__(self) -> Generator[_R, None, None]: ...
+    members: Final[MemberContainer[Self]]
+class InfiniteLogicBase(AbstractLogicBase[_T]):
+    T: ClassVar[Self]
+    F: ClassVar[Self]
+    verum: ClassVar[Self]
+    falsum: ClassVar[Self]
+    members: Final[dict[_T, Self]]
+class DecimalLogicBase(InfiniteLogicBase[Decimal]):
+    @overload
+    def __new__(cls, v: Decimal, /) -> Self: ...
+    @overload
+    def __new__(cls, v: float, /) -> Self: ...
+    @overload
+    def __new__(cls, v: str, /) -> Self: ...
+    @overload
+    def __new__(cls, v: tuple[int, Sequence[int], int], /) -> Self: ...
+class RationalLogicBase(InfiniteLogicBase[Fraction]):
+    @overload
+    def __new__(cls, num: int, /) -> Self: ...
+    @overload
+    def __new__(cls, arg: str, /) -> Self: ...
+    @overload
+    def __new__(cls, num: float, /) -> Self: ...
+    @overload
+    def __new__(cls, num: Fraction, /) -> Self: ...
+    @overload
+    def __new__(cls, num: Decimal, /) -> Self: ...
+    @overload
+    def __new__(cls, num: int, dem: int, /) -> Self: ...
+class StrictLogicBase(LogicBase[_T]):
+    def gullibility(self, other: Self, /) -> Self: ...
+    def consensus(self, other: Self, /) -> Self: ...
+class GödelLogic(LogicBase[Fraction]): ...
+class ŁukasiewiczLogic(LogicBase[Fraction]):
+    def strong_disjunction(self, other: Self, /) -> Self: ...
+    def strong_conjunction(self, other: Self, /) -> Self: ...
+    def diamond(self) -> Self: ...
+    def box(self) -> Self: ...
+    def doubtful(self) -> Self: ...
+class PostLogic(LogicBase[Fraction]): ...
+class TNormLogic(DecimalLogicBase):
+    def strong_conjunction(self, other: Self, /) -> Self: ...
+class RationalTNormLogic(RationalLogicBase):
+    def strong_conjunction(self, other: Self, /) -> Self: ...

mvlogics-0.9.0.dist-info/METADATA

@@ -0,0 +1,20 @@
+Metadata-Version: 2.4
+Name: mvlogics
+Version: 0.9.0
+Summary: Multi-valued logics.
+Author-email: Jonathan Dung <jonathandung@yahoo.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/jonathandung/mvlogics
+Project-URL: Repository, https://github.com/jonathandung/mvlogics.git
+Keywords: mathematical,object-oriented
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: black; extra == "dev"
+Requires-Dist: flake8; extra == "dev"
+Dynamic: license-file
+
+# mvlogics

mvlogics-0.9.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+mvlogics/__init__.py,sha256=X112Qek4azgNyP6gAuNjgRckWOT8CUFd0cmC7a6htyc,11157
+mvlogics/__init__.pyi,sha256=0y95DYMI4TgYRRcL1gz4nikevsq73plv95Zk4iBItIk,11802
+mvlogics/base.py,sha256=YldQA3vClpPMhGcuZQDSJToce7hTyuhMl3qWPFsGnvE,10553
+mvlogics/protocols.pyi,sha256=vb1E7-LvYTY_9L2FZM46WBdmtIhWpgUkMc1Z3fnNXI0,3850
+mvlogics-0.9.0.dist-info/licenses/LICENSE,sha256=DIVhmXv1QFIoykQd8zmb-hEQ4vDvDBi3oteSatFMF-I,1089
+mvlogics-0.9.0.dist-info/METADATA,sha256=2uXUL3bBbKANPJe9r5b3ARE4NoR_ixm1YfMdFnCSKHw,661
+mvlogics-0.9.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+mvlogics-0.9.0.dist-info/top_level.txt,sha256=MEu4A_SLEh1sNkT89LhUa6Of2MzOCMowEKfFJjpeR_E,9
+mvlogics-0.9.0.dist-info/RECORD,,

mvlogics-0.9.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

mvlogics-0.9.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jonathan Dung
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

mvlogics-0.9.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+mvlogics