关系¶

应用示例¶

连续比较检查显式有限域。

fuzzyroutines.relations ¶

标量模糊集的显式相等与包含关系。

有限次求值无法证明任意 Python 隶属函数可调用对象在连续区间上相等。因此本模块穷举离散论域，并要求连续论域具有显式的有限比较域。精确或基于容差的数值语义始终由不可变策略对象选择。

ComparisonDomain `dataclass` ¶

ComparisonDomain(points: tuple[MembershipScalar, ...])

用于比较连续模糊集的有限有序坐标。

属性：

名称	类型	描述
`points`	`tuple[MembershipScalar, ...]`	非空、严格递增的有限坐标元组。

points `instance-attribute` ¶

points: tuple[MembershipScalar, ...]

__post_init__ ¶

__post_init__() -> None

Require a non-empty tuple of finite, strictly increasing points.

源代码位于： fuzzyroutines/relations.py

def __post_init__(self) -> None:
    """Require a non-empty tuple of finite, strictly increasing points."""

    if not isinstance(self.points, tuple):
        raise InvalidParameterTypeError("comparison-domain points must be an explicit tuple")

    if not self.points:
        raise InvalidDomainError("comparison domain must contain at least one coordinate")

    validatedPoints = tuple(
        _RequireFiniteReal(point, f"points[{pointIndex}]")
        for pointIndex, point in enumerate(self.points)
    )

    if any(leftPoint >= rightPoint for leftPoint, rightPoint in pairwise(validatedPoints)):
        raise InvalidDomainError("comparison-domain points must be strictly increasing and distinct")

    object.__setattr__(self, "points", validatedPoints)

ValidateWithin ¶

ValidateWithin(universe: ContinuousUniverse) -> ComparisonDomain

证明每个点都属于论域后，返回本比较域。

参数：

名称	类型	描述	默认
`universe`	`ContinuousUniverse`	预期包含全部点的连续论域。	必需

返回：

类型	描述
`ComparisonDomain`	验证成功后返回原比较域，不作修改。

引发：

类型	描述
`TypeError`	`universe` 不是连续论域。
`ValueError`	任一比较点位于论域之外。

源代码位于： fuzzyroutines/relations.py

def ValidateWithin(self, universe: ContinuousUniverse) -> "ComparisonDomain":
    """Return this domain after proving every point belongs to the universe.

    Args:
        universe: Continuous universe expected to contain every point.

    Returns:
        This unchanged comparison domain after successful validation.

    Raises:
        TypeError: If `universe` is not continuous.
        ValueError: If any comparison point lies outside the universe.
    """

    if not isinstance(universe, ContinuousUniverse):
        raise InvalidParameterTypeError("comparison domains are used only with ContinuousUniverse")

    if any(not universe.Contains(point) for point in self.points):
        raise InvalidDomainError("every comparison-domain point must belong to the universe")

    return self

ComparisonPolicy `dataclass` ¶

ComparisonPolicy(mode: str, absoluteTolerance: MembershipScalar | None = None, relativeTolerance: MembershipScalar | None = None)

显式的精确隶属度比较或容差比较语义。

属性：

名称	类型	描述
`mode`	`str`	`"exact"` 或 `"tolerance"`。
`absoluteTolerance`	`MembershipScalar \| None`	tolerance 模式下的非负绝对容差。
`relativeTolerance`	`MembershipScalar \| None`	tolerance 模式下的非负相对容差。

mode `instance-attribute` ¶

mode: str

absoluteTolerance `class-attribute` `instance-attribute` ¶

absoluteTolerance: MembershipScalar | None = None

relativeTolerance `class-attribute` `instance-attribute` ¶

relativeTolerance: MembershipScalar | None = None

__post_init__ ¶

__post_init__() -> None

Reject incomplete, ambiguous, or zero-effect comparison policies.

源代码位于： fuzzyroutines/relations.py

def __post_init__(self) -> None:
    """Reject incomplete, ambiguous, or zero-effect comparison policies."""

    if self.mode == "exact":
        if self.absoluteTolerance is not None or self.relativeTolerance is not None:
            raise InvalidParameterError("exact comparison does not accept tolerances")

        return

    if self.mode != "tolerance":
        raise InvalidParameterError(f"unknown comparison mode: {self.mode!r}")

    absoluteTolerance = _RequireFiniteReal(self.absoluteTolerance, "absoluteTolerance")
    relativeTolerance = _RequireFiniteReal(self.relativeTolerance, "relativeTolerance")

    if absoluteTolerance < 0 or relativeTolerance < 0:
        raise InvalidParameterError("comparison tolerances must be non-negative")

    if absoluteTolerance == 0 and relativeTolerance == 0:
        raise InvalidParameterError("tolerance comparison requires at least one positive tolerance")

    object.__setattr__(self, "absoluteTolerance", absoluteTolerance)
    object.__setattr__(self, "relativeTolerance", relativeTolerance)

