evidencelib 1.0.0__py3-none-any.whl

evidencelib/__init__.py

@@ -0,0 +1,8 @@
+"""Belief-function calculations for DST and DSmT."""
+
+from evidencelib.frame import Frame
+from evidencelib.mass import MassFunction
+from evidencelib.proposition import Proposition
+
+__all__ = ["Frame", "MassFunction", "Proposition"]
+

evidencelib/exceptions.py

@@ -0,0 +1,14 @@
+"""Package-specific exceptions."""
+
+
+class EvidenceLibError(Exception):
+    """Base exception for evidencelib."""
+
+
+class InvalidMassError(EvidenceLibError, ValueError):
+    """Raised when a mass assignment is invalid."""
+
+
+class TotalConflictError(EvidenceLibError, ZeroDivisionError):
+    """Raised when normalized combination is undefined due to total conflict."""
+

evidencelib/frame.py

@@ -0,0 +1,198 @@
+"""Frames of discernment for DST and DSmT."""
+
+from __future__ import annotations
+
+from itertools import combinations
+from typing import Iterable, Iterator, Mapping, Sequence
+
+from evidencelib.parser import PropositionParser
+from evidencelib.proposition import Proposition
+
+
+class Frame:
+    """A finite frame of discernment.
+
+    The internal representation uses Venn regions. This lets the same
+    proposition algebra represent Shafer's exclusive DST model, the free DSmT
+    model, and constrained hybrid DSm models.
+    """
+
+    def __init__(
+        self,
+        atoms: Sequence[str],
+        *,
+        empty: Iterable[str | Proposition] = (),
+        exclusive: bool | Iterable[Sequence[str]] = False,
+        model: str = "hybrid",
+    ) -> None:
+        if not atoms:
+            raise ValueError("A frame needs at least one atom.")
+        if len(set(atoms)) != len(atoms):
+            raise ValueError("Frame atom names must be unique.")
+
+        self.atoms = tuple(atoms)
+        self.model = model
+        self._index = {name: i for i, name in enumerate(self.atoms)}
+        self._full_universe = frozenset(range(1, 1 << len(self.atoms)))
+        self._impossible_regions: set[int] = set()
+        self._universe = self._full_universe
+
+        constraints: list[str | Proposition] = []
+        if exclusive is True:
+            constraints.extend("&".join(pair) for pair in combinations(self.atoms, 2))
+        elif exclusive:
+            constraints.extend("&".join(group) for group in exclusive)
+        constraints.extend(empty)
+
+        for constraint in constraints:
+            prop = self._parse_free(constraint)
+            self._impossible_regions.update(prop.regions)
+            self._universe = frozenset(self._full_universe - self._impossible_regions)
+
+        self.empty = Proposition(self, frozenset())
+        self.total = Proposition(self, self._universe)
+
+    @classmethod
+    def dst(cls, atoms: Sequence[str]) -> "Frame":
+        """Create Shafer's DST model with mutually exclusive hypotheses."""
+
+        return cls(atoms, exclusive=True, model="dst")
+
+    @classmethod
+    def dsmt(cls, atoms: Sequence[str]) -> "Frame":
+        """Create the free DSm model where hypotheses may overlap."""
+
+        return cls(atoms, model="dsmt")
+
+    @classmethod
+    def hybrid(
+        cls,
+        atoms: Sequence[str],
+        *,
+        empty: Iterable[str | Proposition] = (),
+        exclusive: bool | Iterable[Sequence[str]] = False,
+    ) -> "Frame":
+        """Create a constrained DSm model."""
+
+        return cls(atoms, empty=empty, exclusive=exclusive, model="hybrid")
+
+    def symbols(self, names: str | None = None) -> tuple[Proposition, ...]:
+        """Return atom propositions.
+
+        ``names`` may be omitted to return all frame atoms, or supplied as a
+        whitespace/comma-separated subset.
+        """
+
+        if names is None:
+            selected = self.atoms
+        else:
+            selected = tuple(part for part in names.replace(",", " ").split() if part)
+        return tuple(self.atom(name) for name in selected)
+
+    def atom(self, name: str) -> Proposition:
+        if name not in self._index:
+            raise KeyError(f"Unknown frame atom: {name!r}")
+        bit = 1 << self._index[name]
+        return Proposition(self, frozenset(r for r in self._universe if r & bit))
+
+    def proposition(self, value: str | Proposition | Iterable[str]) -> Proposition:
+        """Coerce a string, proposition, or iterable of atoms into a proposition."""
+
+        if isinstance(value, Proposition):
+            if value.frame is not self:
+                raise ValueError("Proposition belongs to a different frame.")
+            return value
+        if isinstance(value, str):
+            return self._parse(value)
+        prop = self.empty
+        for atom in value:
+            prop = prop | self.atom(atom)
+        return prop
+
+    def mass(self, values: Mapping[str | Proposition | Iterable[str], float], **kwargs):
+        from evidencelib.mass import MassFunction
+
+        return MassFunction(self, values, **kwargs)
+
+    @property
+    def region_count(self) -> int:
+        """Number of non-empty disjoint Venn regions in the current model."""
+
+        return len(self._universe)
+
+    def elements(self, *, max_count: int | None = 100_000) -> tuple[Proposition, ...]:
+        """Generate the model's closure under union and intersection.
+
+        The result is the power set for DST and the hyper-power set for the free
+        DSm model. DSmT cardinality grows very quickly; pass ``max_count=None``
+        only when you really want the full closure.
+        """
+
+        elements = {self.empty, *self.symbols()}
+        changed = True
+        while changed:
+            changed = False
+            current = tuple(elements)
+            for left in current:
+                for right in current:
+                    for combined in (left | right, left & right):
+                        if combined not in elements:
+                            elements.add(combined)
+                            changed = True
+                            if max_count is not None and len(elements) > max_count:
+                                raise RuntimeError(
+                                    "Element generation exceeded max_count; "
+                                    "DSmT hyper-power sets grow very quickly."
+                                )
+        return tuple(sorted(elements, key=lambda p: (len(p.regions), str(p))))
+
+    def format(self, prop: Proposition) -> str:
+        if not prop.regions:
+            return "empty"
+
+        terms = self._minimal_terms(prop.regions)
+        rendered_terms = []
+        for term in terms:
+            names = [name for i, name in enumerate(self.atoms) if term & (1 << i)]
+            rendered_terms.append("&".join(names))
+        return "|".join(rendered_terms)
+
+    def _normalize_regions(self, regions: Iterable[int]) -> frozenset[int]:
+        return frozenset(r for r in regions if r in self._universe)
+
+    def _parse_free(self, value: str | Proposition) -> Proposition:
+        old_universe = self._universe
+        self._universe = self._full_universe
+        try:
+            return self._parse(value)
+        finally:
+            self._universe = old_universe
+
+    def _parse(self, value: str | Proposition) -> Proposition:
+        if isinstance(value, Proposition):
+            if value.frame is not self:
+                raise ValueError("Proposition belongs to a different frame.")
+            return value
+
+        try:
+            result = PropositionParser(self).parse(value)
+        except Exception as exc:  # pragma: no cover - exception message is the value.
+            raise ValueError(f"Could not parse proposition {value!r}") from exc
+        return result
+
+    def _minimal_terms(self, regions: Iterable[int]) -> tuple[int, ...]:
+        region_set = set(regions)
+        terms: list[int] = []
+        for region in sorted(region_set, key=lambda r: (r.bit_count(), r)):
+            if any((term & region) == term for term in terms):
+                continue
+            upward = {r for r in self._universe if (r & region) == region}
+            if upward & region_set:
+                terms.append(region)
+        return tuple(terms)
+
+    def __iter__(self) -> Iterator[Proposition]:
+        return iter(self.symbols())
+
+    def __repr__(self) -> str:
+        return f"Frame({self.atoms!r}, model={self.model!r})"

