2.7.1. Complexity Analysis Proofs
Let
: population size (number of agents),
: decision-space dimension,
: maximum number of iterations,
: worst-case cost of one evaluation of the objective function .
Assume the base meta-heuristic update (PSO/GA/DE, etc.) requires arithmetic operations per agent per iteration (standard in population-based algorithms).
Lemma 1 (Initialization)
. The initialization phase of RSMS runs in time and uses
space.
Proof. The algorithm allocates and initializes agents, each represented by a decision vector in and possibly additional state (e.g., velocity, strategy parameters) of proportional size. Initializing each agent’s state therefore costs operations, for a total of . The initial fitness evaluation of all agents requires one call to per agent, which is .
The main memory usage comes from storing the decision vectors and any associated state vectors, each of dimension , leading to space. Auxiliary scalars such as fitness values and indices are and do not affect the asymptotic bound. □
Lemma 2 (Information system and universal attributes)
. Constructing the information system and computing a fixed number of universal attributes for all agents costs time and
additional space per iteration.
Proof. For each agent, RSMS computes a constant number of universal attributes (e.g., rank, diversity, improvement) from its current state. Each such attribute can be computed using a bounded number of operations on -dimensional vectors, so the cost per agent is . Over agents, this yields operations per iteration.
The information system stores a constant number of scalar attributes for each agent, adding scalars to memory. This is dominated by the storage for the agents’ state vectors. □
Lemma 3 (Discretization and equivalence classes)
. Discretizing the universal attributes and forming equivalence classes via the indiscernibility relation , with
fixed and small, costs time and space per iteration.
Proof. Each universal attribute is discretized using a constant number of thresholds that depend on the iteration (e.g., dynamic semantic limits). For each attribute value, discretization is therefore , so processing all attributes for all agents costs .
To construct equivalence classes induced by over a finite attribute set of constant cardinality, each agent is assigned a discrete key (e.g., a small tuple) determined by its discretized attributes. A standard implementation sorts the keys in time, then performs a single linear scan to group consecutive agents with identical keys into equivalence classes, an operation. The total time is dominated by the sorting, giving per iteration.
Each agent’s discrete key and class label are stored once, requiring additional memory. □
Lemma 4 (Target set, rough regions, and boundary ratio)
. Defining the elite target set and computing the rough regions , , , along with the boundary ratio , costs time and space per iteration.
Proof. The elite target set is defined as the top fraction of agents according to a chosen criterion (e.g., fitness or rank-based attribute). In the worst case, identifying uses a sorting-based approach on all agents, costing . A linear-time selection procedure could reduce this, but the sorting-based bound is safe and commonly used.
Given and the equivalence classes from Lemma 3, each agent’s membership in , , or is determined by a single pass over the population, which is . Computing the boundary ratio only requires reading accumulated counts, which is . Region labels and counters require storage proportional to , so space usage is . □
Lemma 5 (Phase determination via hysteresis)
. Determining the phase with hysteresis using and fixed thresholds takes time and space per iteration.
Proof. The phase selection step compares the scalar against a constant number of thresholds (e.g., lower and upper bounds) and combines this with the previous phase label to implement hysteresis. This involves a constant number of comparisons and assignments, independent of and , hence time and space. □
Lemma 6 (Agent class assignment and hyper parameter mapping)
. Assigning each agent to a behavioral class and mapping it to hyper parameters costs time and space per iteration.
Proof. Each agent’s behavioral class (e.g., positive, boundary, negative) is derived from its rough-region membership computed in Lemma 4. Hyper-parameters are assigned by querying a fixed-size lookup structure indexed by the current phase and behavioral class. Such a lookup is per agent, again resulting in time overall. Storing each agent’s class label and hyper parameters requires additional scalars. □
Lemma 7 (Base meta-heuristic update and evaluations)
. Applying the base update rule with assigned hyper parameters and evaluating the objective function for all agents costs time per iteration and uses space.
Proof. The base update rule (PSO, GA, DE, etc.) modifies each agent’s -dimensional state using a fixed number of algebraic operations, implying work per agent and in total. After the update, RSMS evaluates the objective function for each agent exactly once, costing . This term is often dominant in many practical applications. The memory for agent states (decision vectors and any additional kernel-specific state) is , as established in Lemma 1. No larger data structures are introduced in this step. □
Theorem 1 (Time complexity of macro-level RSMS)
. The total time complexity of the macro-level RSMS framework iswhich, for large
, simplifies to Proof. From Lemma 1, the one-time initialization cost is . For each of the iterations, Lemmas 2–7 contribute the following costs:
Information system and universal attributes: (Lemma 2).
Discretization and equivalence classes: (Lemma 3).
Target set, rough regions, and : (Lemma 4).
Phase determination: (Lemma 5).
Class assignment and hyper parameters: (Lemma 6).
Base update and evaluations: (Lemma 7).
Summing the per-iteration terms and absorbing lower-order terms
and
into the dominant ones yields
per iteration. Multiplying by
iterations and adding the initialization term gives the overall bound
For large , the initialization term is dominated, giving the stated asymptotic form. □
Theorem 2 (Space complexity of macro-level RSMS)
. The macro-level RSMS framework uses memory.
Proof. The dominant storage is the population state: each of the agents has a decision vector in and possibly an additional state of proportional size, requiring memory.
All other data structures—universal attributes, discrete keys, class labels, rough-region indicators, hyper parameters, and phase information—are at most linear in the population size, i.e., . Since is dominated by for , the overall memory usage is . □
2.7.2. The RSMS Complexity Discussion
These results show that the macro-level RSMS framework preserves the computational tractability of its underlying meta-heuristic. Per iteration, RSMS requires , where is the population size, the decision-space dimension, and the cost of evaluating the objective function. The linear term stems from vectorized state and attribute updates, while the term is due to sorting-based construction of equivalence classes and elite sets; this overhead remains asymptotically dominated in high-dimensional settings where . Memory usage is governed by the storage of candidate solutions and associated states, yielding a space complexity of . Consequently, RSMS can endow a broad family of base meta-heuristics with rough-set-guided, phase-aware control without compromising their applicability to large-scale optimization problems.
In classical Rough Set theory, NP-hardness arises in attribute reduction because one searches over subsets of a potentially large condition-attribute set. In our framework, we never perform attribute reduction: the rough component operates on a fixed, low-cardinality descriptor set (here, ), and we only compute equivalence classes for these attributes via sorting or hashing. This yields at most overhead per iteration, which is polynomial and asymptotically dominated by the cost of the underlying meta-heuristic and objective evaluations. Thus, the NP-hard part of Rough Sets is not invoked by the proposed RS-based controller.