Equal ¶

Equal(leftGrade: MembershipScalar, rightGrade: MembershipScalar) -> bool

返回两个隶属度是否按本策略相等。

参数：

名称	类型	描述	默认
`leftGrade`	`MembershipScalar`	\([0, 1]\) 内的左隶属度。	必需
`rightGrade`	`MembershipScalar`	\([0, 1]\) 内的右隶属度。	必需

返回：

类型	描述
`bool`	根据 `mode` 使用精确相等或 `math.isclose`。

引发：

类型	描述
`TypeError`	任一隶属度不是实数标量。
`ValueError`	任一隶属度非有限或超出 \([0, 1]\)。

源代码位于： fuzzyroutines/relations.py

def Equal(self, leftGrade: MembershipScalar, rightGrade: MembershipScalar) -> bool:
    """Return whether two membership grades are equal by this policy.

    Args:
        leftGrade: Left membership degree in $[0, 1]$.
        rightGrade: Right membership degree in $[0, 1]$.

    Returns:
        Exact equality or `math.isclose` according to `mode`.

    Raises:
        TypeError: If either grade is not a real scalar.
        ValueError: If either grade is non-finite or outside $[0, 1]$.
    """

    leftGrade = _RequireGrade(leftGrade, "leftGrade")
    rightGrade = _RequireGrade(rightGrade, "rightGrade")

    if self.mode == "exact":
        return leftGrade == rightGrade

    return math.isclose(
        leftGrade,
        rightGrade,
        abs_tol=cast(float, self.absoluteTolerance),
        rel_tol=cast(float, self.relativeTolerance),
    )

Included ¶

Included(subsetGrade: MembershipScalar, supersetGrade: MembershipScalar) -> bool

根据本策略，检验两个隶属度是否满足模糊包含关系的判据。

参数：

名称	类型	描述	默认
`subsetGrade`	`MembershipScalar`	候选子集的隶属度。	必需
`supersetGrade`	`MembershipScalar`	候选超集的隶属度。	必需

返回：

类型	描述
`bool`	子集隶属度是否不大于超集隶属度；仅在 tolerance 模式允许数值接近。

引发：

类型	描述
`TypeError`	任一隶属度不是实数标量。
`ValueError`	任一隶属度非有限或超出 \([0, 1]\)。

源代码位于： fuzzyroutines/relations.py

def Included(self, subsetGrade: MembershipScalar, supersetGrade: MembershipScalar) -> bool:
    """Return whether one grade is included in another by this policy.

    Args:
        subsetGrade: Candidate subset membership degree.
        supersetGrade: Candidate superset membership degree.

    Returns:
        Whether the subset grade is no greater than the superset grade,
        allowing closeness only in tolerance mode.

    Raises:
        TypeError: If either grade is not a real scalar.
        ValueError: If either grade is non-finite or outside $[0, 1]$.
    """

    subsetGrade = _RequireGrade(subsetGrade, "subsetGrade")
    supersetGrade = _RequireGrade(supersetGrade, "supersetGrade")

    if subsetGrade <= supersetGrade:
        return True

    if self.mode == "exact":
        return False

    return self.Equal(subsetGrade, supersetGrade)

EqualOnDomain ¶

EqualOnDomain(leftSet: ScalarFuzzySet, rightSet: ScalarFuzzySet, comparisonPolicy: ComparisonPolicy, comparisonDomain: ComparisonDomain | None = None) -> bool

在穷尽域或显式有限域上比较隶属度是否相等。

对于离散论域，全部声明点构成穷尽检查，必须省略 comparisonDomain。对于连续论域，结果仅描述显式给出的采样点，不证明全局函数相等。

参数：

名称	类型	描述	默认
`leftSet`	`ScalarFuzzySet`	左标量模糊集。	必需
`rightSet`	`ScalarFuzzySet`	具有完全相同论域的右标量模糊集。	必需
`comparisonPolicy`	`ComparisonPolicy`	精确或容差隶属度比较策略。	必需
`comparisonDomain`	`ComparisonDomain \| None`	连续论域必需的有限观测点；离散论域应省略。	`None`

返回：

类型	描述
`bool`	所有已求值的隶属度对按策略比较相等时返回 `True`。

引发：

类型	描述
`TypeError`	参数类型不符合约定。
`ValueError`	论域不同或比较域选择无效。

源代码位于： fuzzyroutines/relations.py