evidencelib/mass.py

@@ -0,0 +1,305 @@
+"""Mass functions and fusion rules."""
+
+from __future__ import annotations
+
+from itertools import product
+from math import prod
+from typing import Iterable, Iterator, Mapping
+
+from evidencelib.exceptions import InvalidMassError, TotalConflictError
+from evidencelib.proposition import Proposition
+
+
+class MassFunction:
+    """A basic belief assignment over a frame."""
+
+    normalization_tolerance = 1e-6
+
+    def __init__(
+        self,
+        frame,
+        values: Mapping[str | Proposition | Iterable[str], float],
+        *,
+        validate: bool = True,
+        tolerance: float = 1e-9,
+    ) -> None:
+        self.frame = frame
+        self.tolerance = tolerance
+        masses: dict[Proposition, float] = {}
+        for key, value in values.items():
+            prop = frame.proposition(key)
+            mass = float(value)
+            if mass < -tolerance:
+                raise InvalidMassError("Mass values must be non-negative.")
+            if abs(mass) <= tolerance:
+                continue
+            masses[prop] = masses.get(prop, 0.0) + mass
+        self._masses = self._clean(masses)
+        if validate:
+            self._validate_sum()
+
+    def __getitem__(self, key: str | Proposition | Iterable[str]) -> float:
+        return self.mass(key)
+
+    def __iter__(self) -> Iterator[tuple[Proposition, float]]:
+        return iter(self.items())
+
+    def __repr__(self) -> str:
+        body = ", ".join(f"{prop}: {value:.6g}" for prop, value in self.items())
+        return f"MassFunction({{{body}}})"
+
+    def items(self) -> tuple[tuple[Proposition, float], ...]:
+        return tuple(sorted(self._masses.items(), key=lambda item: str(item[0])))
+
+    def focal(self) -> tuple[Proposition, ...]:
+        return tuple(prop for prop, _ in self.items())
+
+    def to_dict(self, *, string_keys: bool = True) -> dict[str | Proposition, float]:
+        """Return the mass assignment as a plain dictionary."""
+
+        if string_keys:
+            return {str(prop): value for prop, value in self.items()}
+        return dict(self.items())
+
+    @property
+    def total_mass(self) -> float:
+        """Sum of all stored masses."""
+
+        return sum(self._masses.values())
+
+    def mass(self, key: str | Proposition | Iterable[str]) -> float:
+        return self._masses.get(self.frame.proposition(key), 0.0)
+
+    def belief(self, key: str | Proposition | Iterable[str]) -> float:
+        target = self.frame.proposition(key)
+        return sum(value for prop, value in self._masses.items() if prop <= target)
+
+    def plausibility(self, key: str | Proposition | Iterable[str]) -> float:
+        target = self.frame.proposition(key)
+        return sum(value for prop, value in self._masses.items() if prop.intersects(target))
+
+    def commonality(self, key: str | Proposition | Iterable[str]) -> float:
+        target = self.frame.proposition(key)
+        return sum(value for prop, value in self._masses.items() if target <= prop)
+
+    @property
+    def conflict(self) -> float:
+        return self.mass(self.frame.empty)
+
+    def conjunctive(self, *others: "MassFunction") -> "MassFunction":
+        """Unnormalized conjunctive rule.
+
+        On a free DSm frame this is the classic DSm rule (DSmC). On Shafer's
+        DST model, contradictory intersections are accumulated on ``empty``.
+        """
+
+        return self._combine_intersection((self, *others), normalize=False)
+
+    def dsmc(self, *others: "MassFunction") -> "MassFunction":
+        """Alias for the classic conjunctive DSm rule."""
+
+        return self.conjunctive(*others)
+
+    def smets(self, *others: "MassFunction") -> "MassFunction":
+        """Smets/TBM unnormalized rule, keeping conflict on the empty set."""
+
+        return self.conjunctive(*others)
+
+    def dempster(self, *others: "MassFunction") -> "MassFunction":
+        """Dempster's normalized rule of combination."""
+
+        return self._combine_intersection((self, *others), normalize=True)
+
+    def yager(self, *others: "MassFunction") -> "MassFunction":
+        """Yager's rule: transfer total conflict to total ignorance."""
+
+        conjunctive = self.conjunctive(*others)
+        conflict = conjunctive.conflict
+        masses = {prop: value for prop, value in conjunctive.items() if prop}
+        if conflict:
+            masses[self.frame.total] = masses.get(self.frame.total, 0.0) + conflict
+        return MassFunction(self.frame, masses)
+
+    def dubois_prade(self, *others: "MassFunction") -> "MassFunction":
+        """Dubois-Prade style transfer of conflicts to disjunctions."""
+
+        return self.dsmh(*others)
+
+    def dsmh(self, *others: "MassFunction") -> "MassFunction":
+        """Hybrid DSm rule for constrained models.
+
+        Products whose intersection is non-empty go to that intersection.
+        Products whose intersection is empty are transferred to the union of
+        the involved propositions. If that union is also empty under the model,
+        the mass goes to total ignorance.
+        """
+
+        self._check_sources((self, *others))
+        masses: dict[Proposition, float] = {}
+        for props, values in self._focal_product((self, *others)):
+            amount = prod(values)
+            intersection = self._intersection_all(props)
+            if intersection:
+                target = intersection
+            else:
+                target = self._union_all(props)
+                if not target:
+                    target = self.frame.total
+            masses[target] = masses.get(target, 0.0) + amount
+        masses.pop(self.frame.empty, None)
+        return MassFunction(self.frame, masses)
+
+    def pcr5(self, other: "MassFunction") -> "MassFunction":
+        """PCR5 for two sources."""
+
+        return self.pcr6(other)
+
+    def pcr6(self, *others: "MassFunction") -> "MassFunction":
+        """PCR6 proportional conflict redistribution for two or more sources."""
+
+        sources = (self, *others)
+        self._check_sources(sources)
+        masses: dict[Proposition, float] = {}
+        for props, values in self._focal_product(sources):
+            amount = prod(values)
+            intersection = self._intersection_all(props)
+            if intersection:
+                masses[intersection] = masses.get(intersection, 0.0) + amount
+                continue
+
+            denominator = sum(values)
+            if denominator <= self.tolerance:
+                continue
+            for prop, source_mass in zip(props, values, strict=True):
+                target = prop if prop else self.frame.total
+                if not target:
+                    continue
+                share = amount * source_mass / denominator
+                masses[target] = masses.get(target, 0.0) + share
+        masses.pop(self.frame.empty, None)
+        return MassFunction(self.frame, masses)
+
+    def normalize(self) -> "MassFunction":
+        """Normalize a conjunctive result by removing empty-set conflict."""
+
+        conflict = self.conflict
+        denominator = 1.0 - conflict
+        if denominator <= self.tolerance:
+            raise TotalConflictError("Dempster normalization is undefined at total conflict.")
+        masses = {
+            prop: value / denominator
+            for prop, value in self._masses.items()
+            if prop and abs(value) > self.tolerance
+        }
+        return MassFunction(self.frame, masses)
+
+    def pignistic(self) -> dict[str, float]:
+        """Return pignistic scores for singleton hypotheses.
+
+        This is the classical pignistic transformation on DST frames. On free
+        or hybrid DSmT frames, singleton hypotheses can overlap, so the returned
+        event scores are useful for decisions but do not have to sum to one.
+        """
+
+        result = {name: 0.0 for name in self.frame.atoms}
+        singletons = dict(zip(self.frame.atoms, self.frame.symbols(), strict=True))
+        for prop, mass in self._masses.items():
+            if not prop:
+                continue
+            cardinality = prop.cardinality
+            if cardinality == 0:
+                continue
+            for name, atom in singletons.items():
+                overlap = (atom & prop).cardinality
+                if overlap:
+                    result[name] += mass * overlap / cardinality
+        return result
+
+    def pignistic_regions(self) -> dict[str, float]:
+        """Return a probability distribution over model Venn regions."""
+
+        result = {self._format_region(region): 0.0 for region in self.frame._universe}
+        for prop, mass in self._masses.items():
+            if not prop:
+                continue
+            cardinality = prop.cardinality
+            if cardinality == 0:
+                continue
+            share = mass / cardinality
+            for region in prop.regions:
+                result[self._format_region(region)] += share
+        return result
+
+    def decision(self) -> str:
+        """Return the singleton with the largest pignistic probability."""
+
+        probabilities = self.pignistic()
+        return max(probabilities, key=probabilities.__getitem__)
+
+    @classmethod
+    def _from_unchecked(cls, frame, values: Mapping[Proposition, float]) -> "MassFunction":
+        return cls(frame, values, validate=False)
+
+    def _combine_intersection(
+        self,
+        sources: tuple["MassFunction", ...],
+        *,
+        normalize: bool,
+    ) -> "MassFunction":
+        self._check_sources(sources)
+        masses: dict[Proposition, float] = {}
+        for props, values in self._focal_product(sources):
+            target = self._intersection_all(props)
+            masses[target] = masses.get(target, 0.0) + prod(values)
+        result = MassFunction(self.frame, masses)
+        return result.normalize() if normalize else result
+
+    def _focal_product(
+        self,
+        sources: tuple["MassFunction", ...],
+    ) -> Iterator[tuple[tuple[Proposition, ...], tuple[float, ...]]]:
+        item_groups = [source.items() for source in sources]
+        for combo in product(*item_groups):
+            props = tuple(prop for prop, _ in combo)
+            values = tuple(value for _, value in combo)
+            yield props, values
+
+    def _intersection_all(self, props: Iterable[Proposition]) -> Proposition:
+        iterator = iter(props)
+        result = next(iterator)
+        for prop in iterator:
+            result = result & prop
+        return result
+
+    def _union_all(self, props: Iterable[Proposition]) -> Proposition:
+        result = self.frame.empty
+        for prop in props:
+            result = result | prop
+        return result
+
+    def _check_sources(self, sources: tuple["MassFunction", ...]) -> None:
+        if len(sources) < 2:
+            raise ValueError("At least two sources are required.")
+        if any(source.frame is not self.frame for source in sources):
+            raise ValueError("All mass functions must belong to the same frame.")
+
+    def _validate_sum(self) -> None:
+        total = sum(self._masses.values())
+        if abs(total - 1.0) <= self.tolerance:
+            return
+        if abs(total - 1.0) <= self.normalization_tolerance:
+            self._masses = {prop: value / total for prop, value in self._masses.items()}
+            return
+        if abs(total - 1.0) > self.tolerance:
+            raise InvalidMassError(f"Mass values must sum to 1.0, got {total}.")
+
+    def _clean(self, masses: Mapping[Proposition, float]) -> dict[Proposition, float]:
+        return {
+            prop: value
+            for prop, value in masses.items()
+            if abs(value) > self.tolerance
+        }
+
+    def _format_region(self, region: int) -> str:
+        names = [name for i, name in enumerate(self.frame.atoms) if region & (1 << i)]
+        return "&".join(names)

