🔢 mathematics

Hierarchical similarity-based approximate reasoning with restricted equivalence function

This paper proposes a hierarchical similarity-based approximate reasoning framework that integrates restricted equivalence functions (REFs) with aggregation functions to characterize REFs, analyze their approximation equality with existing methods, and efficiently mitigate the explosion of fuzzy rules.

Original authors: Dechao Li, Yuhui Zhu

Published 2026-05-04

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Dechao Li, Yuhui Zhu

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to teach a computer how to think like a human. Humans are great at handling fuzzy, blurry concepts. We don't need perfect data to know that two pictures are "similar" or that a rule like "If it's raining, take an umbrella" applies even if it's only drizzling.

This paper is about giving computers better tools to handle that fuzziness, specifically by fixing two big problems: how to measure similarity and how to stop the computer from getting overwhelmed by too many rules.

Here is the breakdown of their work, using some everyday analogies.

1. The Problem: The "Rule Explosion"

Imagine you are a chef trying to write a cookbook.

The Old Way (Raha's SBAR): If you have 3 ingredients (Flour, Sugar, Eggs) and you want to make a cake, you might write a rule for every possible combination. But what if you have 10 ingredients? The number of rules explodes. It's like trying to write a recipe for every single possible permutation of ingredients in the universe. The computer gets stuck trying to read through millions of pages of rules just to decide if you should bake a cake. This is called the "rule explosion."
The Goal: The authors want to build a "hierarchical" cookbook. Instead of one giant list, you have a smart system that checks ingredients one by one, step-by-step, without needing to read the whole encyclopedia at once.

2. The New Tool: The "Restricted Equivalence Function" (REF)

To make this smart system work, the computer needs a way to say, "These two things are similar enough to count as the same."

The Analogy: Think of a standard ruler. It tells you if two lines are exactly the same length. But in the real world, things are rarely exactly the same. A "Similarity Measure" is like a flexible ruler that says, "These two lines are 90% the same."
The Innovation: The authors introduce a specific type of flexible ruler called a Restricted Equivalence Function (REF). They figured out how to build this ruler using a mathematical "glue" (called an aggregation function) and a "logic connector" (called a fuzzy implication).
Why it matters: They proved that you can construct this special ruler in many different ways, not just the old standard ways. This gives the computer more flexibility to decide what "similar" means in different situations.

3. The Breakthrough: The "Layered" Reasoning System

Once they had their new, flexible ruler (the REF), they applied it to the "Rule Explosion" problem.

The Old Method (Flat Reasoning): Imagine trying to find a specific book in a library by checking every single book on every single shelf at the same time. If the library has 1,000 shelves, you have to check 1,000 books simultaneously. It's slow and requires a huge team (memory).
The New Method (Hierarchical Reasoning): The authors built a system that works like a funnel or a relay race.
- Step 1: Check the first ingredient (e.g., Flour). Is it similar to the rule?
- Step 2: Take that result and pass it to the next station to check the second ingredient (Sugar).
- Step 3: Pass the result to the third station (Eggs).
- Result: You get the final answer without ever having to look at all the ingredients at once.

4. The Results: Speed and Efficiency

The authors ran a test to see how much faster this new "relay race" method is compared to the old "check everything at once" method.

The Old Way: As you add more ingredients (dimensions), the time it takes to calculate grows exponentially. It's like trying to count grains of sand on a beach; every new grain makes the pile grow massively.
The New Way: The time it takes grows linearly (a straight line). Adding more ingredients just adds a small, manageable amount of work.
The Analogy: The old method is like trying to lift a heavy boulder with one hand. The new method is like using a pulley system. You still lift the boulder, but it takes a fraction of the effort and memory.

Summary of What They Claim

New Rulers: They showed how to build better "similarity rulers" (REFs) using different mathematical tools.
Stability: They proved that if you use these new rulers, the computer's reasoning stays consistent. If the input is slightly fuzzy, the output remains reliable.
Efficiency: They created two new "layered" (hierarchical) methods that solve the "Rule Explosion" problem.
Proof: They demonstrated with a specific example that their new method requires significantly fewer calculations and less memory storage than the traditional method.

In short: The paper doesn't claim to cure diseases or predict the stock market. It claims to have built a smarter, faster, and less memory-hungry engine for fuzzy logic systems, allowing them to handle complex, multi-variable decisions without crashing.

1. Problem Statement

The paper addresses two primary challenges in fuzzy logic and approximate reasoning:

Limitations of Existing Similarity Measures: While various similarity measures exist for fuzzy sets, many fail to satisfy rigorous axiomatic definitions or are not optimized for specific applications like image comparison. The authors aim to integrate Restricted Equivalence Functions (REFs), which are known for their robustness in image processing, into approximate reasoning systems.
The "Rule Explosion" Problem: In Multi-Input-Single-Output (MISO) fuzzy systems, traditional approximate reasoning methods (specifically Raha's Similarity-Based Approximate Reasoning or SBAR) suffer from exponential growth in computational complexity and memory requirements as the number of input variables increases. This is due to the need to compute sup-projection operations over the entire Cartesian product of input spaces.

The core objective is to construct hierarchical versions of Raha's SBAR method using REFs to enhance inference capabilities while effectively restraining the explosion of fuzzy rules.

2. Methodology

The paper employs a structured mathematical approach involving four main stages:

A. Characterization of REFs via Aggregation Functions

The authors generalize the construction of Restricted Equivalence Functions (REFs). Traditionally, REFs were constructed using t-norms and fuzzy implications. This work extends this by characterizing REFs using a general binary aggregation function ( $M$ ) and a mapping ( $f$ ).

They define a function $G(x, y) = M(f(x, y), f(y, x))$ .
They derive necessary and sufficient conditions for $M$ and $f$ (where $f$ acts as a fuzzy implication) to ensure $G$ satisfies the five axioms of an REF (symmetry, identity, boundary conditions, negation invariance, and monotonicity).
Key Finding: REFs can be constructed not only via t-norms but via any commutative binary aggregation function with specific properties (e.g., being "one strict" or having a neutral element).

B. Approximate Equality and Stability Analysis

The authors define approximate equality between fuzzy sets using the similarity measure $S_F$ generated by an REF.

They investigate the retention of approximate equality under fundamental fuzzy set operations: complement, union, intersection, and composition.
They prove that if two fuzzy sets are approximately equal, their complements, unions, and intersections remain approximately equal under specific conditions.
Crucially, they analyze the stability of Raha's SBAR method. They demonstrate that the approximation equality of the output ( $B'$ ) is bounded by the approximation equality of the inputs ( $A', A$ ) and the rule consequent ( $B$ ), provided specific continuity and functional equation constraints are met.

C. Construction of Hierarchical SBAR Methods

To solve the rule explosion problem, the authors propose transforming MISO systems into Single-Input-Single-Output (SISO) hierarchical structures.

Functional Equation: They seek conditions where the similarity of a composite input equals the aggregation of individual similarities:
$S_F(T(A'_1, A'_2), T(A_1, A_2)) = T(S_F(A'_1, A_1), S_F(A'_2, A_2))$
where $T$ is a t-norm.
They identify specific t-norms (Minimum $T_M$ , Product $T_P$ , Lukasiewicz $T_L$ ) and implications (Gödel, Goguen, Lukasiewicz) that satisfy this equation under certain constraints (e.g., strict t-norms or nilpotent t-norms without zero divisors).
Based on these functional equations, they derive two hierarchical algorithms:
1. Method 1 (Based on Eq. 2): Uses infimum operations (conjunction-based).
2. Method 2 (Based on Eq. 1): Uses supremum operations (implication-based).

D. Complexity Analysis

The paper provides a rigorous comparison of computational and space complexity between the traditional Raha's SBAR and the proposed Hierarchical methods.

Traditional Raha: Complexity is exponential, $O(\prod u_i)$ , where $u_i$ is the size of the domain of the $i$ -th input.
Hierarchical Method: Complexity is linear/polynomial, $O(m + \max(u_i))$ , where $m$ is the output domain size.

3. Key Contributions

Generalized REF Characterization: The paper establishes a theoretical framework for constructing REFs using arbitrary binary aggregation functions, extending previous work limited to t-norms.
Theoretical Stability Proofs: It provides formal proofs regarding the approximate equality of Raha's SBAR method when using REF-based similarity measures, ensuring that reasoning remains robust even with fuzzy inputs.
Hierarchical Algorithms: The authors propose two specific hierarchical algorithms (Algorithm 1 and Algorithm 2) that decompose multi-dimensional reasoning into a sequence of one-dimensional steps.
Complexity Reduction: The work demonstrates mathematically and empirically that the proposed hierarchical methods reduce computational complexity from exponential to polynomial, effectively solving the rule explosion problem in high-dimensional fuzzy systems.

4. Results

Theoretical Validation: Theorems 3.13, 3.14, and 3.21-3.22 successfully characterize REFs via aggregation functions. Theorems 4.11 and 4.12 prove that the approximation error in the output is bounded by the errors in the inputs and rules.
Functional Equations: The paper identifies that for strict t-norms and specific nilpotent t-norms (under non-zero divisor conditions), the required functional equations for hierarchical decomposition hold true.
Numerical Example: A case study with a 3-input fuzzy system was conducted.
- Traditional Raha SBAR: Required 194 calculation steps.
- Proposed Hierarchical SBAR: Required only 68 calculation steps.
- Storage: The hierarchical method significantly reduced memory requirements by avoiding the storage of the full Cartesian product matrix.

5. Significance

Scalability: The primary significance is the ability to apply similarity-based reasoning to high-dimensional problems (e.g., complex image processing, multi-variable control systems) that were previously computationally intractable due to the "curse of dimensionality."
Integration of Disciplines: It bridges the gap between image processing (where REFs are standard) and fuzzy control systems (where SBAR is standard), allowing for more robust handling of uncertainty in complex environments.
Practical Efficiency: By reducing complexity from exponential to polynomial, the proposed methods make real-time approximate reasoning feasible for systems with many inputs, a critical requirement for modern AI and decision-making systems.
Theoretical Foundation: The work provides a solid mathematical basis for using aggregation functions to construct equivalence relations, offering a flexible toolkit for future research in fuzzy logic.

In conclusion, this paper successfully integrates Restricted Equivalence Functions into hierarchical approximate reasoning, providing a mathematically rigorous and computationally efficient solution to the rule explosion problem in fuzzy systems.