def EqualOnDomain(
    leftSet: ScalarFuzzySet,
    rightSet: ScalarFuzzySet,
    comparisonPolicy: ComparisonPolicy,
    comparisonDomain: ComparisonDomain | None=None,
) -> bool:
    """Compare membership equality over an exhaustive or explicit finite domain.

    For a discrete universe the complete declared point set is exhaustive and
    `comparisonDomain` must be omitted. For a continuous universe the result
    describes only the explicitly supplied sample points; it is not a proof of
    global functional equality.

    Args:
        leftSet: Left scalar fuzzy set.
        rightSet: Right scalar fuzzy set over exactly the same universe.
        comparisonPolicy: Exact or tolerance-based grade policy.
        comparisonDomain: Required finite observation points for a continuous
            universe; omitted for a discrete universe.

    Returns:
        `True` when all evaluated membership pairs compare equal.

    Raises:
        TypeError: If an argument has the wrong contract type.
        ValueError: If universes differ or domain selection is invalid.
    """

    leftSet, rightSet = _RequireCompatibleSets(leftSet, rightSet)

    if not isinstance(comparisonPolicy, ComparisonPolicy):
        raise InvalidParameterTypeError("comparisonPolicy must be a ComparisonPolicy")

    comparisonPoints = _ResolveComparisonPoints(leftSet.universe, comparisonDomain)

    # all() preserves fail-fast semantics: at most one evaluation per declared
    # point and immediate termination at the first counterexample.
    return all(
        comparisonPolicy.Equal(leftSet.Membership(point), rightSet.Membership(point))
        for point in comparisonPoints
    )

IncludedOnDomain ¶

IncludedOnDomain(subset: ScalarFuzzySet, superset: ScalarFuzzySet, comparisonPolicy: ComparisonPolicy, comparisonDomain: ComparisonDomain | None = None) -> bool

在穷尽域或显式有限域上求模糊包含关系。

包含意味着每个求值点都满足 \(\mu_{subset}(x) \leq \mu_{superset}(x)\)。容差模式允许不等式有轻微违反，但仅限于两个隶属度按显式比较策略判定为数值接近的情形。

参数：

名称	类型	描述	默认
`subset`	`ScalarFuzzySet`	候选子模糊集。	必需
`superset`	`ScalarFuzzySet`	具有完全相同论域的候选超集。	必需
`comparisonPolicy`	`ComparisonPolicy`	精确或容差隶属度比较策略。	必需
`comparisonDomain`	`ComparisonDomain \| None`	连续论域必需的有限观测点；离散论域应省略。	`None`

返回：

类型	描述
`bool`	每个求值坐标都满足包含关系时返回 `True`。

引发：

类型	描述
`TypeError`	参数类型不符合约定。
`ValueError`	论域不同或比较域选择无效。

源代码位于： fuzzyroutines/relations.py

def IncludedOnDomain(
    subset: ScalarFuzzySet,
    superset: ScalarFuzzySet,
    comparisonPolicy: ComparisonPolicy,
    comparisonDomain: ComparisonDomain | None=None,
) -> bool:
    r"""Evaluate fuzzy inclusion over an exhaustive or explicit finite domain.

    Inclusion means $\mu_{subset}(x) \leq \mu_{superset}(x)$ at every
    evaluated point.
    Tolerance mode permits only violations whose two grades are numerically
    close under the explicit comparison policy.

    Args:
        subset: Candidate subset fuzzy set.
        superset: Candidate superset over exactly the same universe.
        comparisonPolicy: Exact or tolerance-based grade policy.
        comparisonDomain: Required finite observation points for a continuous
            universe; omitted for a discrete universe.

    Returns:
        `True` when inclusion holds at every evaluated coordinate.

    Raises:
        TypeError: If an argument has the wrong contract type.
        ValueError: If universes differ or domain selection is invalid.
    """

    subset, superset = _RequireCompatibleSets(subset, superset)

    if not isinstance(comparisonPolicy, ComparisonPolicy):
        raise InvalidParameterTypeError("comparisonPolicy must be a ComparisonPolicy")

    comparisonPoints = _ResolveComparisonPoints(subset.universe, comparisonDomain)

    # Worst-case O(n), O(1) auxiliary space; a finite continuous domain remains
    # evidence only for its declared points, never a global proof.
    return all(
        comparisonPolicy.Included(subset.Membership(point), superset.Membership(point))
        for point in comparisonPoints
    )

关系¶

应用示例¶

fuzzyroutines.relations ¶

ComparisonDomain dataclass ¶

points instance-attribute ¶

__post_init__ ¶

ValidateWithin ¶

ComparisonPolicy dataclass ¶

mode instance-attribute ¶

absoluteTolerance class-attribute instance-attribute ¶

relativeTolerance class-attribute instance-attribute ¶

__post_init__ ¶

Equal ¶

Included ¶

EqualOnDomain ¶

IncludedOnDomain ¶

ComparisonDomain `dataclass` ¶

points `instance-attribute` ¶

ComparisonPolicy `dataclass` ¶

mode `instance-attribute` ¶

absoluteTolerance `class-attribute` `instance-attribute` ¶

relativeTolerance `class-attribute` `instance-attribute` ¶