evidencelib/parser.py

@@ -0,0 +1,104 @@
+"""Small parser for proposition expressions."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from evidencelib.proposition import Proposition
+
+
+@dataclass(frozen=True)
+class _Token:
+    kind: str
+    value: str
+
+
+class PropositionParser:
+    """Parse proposition expressions without executing Python code."""
+
+    def __init__(self, frame) -> None:
+        self.frame = frame
+
+    def parse(self, expression: str) -> Proposition:
+        self._tokens = self._tokenize(expression)
+        self._position = 0
+        result = self._parse_union()
+        if self._peek().kind != "end":
+            raise ValueError(f"Unexpected token {self._peek().value!r}.")
+        return result
+
+    def _parse_union(self) -> Proposition:
+        result = self._parse_intersection()
+        while self._accept("|"):
+            result = result | self._parse_intersection()
+        return result
+
+    def _parse_intersection(self) -> Proposition:
+        result = self._parse_primary()
+        while self._accept("&"):
+            result = result & self._parse_primary()
+        return result
+
+    def _parse_primary(self) -> Proposition:
+        token = self._peek()
+        if self._accept("("):
+            result = self._parse_union()
+            self._expect(")")
+            return result
+        if token.kind == "atom":
+            self._position += 1
+            if token.value in {"empty", "EMPTY"}:
+                return Proposition(self.frame, frozenset())
+            return self.frame.atom(token.value)
+        raise ValueError(f"Expected proposition, got {token.value!r}.")
+
+    def _accept(self, kind: str) -> bool:
+        if self._peek().kind == kind:
+            self._position += 1
+            return True
+        return False
+
+    def _expect(self, kind: str) -> None:
+        if not self._accept(kind):
+            raise ValueError(f"Expected {kind!r}, got {self._peek().value!r}.")
+
+    def _peek(self) -> _Token:
+        return self._tokens[self._position]
+
+    def _tokenize(self, expression: str) -> list[_Token]:
+        tokens: list[_Token] = []
+        i = 0
+        while i < len(expression):
+            char = expression[i]
+            if char.isspace():
+                i += 1
+                continue
+            if char in "()":
+                tokens.append(_Token(char, char))
+                i += 1
+                continue
+            if char in {"&", "∩", "∧"}:
+                tokens.append(_Token("&", char))
+                i += 1
+                continue
+            if char in {"|", "∪", "∨"}:
+                tokens.append(_Token("|", char))
+                i += 1
+                continue
+            if char == "∅":
+                tokens.append(_Token("atom", "empty"))
+                i += 1
+                continue
+
+            start = i
+            while i < len(expression):
+                current = expression[i]
+                if current.isspace() or current in "()&|∩∧∪∨":
+                    break
+                i += 1
+            value = expression[start:i]
+            if value not in self.frame.atoms and value not in {"empty", "EMPTY"}:
+                raise ValueError(f"Unknown proposition atom {value!r}.")
+            tokens.append(_Token("atom", value))
+        tokens.append(_Token("end", "end of expression"))
+        return tokens

evidencelib/proposition.py

@@ -0,0 +1,80 @@
+"""Symbolic propositions used by DST and DSmT frames."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, FrozenSet
+
+if TYPE_CHECKING:
+    from evidencelib.frame import Frame
+
+
+@dataclass(frozen=True)
+class Proposition:
+    """A canonical proposition represented by possible Venn regions.
+
+    Users normally create propositions through a :class:`evidencelib.Frame` and
+    combine them with ``|`` for union and ``&`` for intersection.
+    """
+
+    frame: "Frame"
+    regions: FrozenSet[int]
+
+    def __post_init__(self) -> None:
+        normalized = self.frame._normalize_regions(self.regions)
+        object.__setattr__(self, "regions", frozenset(normalized))
+
+    def __or__(self, other: "Proposition") -> "Proposition":
+        self._check_same_frame(other)
+        return Proposition(self.frame, self.regions | other.regions)
+
+    def __and__(self, other: "Proposition") -> "Proposition":
+        self._check_same_frame(other)
+        return Proposition(self.frame, self.regions & other.regions)
+
+    def __le__(self, other: "Proposition") -> bool:
+        self._check_same_frame(other)
+        return self.regions <= other.regions
+
+    def __lt__(self, other: "Proposition") -> bool:
+        return self <= other and self.regions != other.regions
+
+    def __bool__(self) -> bool:
+        return bool(self.regions)
+
+    def __str__(self) -> str:
+        return self.frame.format(self)
+
+    def __format__(self, format_spec: str) -> str:
+        return format(str(self), format_spec)
+
+    def __repr__(self) -> str:
+        return f"Proposition({str(self)!r})"
+
+    @property
+    def is_empty(self) -> bool:
+        return not self.regions
+
+    @property
+    def cardinality(self) -> int:
+        """DSm cardinality: number of non-empty model regions."""
+
+        return len(self.regions)
+
+    def intersects(self, other: "Proposition") -> bool:
+        self._check_same_frame(other)
+        return bool(self.regions & other.regions)
+
+    def union_atoms(self) -> "Proposition":
+        """Return the disjunction of singleton hypotheses involved in this proposition."""
+
+        mask = 0
+        for region in self.regions:
+            mask |= region
+        if mask == 0:
+            return self.frame.empty
+        return Proposition(self.frame, frozenset(r for r in self.frame._universe if r & mask))
+
+    def _check_same_frame(self, other: "Proposition") -> None:
+        if not isinstance(other, Proposition) or other.frame is not self.frame:
+            raise ValueError("Propositions must belong to the same frame.")

evidencelib/py.typed

@@ -0,0 +1 @@
+

evidencelib-1.0.0.dist-info/METADATA

@@ -0,0 +1,225 @@
+Metadata-Version: 2.4
+Name: evidencelib
+Version: 1.0.0
+Summary: Computational belief functions for DST and DSmT.
+Project-URL: Documentation, https://evidencelib.readthedocs.io/en/latest/
+Project-URL: Source, https://github.com/itaprac/evidencelib
+Project-URL: Issues, https://github.com/itaprac/evidencelib/issues
+Author: evidencelib contributors
+License: MIT License
+        
+        Copyright (c) 2026 evidencelib contributors
+        
+        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.
+        
+License-File: LICENSE
+Keywords: belief-functions,dempster-shafer,dsmt,dst,evidence-theory
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.10
+Provides-Extra: dev
+Requires-Dist: build>=1.0; extra == 'dev'
+Requires-Dist: myst-parser>=4.0; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: sphinx-rtd-theme>=3.0; extra == 'dev'
+Requires-Dist: sphinx>=8.0; extra == 'dev'
+Provides-Extra: docs
+Requires-Dist: myst-parser>=4.0; extra == 'docs'
+Requires-Dist: sphinx-rtd-theme>=3.0; extra == 'docs'
+Requires-Dist: sphinx>=8.0; extra == 'docs'
+Description-Content-Type: text/markdown
+
+# evidencelib
+
+[![CI](https://github.com/itaprac/evidencelib/actions/workflows/ci.yml/badge.svg)](https://github.com/itaprac/evidencelib/actions/workflows/ci.yml)
+[![Documentation Status](https://readthedocs.org/projects/evidencelib/badge/?version=latest)](https://evidencelib.readthedocs.io/en/latest/?badge=latest)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+Python library for belief-function calculations in Dempster-Shafer theory
+(DST) and Dezert-Smarandache theory (DSmT).
+
+`evidencelib` provides a compact quantitative core for finite frames: symbolic
+propositions, basic belief assignments, evidence fusion rules, belief measures,
+and pignistic decision support.
+
+Documentation is available on
+[Read the Docs](https://evidencelib.readthedocs.io/en/latest/).
+
+---
+
+## Installation
+
+You can install `evidencelib` using pip:
+
+```bash
+pip install evidencelib
+```
+
+For local development:
+
+```bash
+git clone https://github.com/itaprac/evidencelib.git
+cd evidencelib
+python3.10 -m venv .venv
+source .venv/bin/activate
+pip install -e ".[dev,docs]"
+```
+
+Run the test suite:
+
+```bash
+python -m pytest -q
+```
+
+Build the documentation locally:
+
+```bash
+python -m sphinx -W -b html docs docs/_build/html
+```
+
+---
+
+## Available Functionality
+
+The library contains:
+
+### Models
+
+| Constructor | Description |
+| --- | --- |
+| `Frame.dst(...)` | Shafer's classical DST model with exhaustive and mutually exclusive hypotheses. |
+| `Frame.dsmt(...)` | Free DSm model where hypotheses may overlap. |
+| `Frame.hybrid(...)` | Constrained DSm model with explicit emptiness or exclusivity constraints. |
+
+### Proposition Algebra
+
+| Operation | Meaning |
+| --- | --- |
+| `A \| B` | Union / disjunction, `A ∪ B`. |
+| `A & B` | Intersection / conjunction, `A ∩ B`. |
+| `frame.proposition("A ∩ (B ∪ C)")` | Parse a proposition from text. |
+| `frame.elements()` | Generate the model's power set or hyper-power set. |
+
+### Belief Measures
+
+| Method | Description |
+| --- | --- |
+| `mass(A)` | Direct mass assigned to a proposition. |
+| `belief(A)` | Sum of masses contained in `A`. |
+| `plausibility(A)` | Sum of masses intersecting `A`. |
+| `commonality(A)` | Sum of masses containing `A`. |
+| `conflict` | Mass assigned to the empty proposition. |
+
+### Fusion Rules
+
+| Method | Description |
+| --- | --- |
+| `conjunctive(...)` | Unnormalized conjunctive rule. |
+| `dsmc(...)` | Classic DSm rule on a free DSm frame. |
+| `smets(...)` | TBM/Smets rule, keeping conflict on the empty proposition. |
+| `dempster(...)` | Normalized Dempster rule. |
+| `yager(...)` | Yager rule, moving conflict to total ignorance. |
+| `dsmh(...)` | Hybrid DSm rule for constrained models. |
+| `dubois_prade(...)` | Static Dubois-Prade-style conflict transfer. |
+| `pcr5(...)` | PCR5 for two sources. |
+| `pcr6(...)` | PCR6 for two or more sources. |
+
+### Decision Support
+
+| Method | Description |
+| --- | --- |
+| `pignistic()` | Singleton pignistic scores. |
+| `pignistic_regions()` | Probability distribution over disjoint model regions. |
+| `decision()` | Singleton with the largest pignistic score. |
+
+---
+
+## Usage Example
+
+```python
+from evidencelib import Frame
+
+frame = Frame.dst(["A", "B"])
+A, B = frame.symbols()
+
+m1 = frame.mass({
+    A: 0.6,
+    A | B: 0.4,
+})
+
+m2 = frame.mass({
+    B: 0.3,
+    A | B: 0.7,
+})
+
+print(m1.dempster(m2).to_dict())
+print(m1.pcr5(m2).to_dict())
+```
+
+Output:
+
+```python
+{"A": 0.5121951219512195, "A|B": 0.34146341463414637, "B": 0.14634146341463414}
+{"A": 0.54, "A|B": 0.28, "B": 0.18}
+```
+
+Free DSmT example:
+
+```python
+frame = Frame.dsmt(["A", "B"])
+A, B = frame.symbols()
+
+m = frame.mass({
+    A: 0.2,
+    B: 0.3,
+    A & B: 0.4,
+    A | B: 0.1,
+})
+
+print(m.pignistic())
+print(m.pignistic_regions())
+```
+
+In DSmT, singleton hypotheses can overlap, so `pignistic()` returns decision
+scores that do not necessarily sum to one. Use `pignistic_regions()` for a
+probability distribution over disjoint Venn regions.
+
+More examples are available in the [`examples/`](examples/) directory and in
+the documentation.
+
+---
+
+## References
+
+- Shafer, G. (1976). *A Mathematical Theory of Evidence*. Princeton University Press.
+- Smarandache, F., & Dezert, J. (eds.). *Advances and Applications of DSmT for Information Fusion*.
+- Dezert, J., & Smarandache, F. *An Introduction to DSmT*.
+- Zadeh, L. A. (1986). A simple view of the Dempster-Shafer theory of evidence and its implication for the rule of combination. *AI Magazine*, 7(2), 85-90.
+
+---
+
+## License
+
+`evidencelib` is released under the MIT License.

evidencelib-1.0.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+evidencelib/__init__.py,sha256=s9pRq0RXF1j6Kl7IRjxNBhroVla0lPif-cxcBd5rBFQ,233
+evidencelib/exceptions.py,sha256=vh683OUtlryjLX6l5OKZL_jOwqJgus-XKpJSBXFEfjg,369
+evidencelib/frame.py,sha256=62AFTVpVAfPCMzeBoVzUok1IAYhRNT54CGDdgOfVsn0,7436
+evidencelib/mass.py,sha256=Vjl8kmo8tJsseHvY5tZJwKORms6va2oBq7myAc2ti5c,11699
+evidencelib/parser.py,sha256=aMm_Ai2cB2E4DUvUX67059EIyft1zhBmCgtqF8TCh8M,3333
+evidencelib/proposition.py,sha256=zLaUOWskXI8hMbxfQ6X2KQ-l9peyK0s6-fsWLd-ma2w,2584
+evidencelib/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+evidencelib-1.0.0.dist-info/METADATA,sha256=x6D0Qbm7F7H20xFOFPzSyVyJqzKb_dfIrNGzGA2s0mc,7137
+evidencelib-1.0.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+evidencelib-1.0.0.dist-info/licenses/LICENSE,sha256=4LvwJSWU4qyrxxGYsh0ABUM28zI-5Q7MOO1NFhqlEQ8,1082
+evidencelib-1.0.0.dist-info/RECORD,,

evidencelib-1.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

evidencelib-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 evidencelib contributors
+
+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.
+