Abstract
In this paper, we present an algorithm for determining the strong fuzzy grade of a hypergroup, considering a particular class of hypergroups associated with genetics. A study is carried out depending on the cardinality of the initial hypergroup. The last paragraph of this paper contains the MATLAB R2018b program for the fuzzy grade for cardinals .
MSC:
20N20
1. Introduction
The theory of hyperstructures is a topic of algebra that is more than 90 years old and rich in applications, in particular in fuzzy, soft, and rough sets, lattices, cryptography, artificial intelligence (see [1,2]). In a hypergroupoid, the result of the “multiplication” of two elements is a set of elements rather than a single element.
The study of the connections between algebraic structures and fuzzy set theory has been a research direction since the 1970s, when Rosenfeld [3] introduced fuzzy groups. Later, algebraic hyperstructures induced by fuzzy sets were introduced and studied, as well as fuzzy hyperstructures.
First, let us present some basic definitions:
A hyperoperation on a non-empty set H is a function , where is the set of non-empty subsets of H.
For subsets of H, denote and for write and for and , respectively.
The structure is a hypergroup if for all of H we have
A hypergroup for which for all is called a total hypergroup.
Various classes of hypergroups are known and studied. Regular reversible hypergroups have at least one identity and each element x has at least one inverse , such that if then there exist the inverses of y and of z, for which and Complete hypergroups form a class of hypergroups, closed to groups, in which every hyperproduct of elements is a complete part. We say that a subset A of H is a complete part of H if all hyperproducts of elements of H which have a non-empty intersection with A are contained in Join spaces are another important class of commutative hypergroups. A commutative hypergroup is a join space if for all elements of H,
Corsini began to study the join spaces induced by fuzzy sets. He associated a join space with a fuzzy set [4] and then a fuzzy set with a hypergroupoid/join space [5], constructing in this manner a sequence of join spaces and fuzzy sets, which ends if two consecutive join spaces are isomorphic. The length of this sequence is called the fuzzy grade. This indicates a point where the structure of the spaces essentially stabilizes. In this paper, we will call it the Corsini fuzzy grade to distinguish it from the strong fuzzy grade, which will be explained later. The study of this sequence offers the possibility of studying fuzzy sets from an algebraic point of view and also provides examples of join spaces on a certain set.
Now, let us present the algorithm introduced by Corsini in [5]. First, he associated a fuzzy set with every hypergroupoid , as follows:
In [6], the above fuzzy set was called grade fuzzy set and was denoted by
On the other hand, a join space can be associated with the fuzzy set as follows:
We repeat the process and obtain a sequence of join spaces and a sequence of fuzzy sets . These sequences have been studied in many contexts, for instance, in several classes of hypergroups, such as hypergroups with partial scalar identities [7], non-complete 1-hypergroups [8], and complete hypergroups [9], but also in connection with hypergraphs [10,11], multivalued functions [12], and recently, genetics [13]. Studying these sequences can be useful for analyzing the properties of join spaces, particularly their structure. Actually, the sequences are a hierarchical construction of associated join spaces, built step by step from a hypergroup or just a hypergroupoid.
In [14], the fuzzy grade is calculated for hypergroups associated with hypergraphs with the help of MATLAB. In the papers [13,14], the authors declare that they calculated the fuzzy grade of the corresponding hyperstructures, but in reality, the condition they used to stop the sequence of join spaces and fuzzy sets was that the last two join spaces had to be exactly the same or the latest two fuzzy sets had to have the same order.
The fuzzy grade of the starting hypergroup is the minimum natural number i for which while the strong fuzzy grade is the minimum natural number j for which It is easy to see that for the same hyperstructure, the strong fuzzy grade is greater than or equal to the fuzzy grade
According to [15], if we consider the equivalence relation on defined by then it follows that is a regular equivalence and a congruence in . The quotient set consists of equivalence classes with cardinals for all Therefore, with each join space we can associate an -tuple In [15], the authors established a sufficient condition in order to have two consecutive associated join spaces of a sequence be non-isomorphic. They also found a property of the quotient hypergroup determined by the join space and the relation associated with the fuzzy set and determined a necessary and sufficient condition for the join space in order for it to be a reduced hypergroup. In [9], the authors provide a method for constructing a finite hypergroup with the strong fuzzy grade equal to a given natural number.
In this paper, we consider the above construction for a class of hypergroups which has been obtained in connection with genetics (see [16,17,18]) and analyze the strong fuzzy grade of these hypergroups. This study is a continuation of the paper [13]. The last section of this paper contains the MATLAB programs for the strong fuzzy grade for cardinals
2. The Fuzzy Grade of a Genetic Hypergroup
We apply Corsini’s construction for the next join space, which is connected with a genetic inheritance (see [13]). This hypergroup is not complete, but it is regular and reversible.
We set and .
We consider the hyperoperation on H given in Table 1.
Table 1.
The multiplication table of ∘.
For all , we have
Moreover, is a join space. The idea of considering such a hypergroup comes from genetics; more precisely, it is associated with a type of non-Mendelian inheritance, namely Epistasis [16,18].
We have for all By calculation, for all natural numbers
Indeed,
whence
whence
whence
whence
Finally,
For all , we have
Theorem 1
([13]). For , we obtain
For , the above join space is an example of a hypergroup that satisfies the conditions of Theorem 6.1 [19], which states the following:
Theorem 2
([19]). Let H be the finite hypergroupoid with and s a nonzero natural number, which verifies the relation
i.e., the n-tuple associated with H is Then, the join space is a total hypergroup, and by consequence
In the proof of this theorem, it is checked that for all and for all Thus, the join space is associated with the -tuple , where .
Continuing in this manner, the join space is associated with the -tuple , with , and so on. The join space is associated with the pair . The join space is a total hypergroup and
Example 1.
Consider for hypergroup , and we obtain the following:
corresponding to ,
corresponding to ,
corresponding to ,
corresponding to the total hypergroup.
Hence, the fuzzy grade of is 4.
We continue the algorithm by obtaining the join spaces and fuzzy functions in order to establish the fuzzy degree in the other situations where
With , we obtain a join space such that for all we have
and for all we have .
Hence, we obtain Table 2.
Table 2.
The multiplication table of .
Note that all hypergroups we consider in this paper are commutative, so we can only write in the table the elements above the main diagonal.
Applying , we obtain the following:
and for
In particular,
If , where s is a natural number, , then
If , where s is a natural number, , then
and
For any we have
Theorem 3
([13]). (i) For we have the following:
and
- (ii)
- For we have the following:and
Hence, for the associated s-tuple is , and for the associated -tuple is
Applying again, we obtain the join space , where For all we have Moreover, for all we have
Denote Hence,
In what follows, we analyze separately a case where n is even and a case where n is odd.
I. Case
This allows us to obtain Table 3.
Table 3.
The multiplication table for .
We analyze the following cases:
- (i)
- If is even, i.e., , then.In this case, the associated k-tuple of is
- (ii)
- If is odd, i.e., , then.The associated -tuple of isThe cardinal 2 corresponds to since we have for all for which according to Theorem 2.3.
Applying (i) s times and then (ii), we obtain the following:
Theorem 4.
Let where
k.
k.Then, the associated tuple of is and the associated tuple of is
Example 2.
For , we have the following:
corresponding to ,
corresponding to ,
corresponding to ,
corresponding to .
Hence, the fuzzy grade of is 3.
Remark 1.
If in for all elements for which we have , then
II. Case
Clearly, if , then Notice that this is the only class containing only one element.
We can thus obtain Table 4.
Table 4.
The multiplication table for .
By calculation, we finally obtain that
The associated -tuple of is as for
Example 3.
For we have the following (see [13]): corresponding to ,
corresponding to ,
corresponding to .
Hence, the fuzzy grade of is 2.
Example 4.
For we have the following (see [13]):
corresponding to ,
corresponding to ,
corresponding to ,
corresponding to .
We obtain and but In this case, there is no strong fuzzy grade, but
Now we will consider a new example, for , in order to verify the results obtained using the MATLAB program of Section 3.Notice that for other values of n, the results obtained using the MATLAB program are verified through direct calculations.
Example 5.
We present the algorithm for , starting with the Table 5:
Table 5.
The multiplication table of ∘.
We have and is the starting hypergroup.
By calculation, we obtain
hence
At the second step, we obtain Table 6.
Table 6.
The multiplication table of .
We obtain
hence
At the next step, we obtain of Table 7.
Table 7.
The multiplication table of .
We obtain
hence
At the next step, we obtain the same hyperoperation, which means that , whence it follows that
3. MATLAB Program for Obtaining the Strong Fuzzy Grade
In this section, we present the R2018b program used to obtain the strong fuzzy grade for a hypergroup, in particular for the hypergroup H defined in the above section. Moreover, we calculate the strong fuzzy grade for cardinals of We use some functions to obtain this program: a function to generate the hyperoperation, then a function to obtain the fuzzy set from the given hyperoperation, then a third function to generate a new join space using the fuzzy set, and then a final function to call the first three functions. The last three functions are valid for any finite hypergroup. Only the first function is characteristic of the particular case of hypergroup studied in this paper.
The first function is used to generate a hyperoperation as described in Table 1. For example, for we obtain Table 8, which is isomorphic to of Table 5.
Table 8.
The multiplication table of .
This table can be obtained as follows: we type
- H=generate_H(3)
- in the command window, and we can get
- >> H=generate_H(3)
- H(:,:,1) =
- 1 1 1
- 1 0 0
- 1 0 0
- H(:,:,2) =
- 2 2 2
- 2 2 2
- 2 2 0
- H(:,:,3) =
- 3 3 3
- 3 3 3
- 3 3 3
- and then we obtain the multiplication table of , presented in the following as Table 8.
The second function can be used to get a fuzzy set from a hyperoperation. For example, if we type
- mu=h2(H)
- in the command window, we can get
- >> mu=h2(H)
- mu =
- 0.333333333333333 0.395833333333333 0.462962962962963
The third function can be used to generate a new join space by a fuzzy set. For example, if we type
- H1 = h3(mu)
- in the command window, we can get
- >> H1 = h3(mu)
- H1(:,:,1) =
- 1 1 1
- 1 0 0
- 1 0 0
- H1(:,:,2) =
- 0 2 2
- 2 2 2
- 2 2 0
- H1(:,:,3) =
- 0 0 3
- 0 0 3
- 3 3 3
The fourth function is obtained by calling the first three functions. If we want to apply the fourth function, we first need to save the first three functions as individual m-files named generate_H.m, h2.m, and h3.m, respectively.
The results of the application of these programs can be found after the codes, from which we know that the strong fuzzy grade of H with is , respectively, which covers the results of [13]. As for , Leoreanu et al. showed in Example 7.4 of [13] that there is no such strong fuzzy grade.
Table 9.
The strong fuzzy grades for H with the cardinals of Table 1, respectively.
The MATLAB programs are as follows.
| %%%The first function |
| function H = generate_H(n) |
| H = zeros(n, n, n); % Initialize an all-zero 3D array |
| for i = 1:n |
| for j = 1:n |
| for k = 1:n |
| if k >= min(i, j) |
| H(i, j, k) = k; |
| end |
| end |
| end |
| end |
| end |
| %%%The second function |
| function mu=h2(H) |
| % Calculate the fuzzy degree of elements in H |
| n = size(H, 1); |
| mu=zeros(1,n); |
| for x=1:n |
| q=0;mu1=0; |
| for i=1:n |
| for j=1:n |
| flag=0;p=0; |
| for k=1:n |
| if H(i,j,k)~=0 |
| p=p+1; |
| end |
| if x==H(i,j,k) |
| q=q+1; |
| flag=1; |
| end |
| end |
| if flag==1 |
| mu1=mu1+1/p; |
| end |
| end |
| end |
| if q~=0 |
| mu(x)=mu1/q; |
| end |
| end |
| %%%The third function |
| function H1 = h3(mu) |
| % to generate a new join space H1 by a fuzzy set mu |
| % H1(i,j,k) = k, if mu(k) is between mu(i) and mu(j); H1(i,j,k)=0, |
| % otherwise |
| if ~isvector(mu) |
| error(’Input mu must be a vector.’); |
| end |
| n = numel(mu); |
| H1 = zeros(n, n, n); |
| for i = 1:n |
| for j = 1:n |
| for k = 1:n |
| if mu(k) >= min(mu(i), mu(j)) && mu(k) <= max(mu(i), mu(j)) |
| H1(i, j, k) = k; |
| end |
| end |
| end |
| end |
| end |
| %The fourth function |
| function grad = h4(n) |
| H = generate_H(n); %To generate H |
| mu = h2(H); %To generate a fuzzy set mu corresponding to H |
| grad = 1; |
| iteration = 0; |
| max_iterations = 50; |
| %%%Note 1: the following codes are designed for display the entries of H |
| for i = 1:size(H, 1) |
| for j = 1:size(H, 2) |
| % Extract (i,j,:) and convert it to a row vector |
| slice = nonzeros(reshape(H(i,j,:), 1, [])); |
| % Display results |
| fprintf(’H(%d,%d,:) = [’, i, j); |
| fprintf(’%d ’, slice); |
| fprintf(’]\n’); |
| end |
| end |
| %%%The end of Note 1 |
| %To display the results of mu |
| fprintf(’mu1 =[ ’); |
| fprintf(’%.4f ’, mu); |
| fprintf(’]\n’); |
| while iteration < max_iterations |
| H1 = h3(mu); |
| mu1 = round(h2(H1),5); %This line can calculate %n=3,4,5,6,8 |
| for i = 1:size(H1, 1) |
| for j = 1:size(H1, 2) |
| % Extract (i,j,:) and convert it to a row vector |
| slice = nonzeros(reshape(H1(i,j,:), 1, [])); |
| % Display results |
| fprintf(’H%d(%d,%d,:) = [’, grad, i, j); |
| fprintf(’%d ’, slice); |
| fprintf(’]\n’); |
| end |
| end |
| %To display the results of all mu |
| fprintf(’mu%d =[ ’,grad+1); |
| fprintf(’%.4f ’, mu1); |
| fprintf(’]\n’); |
| [A, ind] = sort(mu); |
| [B, ind1] = sort(mu1); |
| if ind==ind1; |
| break; |
| end |
| H = H1; |
| mu = mu1; |
| grad = grad + 1; |
| iteration = iteration + 1; |
| end |
| if iteration >= max_iterations |
| warning(’Reached the maximum iteration count of 50.’); |
| end |
| %To display the fuzzy grade of H |
| fprintf(’The fuzzy grade of H with n=%d is %d ’,size(H,1),grad); |
| end |
To measure the execution time of the h4 function for different values on n, we make the following program, from which we obtain Figure 1.
Figure 1.
Execution time versus n value.
| % Measure execution time of h4 function for different n values |
| n_values = [3, 4, 5, 6, 8]; |
| num_trials = 5; % Number of trials for each n value |
| time_results = zeros(length(n_values), num_trials); |
| for i = 1:length(n_values) |
| n = n_values(i); |
| fprintf(’Testing n = %d...\n’, n); |
| for trial = 1:num_trials |
| tic; |
| [~] = evalc(’h4(n)’); |
| time_results(i, trial) = toc; |
| fprintf(’Trial %d: %.4f seconds\n’, trial, time_results(i, trial)); |
| end |
| end |
| % Calculate average times |
| avg_times = mean(time_results, 2); |
| % Create and display results table |
| result_table = table(n_values’, avg_times, ... |
| ’VariableNames’, {’n’, ’AverageTime_seconds’}); |
| disp(result_table); |
| % Plot results |
| figure; |
| ax = gca; |
| % Set axis properties |
| set(ax, ’XColor’, [0 0 0], ’YColor’, [0 0 0], ... |
| ’Color’, ’white’, ... |
| ’GridColor’, [0.8 0.8 0.8], ... |
| ’GridAlpha’, 0.5); |
| % Plot data |
| plot(n_values, avg_times, ’-o’, ... |
| ’LineWidth’, 2, ... |
| ’MarkerSize’, 8, ... |
| ’MarkerEdgeColor’, ’b’, ... |
| ’MarkerFaceColor’, ’w’); |
| % Set labels with mathematical n symbol |
| xlabel(’$n$ value’, ’FontSize’, 11, ’Interpreter’, ’latex’); |
| ylabel(’Average Execution Time (seconds)’, ’FontSize’, 11); |
| title(’Execution Time vs $n$ Value’, ’FontSize’, 12, ’Interpreter’, ’latex’); |
| % Set axis limits |
| xlim([2, max(n_values)+1]); |
| ylim([0, max(avg_times)*1.1]); |
| % Set x-axis ticks |
| set(ax, ’XTick’, 2:max(n_values)); |
| % Add grid |
| grid on; |
| % Add data labels (removed ’s’ unit and adjusted position) |
| for i = 1:length(n_values) |
| text(n_values(i) - 0.1, avg_times(i) + max(avg_times)*0.02, ... |
| % Moved left by 0.1 and up by 2% of max value |
| sprintf(’%.4f’, avg_times(i)), ... |
| ’FontSize’, 9, ... |
| ’VerticalAlignment’, ’bottom’, ... |
| ’HorizontalAlignment’, ’right’); |
| end |
| % Set figure background |
| set(gcf, ’Color’, ’white’); |
| % Save results |
| writetable(result_table, ’execution_times.csv’); |
| print(’execution_time_plot.png’, ’-dpng’, ’-r300’); |
This algorithm exhibits significant bottlenecks in computational efficiency when handling large-scale problems, reflected mainly in the extremely high time complexity of the core function of . As the size n increases, the computation time grows superlinearly, with experimental data showing a seven-fold increase in the computation time when n increases from 3 to 8. This exponential growth in complexity renders the algorithm impractical beyond certain scales, making parallel computing essential for improving computational efficiency.
GPU acceleration offers unique advantages for such problems, particularly for processing the algorithm’s regular matrix operations. Since the algorithm involves numerous independent three-dimensional/four-dimensional array operations, these computations can be perfectly mapped to a GPU’s parallel architecture. The thousands of computing cores in GPUs can simultaneously process matrix element operations, while their high-bandwidth memory effectively alleviates bottlenecks in large-scale data access. Theoretical analysis indicates that when , the GPU solution is expected to achieve 10–100× performance improvements.
However, several challenges remain for effective GPU acceleration of this algorithm. Conditional branching statements in the algorithm may impact GPU execution efficiency, and frequent CPU–GPU data transfers introduce additional overhead. Furthermore, the current algorithm design’s memory access patterns are not fully optimized, potentially limiting the GPU’s memory bandwidth advantages. These factors require targeted optimization during implementation to achieve the desired acceleration results.
We make the following remark to interpret the obtained results: for example, means that we have at position (1, 1) of the multiplication table. After presenting each table corresponding to the join space in the sequence, the fuzzy function is calculated, and we indicate when the sequence stops.
The results of applying our programs are shown below.
| >> h4(3); | H1(3,3,:) = [3] |
| H(1,1,:) = [1 2 3] | mu2 =[0.5333 0.5238 0.5333] |
| H(1,2,:) = [1 2 3] | H2(1,1,:) = [1 3] |
| H(1,3,:) = [1 2 3] | H2(1,2,:) = [1 2 3] |
| H(2,1,:) = [1 2 3] | H2(1,3,:) = [1 3] |
| H(2,2,:) = [2 3] | H2(2,1,:) = [1 2 3] |
| H(2,3,:) = [2 3] | H2(2,2,:) = [2] |
| H(3,1,:) = [1 2 3] | H2(2,3,:) = [1 2 3] |
| H(3,2,:) = [2 3] | H2(3,1,:) = [1 3] |
| H(3,3,:) = [3] | H2(3,2,:) = [1 2 3] |
| mu1 =[0.3333 0.3958 0.4630] | H2(3,3,:) = [1 3] |
| H1(1,1,:) = [1] | mu3 =[0.4167 0.4667 0.4167] |
| H1(1,2,:) = [1 2] | H3(1,1,:) = [1 3] |
| H1(1,3,:) = [1 2 3] | H3(1,2,:) = [1 2 3] |
| H1(2,1,:) = [1 2] | H3(1,3,:) = [1 3] |
| H1(2,2,:) = [2] | H3(2,1,:) = [1 2 3] |
| H1(2,3,:) = [2 3] | H3(2,2,:) = [2] |
| H1(3,1,:) = [1 2 3] | H3(2,3,:) = [1 2 3] |
| H1(3,2,:) = [2 3] | H3(3,1,:) = [1 3] |
| H3(3,2,:) = [1 2 3] | H2(2,3,:) = [2 3] |
| H3(3,3,:) = [1 3] | H2(2,4,:) = [1 2 3 4] |
| mu4 = [0.4167 0.4667 0.4167] | H2(3,1,:) = [1 2 3 4] |
| The strong fuzzy degree of H with | H2(3,2,:) = [2 3] |
| n=3 is 2. | H2(3,3,:) = [2 3] |
| H2(3,4,:) = [1 2 3 4] | |
| . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . | H2(4,1,:) = [1 4] |
| H2(4,2,:) = [1 2 3 4] | |
| >> h4(4); | H2(4,3,:) = [1 2 3 4] |
| H(1,1,:) = [1 2 3 4] | H2(4,4,:) = [1 4] |
| H(1,2,:) = [1 2 3 4] | mu3 = [0.3333 0.3333 |
| H(1,3,:) = [1 2 3 4] | 0.3333 0.3333] |
| H(1,4,:) = [1 2 3 4] | H3 is the total hypergroup. |
| H(2,1,:) = [1 2 3 4] | mu4 = [0.2500 0.2500 |
| H(2,2,:) = [2 3 4] | 0.2500 0.2500] |
| H(2,3,:) = [2 3 4] | The strong fuzzy grade of H |
| H(2,4,:) = [2 3 4] | with n=4 is 3. |
| H(3,1,:) = [1 2 3 4] | |
| H(3,2,:) = [2 3 4] | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . |
| H(3,3,:) = [3 4] | |
| H(3,4,:) = [3 4] | >> h4(5); |
| H(4,1,:) = [1 2 3 4] | H(1,1,:) = [1 2 3 4 5] |
| H(4,2,:) = [2 3 4] | H(1,2,:) = [1 2 3 4 5] |
| H(4,3,:) = [3 4] | H(1,3,:) = [1 2 3 4 5] |
| H(4,4,:) = [4] | H(1,4,:) = [1 2 3 4 5] |
| mu1 = [0.2500 0.2847 | H(1,5,:) = [1 2 3 4 5] |
| 0.3278 0.3698] | H(2,1,:) = [1 2 3 4 5] |
| H1(1,1,:) = [1] | H(2,2,:) = [2 3 4 5] |
| H1(1,2,:) = [1 2] | H(2,3,:) = [2 3 4 5] |
| H1(1,3,:) = [1 2 3] | H(2,4,:) = [2 3 4 5] |
| H1(1,4,:) = [1 2 3 4] | H(2,5,:) = [2 3 4 5] |
| H1(2,1,:) = [1 2] | H(3,1,:) = [1 2 3 4 5] |
| H1(2,2,:) = [2] | H(3,2,:) = [2 3 4 5] |
| H1(2,3,:) = [2 3] | H(3,3,:) = [3 4 5] |
| H1(2,4,:) = [2 3 4] | H(3,4,:) = [3 4 5] |
| H1(3,1,:) = [1 2 3] | H(3,5,:) = [3 4 5] |
| H1(3,2,:) = [2 3] | H(4,1,:) = [1 2 3 4 5] |
| H1(3,3,:) = [3] | H(4,2,:) = [2 3 4 5] |
| H1(3,4,:) = [3 4] | H(4,3,:) = [3 4 5] |
| H1(4,1,:) = [1 2 3 4] | H(4,4,:) = [4 5] |
| H1(4,2,:) = [2 3 4] | H(4,5,:) = [4 5] |
| H1(4,3,:) = [3 4] | H(5,1,:) = [1 2 3 4 5] |
| H1(4,4,:) = [4] | H(5,2,:) = [2 3 4 5] |
| mu2 = [0.4524 0.4394 | H(5,3,:) = [3 4 5] |
| 0.4394 0.4524] | H(5,4,:) = [4 5] |
| H2(1,1,:) = [1 4] | H(5,5,:) = [5] |
| H2(1,2,:) = [1 2 3 4] | mu1 = [0.2000 0.2219 0.2484 |
| H2(1,3,:) = [1 2 3 4] | 0.2799 0.3087] |
| H2(1,4,:) = [1 4] | H1(1,1,:) = [1] |
| H2(2,1,:) = [1 2 3 4] | H1(1,2,:) = [1 2] |
| H2(2,2,:) = [2 3] | H1(1,3,:) = [1 2 3] |
| H1(1,4,:) = [1 2 3 4] | 0.3482 0.3067 0.3000] |
| H1(1,5,:) = [1 2 3 4 5] | H3(1,1,:) = [1 5] |
| H1(2,1,:) = [1 2] | H3(1,2,:) = [1 2 4 5] |
| H1(2,2,:) = [2] | H3(1,3,:) = [1 2 3 4 5] |
| H1(2,3,:) = [2 3] | H3(1,4,:) = [1 2 4 5] |
| H1(2,4,:) = [2 3 4] | H3(1,5,:) = [1 5] |
| H1(2,5,:) = [2 3 4 5] | H3(2,1,:) = [1 2 4 5] |
| H1(3,1,:) = [1 2 3] | H3(2,2,:) = [2 4] |
| H1(3,2,:) = [2 3] | H3(2,3,:) = [2 3 4] |
| H1(3,3,:) = [3] | H3(2,4,:) = [2 4] |
| H1(3,4,:) = [3 4] | H3(2,5,:) = [1 2 4 5] |
| H1(3,5,:) = [3 4 5] | H3(3,1,:) = [1 2 3 4 5] |
| H1(4,1,:) = [1 2 3 4] | H3(3,2,:) = [2 3 4] |
| H1(4,2,:) = [2 3 4] | H3(3,3,:) = [3] |
| H1(4,3,:) = [3 4] | H3(3,4,:) = [2 3 4] |
| H1(4,4,:) = [4] | H3(3,5,:) = [1 2 3 4 5] |
| H1(4,5,:) = [4 5] | H3(4,1,:) = [1 2 4 5] |
| H1(5,1,:) = [1 2 3 4 5] | H3(4,2,:) = [2 4] |
| H1(5,2,:) = [2 3 4 5] | H3(4,3,:) = [2 3 4] |
| H1(5,3,:) = [3 4 5] | H3(4,4,:) = [2 4] |
| H1(5,4,:) = [4 5] | H3(4,5,:) = [1 2 4 5] |
| H1(5,5,:) = [5] | H3(5,1,:) = [1 5] |
| mu2 = [0.3963 0.3822 | H3(5,2,:) = [1 2 4 5] |
| 0.3765 0.3822 0.3963] | H3(5,3,:) = [1 2 3 4 5] |
| H2(1,1,:) = [1 5] | H3(5,4,:) = [1 2 4 5] |
| H2(1,2,:) = [1 2 4 5] | H3(5,5,:) = [1 5] |
| H2(1,3,:) = [1 2 3 4 5] | mu4 = [0.3000 0.3067 0.3482 |
| H2(1,4,:) = [1 2 4 5] | 0.3067 0.3000] |
| H2(1,5,:) = [1 5] | The strong fuzzy grade of H |
| H2(2,1,:) = [1 2 4 5] | with n=5 is 2. |
| H2(2,2,:) = [2 4] | |
| H2(2,3,:) = [2 3 4] | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . |
| H2(2,4,:) = [2 4] | |
| H2(2,5,:) = [1 2 4 5] | >> h4(6); |
| H2(3,1,:) = [1 2 3 4 5] | H(1,1,:) = [1 2 3 4 5 6] |
| H2(3,2,:) = [2 3 4] | H(1,2,:) = [1 2 3 4 5 6] |
| H2(3,3,:) = [3] | H(1,3,:) = [1 2 3 4 5 6] |
| H2(3,4,:) = [2 3 4] | H(1,4,:) = [1 2 3 4 5 6] |
| H2(3,5,:) = [1 2 3 4 5] | H(1,5,:) = [1 2 3 4 5 6] |
| H2(4,1,:) = [1 2 4 5] | H(1,6,:) = [1 2 3 4 5 6] |
| H2(4,2,:) = [2 4] | H(2,1,:) = [1 2 3 4 5 6] |
| H2(4,3,:) = [2 3 4] | H(2,2,:) = [2 3 4 5 6] |
| H2(4,4,:) = [2 4] | H(2,3,:) = [2 3 4 5 6] |
| H2(4,5,:) = [1 2 4 5] | H(2,4,:) = [2 3 4 5 6] |
| H2(5,1,:) = [1 5] | H(2,5,:) = [2 3 4 5 6] |
| H2(5,2,:) = [1 2 4 5] | H(2,6,:) = [2 3 4 5 6] |
| H2(5,3,:) = [1 2 3 4 5] | H(3,1,:) = [1 2 3 4 5 6] |
| H2(5,4,:) = [1 2 4 5] | H(3,2,:) = [2 3 4 5 6] |
| H2(5,5,:) = [1 5] | H(3,3,:) = [3 4 5 6] |
| mu3 = [0.3000 0.3067 | H(3,4,:) = [3 4 5 6] |
| H(3,5,:) = [3 4 5 6] | |
| H(3,6,:) = [3 4 5 6] | H1(5,6,:) = [5 6] |
| H(4,1,:) = [1 2 3 4 5 6] | H1(6,1,:) = [1 2 3 4 5 6] |
| H(4,2,:) = [2 3 4 5 6] | H1(6,2,:) = [2 3 4 5 6] |
| H(4,3,:) = [3 4 5 6] | H1(6,3,:) = [3 4 5 6] |
| H(4,4,:) = [4 5 6] | H1(6,4,:) = [4 5 6] |
| H(4,5,:) = [4 5 6] | H1(6,5,:) = [5 6] |
| H(4,6,:) = [4 5 6] | H1(6,6,:) = [6] |
| H(5,1,:) = [1 2 3 4 5 6] | mu2 = [0.3545 0.3404 |
| H(5,2,:) = [2 3 4 5 6] | 0.3319 0.3319 0.3404 0.3545] |
| H(5,3,:) = [3 4 5 6] | H2(1,1,:) = [1 6] |
| H(5,4,:) = [4 5 6] | H2(1,2,:) = [1 2 5 6] |
| H(5,5,:) = [5 6] | H2(1,3,:) = [1 2 3 4 5 6] |
| H(5,6,:) = [5 6] | H2(1,4,:) = [1 2 3 4 5 6] |
| H(6,1,:) = [1 2 3 4 5 6] | H2(1,5,:) = [1 2 5 6] |
| H(6,2,:) = [2 3 4 5 6] | H2(1,6,:) = [1 6] |
| H(6,3,:) = [3 4 5 6] | H2(2,1,:) = [1 2 5 6] |
| H(6,4,:) = [4 5 6] | H2(2,2,:) = [2 5] |
| H(6,5,:) = [5 6] | H2(2,3,:) = [2 3 4 5] |
| H(6,6,:) = [6] | H2(2,4,:) = [2 3 4 5] |
| mu1 = [0.1667 0.1817 | H2(2,5,:) = [2 5] |
| 0.1994 0.2203 0.2443 0.2653] | H2(2,6,:) = [1 2 5 6] |
| H1(1,1,:) = [1] | H2(3,1,:) = [1 2 3 4 5 6] |
| H1(1,2,:) = [1 2] | H2(3,2,:) = [2 3 4 5] |
| H1(1,3,:) = [1 2 3] | H2(3,3,:) = [3 4] |
| H1(1,4,:) = [1 2 3 4] | H2(3,4,:) = [3 4] |
| H1(1,5,:) = [1 2 3 4 5] | H2(3,5,:) = [2 3 4 5] |
| H1(1,6,:) = [1 2 3 4 5 6] | H2(3,6,:) = [1 2 3 4 5 6] |
| H1(2,1,:) = [1 2] | H2(4,1,:) = [1 2 3 4 5 6] |
| H1(2,2,:) = [2] | H2(4,2,:) = [2 3 4 5] |
| H1(2,3,:) = [2 3] | H2(4,3,:) = [3 4] |
| H1(2,4,:) = [2 3 4] | H2(4,4,:) = [3 4] |
| H1(2,5,:) = [2 3 4 5] | H2(4,5,:) = [2 3 4 5] |
| H1(2,6,:) = [2 3 4 5 6] | H2(4,6,:) = [1 2 3 4 5 6] |
| H1(3,1,:) = [1 2 3] | H2(5,1,:) = [1 2 5 6] |
| H1(3,2,:) = [2 3] | H2(5,2,:) = [2 5] |
| H1(3,3,:) = [3] | H2(5,3,:) = [2 3 4 5] |
| H1(3,4,:) = [3 4] | H2(5,4,:) = [2 3 4 5] |
| H1(3,5,:) = [3 4 5] | H2(5,5,:) = [2 5] |
| H1(3,6,:) = [3 4 5 6] | H2(5,6,:) = [1 2 5 6] |
| H1(4,1,:) = [1 2 3 4] | H2(6,1,:) = [1 6] |
| H1(4,2,:) = [2 3 4] | H2(6,2,:) = [1 2 5 6] |
| H1(4,3,:) = [3 4] | H2(6,3,:) = [1 2 3 4 5 6] |
| H1(4,4,:) = [4] | H2(6,4,:) = [1 2 3 4 5 6] |
| H1(4,5,:) = [4 5] | H2(6,5,:) = [1 2 5 6] |
| H1(4,6,:) = [4 5 6] | H2(6,6,:) = [1 6] |
| H1(5,1,:) = [1 2 3 4 5] | mu3 = [0.2667 0.2619 0.2667 |
| H1(5,2,:) = [2 3 4 5] | 0.2667 0.2619 0.2667] |
| H1(5,3,:) = [3 4 5] | H3(1,1,:) = [1 3 4 6] |
| H1(5,4,:) = [4 5] | H3(1,2,:) = [1 2 3 4 5 6] |
| H1(5,5,:) = [5] | H3(1,3,:) = [1 3 4 6] |
| H3(1,4,:) = [1 3 4 6] | H4(3,4,:) = [1 3 4 6] |
| H3(1,5,:) = [1 2 3 4 5 6] | H4(3,5,:) = [1 2 3 4 5 6] |
| H3(1,6,:) = [1 3 4 6] | H4(3,6,:) = [1 3 4 6] |
| H3(2,1,:) = [1 2 3 4 5 6] | H4(4,1,:) = [1 3 4 6] |
| H3(2,2,:) = [2 5] | H4(4,2,:) = [1 2 3 4 5 6] |
| H3(2,3,:) = [1 2 3 4 5 6] | H4(4,3,:) = [1 3 4 6] |
| H3(2,4,:) = [1 2 3 4 5 6] | H4(4,4,:) = [1 3 4 6] |
| H3(2,5,:) = [2 5] | H4(4,5,:) = [1 2 3 4 5 6] |
| H3(2,6,:) = [1 2 3 4 5 6] | H4(4,6,:) = [1 3 4 6] |
| H3(3,1,:) = [1 3 4 6] | H4(5,1,:) = [1 2 3 4 5 6] |
| H3(3,2,:) = [1 2 3 4 5 6] | H4(5,2,:) = [2 5] |
| H3(3,3,:) = [1 3 4 6] | H4(5,3,:) = [1 2 3 4 5 6] |
| H3(3,4,:) = [1 3 4 6] | H4(5,4,:) = [1 2 3 4 5 6] |
| H3(3,5,:) = [1 2 3 4 5 6] | H4(5,5,:) = [2 5] |
| H3(3,6,:) = [1 3 4 6] | H4(5,6,:) = [1 2 3 4 5 6] |
| H3(4,1,:) = [1 3 4 6] | H4(6,1,:) = [1 3 4 6] |
| H3(4,2,:) = [1 2 3 4 5 6] | H4(6,2,:) = [1 2 3 4 5 6] |
| H3(4,3,:) = [1 3 4 6] | H4(6,3,:) = [1 3 4 6] |
| H3(4,4,:) = [1 3 4 6] | H4(6,4,:) = [1 3 4 6] |
| H3(4,5,:) = [1 2 3 4 5 6] | H4(6,5,:) = [1 2 3 4 5 6] |
| H3(4,6,:) = [1 3 4 6] | H4(6,6,:) = [1 3 4 6] |
| H3(5,1,:) = [1 2 3 4 5 6] | mu5 = [0.2083 0.2333 0.2083 |
| H3(5,2,:) = [2 5] | 0.2083 0.2333 0.2083] |
| H3(5,3,:) = [1 2 3 4 5 6] | The strong fuzzy grade of H |
| H3(5,4,:) = [1 2 3 4 5 6] | with n=6 is 3. |
| H3(5,5,:) = [2 5] | |
| H3(5,6,:) = [1 2 3 4 5 6] | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . |
| H3(6,1,:) = [1 3 4 6] | |
| H3(6,2,:) = [1 2 3 4 5 6] | >> h4(8); |
| H3(6,3,:) = [1 3 4 6] | H(1,1,:) = [1 2 3 4 5 6 7 8] |
| H3(6,4,:) = [1 3 4 6] | H(1,2,:) = [1 2 3 4 5 6 7 8] |
| H3(6,5,:) = [1 2 3 4 5 6] | H(1,3,:) = [1 2 3 4 5 6 7 8] |
| H3(6,6,:) = [1 3 4 6] | H(1,4,:) = [1 2 3 4 5 6 7 8] |
| mu4 = [0.2083 0.2333 0.2083 | H(1,5,:) = [1 2 3 4 5 6 7 8] |
| 0.2083 0.2333 0.2083] | H(1,6,:) = [1 2 3 4 5 6 7 8] |
| H4(1,1,:) = [1 3 4 6] | H(1,7,:) = [1 2 3 4 5 6 7 8] |
| H4(1,2,:) = [1 2 3 4 5 6] | H(1,8,:) = [1 2 3 4 5 6 7 8] |
| H4(1,3,:) = [1 3 4 6] | H(2,1,:) = [1 2 3 4 5 6 7 8] |
| H4(1,4,:) = [1 3 4 6] | H(2,2,:) = [2 3 4 5 6 7 8] |
| H4(1,5,:) = [1 2 3 4 5 6] | H(2,3,:) = [2 3 4 5 6 7 8] |
| H4(1,6,:) = [1 3 4 6] | H(2,4,:) = [2 3 4 5 6 7 8] |
| H4(2,1,:) = [1 2 3 4 5 6] | H(2,5,:) = [2 3 4 5 6 7 8] |
| H4(2,2,:) = [2 5] | H(2,6,:) = [2 3 4 5 6 7 8] |
| H4(2,3,:) = [1 2 3 4 5 6] | H(2,7,:) = [2 3 4 5 6 7 8] |
| H4(2,4,:) = [1 2 3 4 5 6] | H(2,8,:) = [2 3 4 5 6 7 8] |
| H4(2,5,:) = [2 5] | H(3,1,:) = [1 2 3 4 5 6 7 8] |
| H4(2,6,:) = [1 2 3 4 5 6] | H(3,2,:) = [2 3 4 5 6 7 8] |
| H4(3,1,:) = [1 3 4 6] | H(3,3,:) = [3 4 5 6 7 8] |
| H4(3,2,:) = [1 2 3 4 5 6] | H(3,4,:) = [3 4 5 6 7 8] |
| H4(3,3,:) = [1 3 4 6] | H(3,5,:) = [3 4 5 6 7 8] |
| H(3,6,:) = [3 4 5 6 7 8] | |
| H(3,7,:) = [3 4 5 6 7 8] | H1(1,6,:) = [1 2 3 4 5 6] |
| H(3,8,:) = [3 4 5 6 7 8] | H1(1,7,:) = [1 2 3 4 5 6 7] |
| H(4,1,:) = [1 2 3 4 5 6 7 8] | H1(1,8,:) = [1 2 3 4 5 6 7 8] |
| H(4,2,:) = [2 3 4 5 6 7 8] | H1(2,1,:) = [1 2] |
| H(4,3,:) = [3 4 5 6 7 8] | H1(2,2,:) = [2] |
| H(4,4,:) = [4 5 6 7 8] | H1(2,3,:) = [2 3] |
| H(4,5,:) = [4 5 6 7 8] | H1(2,4,:) = [2 3 4] |
| H(4,6,:) = [4 5 6 7 8] | H1(2,5,:) = [2 3 4 5] |
| H(4,7,:) = [4 5 6 7 8] | H1(2,6,:) = [2 3 4 5 6] |
| H(4,8,:) = [4 5 6 7 8] | H1(2,7,:) = [2 3 4 5 6 7] |
| H(5,1,:) = [1 2 3 4 5 6 7 8] | H1(2,8,:) = [2 3 4 5 6 7 8] |
| H(5,2,:) = [2 3 4 5 6 7 8] | H1(3,1,:) = [1 2 3] |
| H(5,3,:) = [3 4 5 6 7 8] | H1(3,2,:) = [2 3] |
| H(5,4,:) = [4 5 6 7 8] | H1(3,3,:) = [3] |
| H(5,5,:) = [5 6 7 8] | H1(3,4,:) = [3 4] |
| H(5,6,:) = [5 6 7 8] | H1(3,5,:) = [3 4 5] |
| H(5,7,:) = [5 6 7 8] | H1(3,6,:) = [3 4 5 6] |
| H(5,8,:) = [5 6 7 8] | H1(3,7,:) = [3 4 5 6 7] |
| H(6,1,:) = [1 2 3 4 5 6 7 8] | H1(3,8,:) = [3 4 5 6 7 8] |
| H(6,2,:) = [2 3 4 5 6 7 8] | H1(4,1,:) = [1 2 3 4] |
| H(6,3,:) = [3 4 5 6 7 8] | H1(4,2,:) = [2 3 4] |
| H(6,4,:) = [4 5 6 7 8] | H1(4,3,:) = [3 4] |
| H(6,5,:) = [5 6 7 8] | H1(4,4,:) = [4] |
| H(6,6,:) = [6 7 8] | H1(4,5,:) = [4 5] |
| H(6,7,:) = [6 7 8] | H1(4,6,:) = [4 5 6] |
| H(6,8,:) = [6 7 8] | H1(4,7,:) = [4 5 6 7] |
| H(7,1,:) = [1 2 3 4 5 6 7 8] | H1(4,8,:) = [4 5 6 7 8] |
| H(7,2,:) = [2 3 4 5 6 7 8] | H1(5,1,:) = [1 2 3 4 5] |
| H(7,3,:) = [3 4 5 6 7 8] | H1(5,2,:) = [2 3 4 5] |
| H(7,4,:) = [4 5 6 7 8] | H1(5,3,:) = [3 4 5] |
| H(7,5,:) = [5 6 7 8] | H1(5,4,:) = [4 5] |
| H(7,6,:) = [6 7 8] | H1(5,5,:) = [5] |
| H(7,7,:) = [7 8] | H1(5,6,:) = [5 6] |
| H(7,8,:) = [7 8] | H1(5,7,:) = [5 6 7] |
| H(8,1,:) = [1 2 3 4 5 6 7 8] | H1(5,8,:) = [5 6 7 8] |
| H(8,2,:) = [2 3 4 5 6 7 8] | H1(6,1,:) = [1 2 3 4 5 6] |
| H(8,3,:) = [3 4 5 6 7 8] | H1(6,2,:) = [2 3 4 5 6] |
| H(8,4,:) = [4 5 6 7 8] | H1(6,3,:) = [3 4 5 6] |
| H(8,5,:) = [5 6 7 8] | H1(6,4,:) = [4 5 6] |
| H(8,6,:) = [6 7 8] | H1(6,5,:) = [5 6] |
| H(8,7,:) = [7 8] | H1(6,6,:) = [6] |
| H(8,8,:) = [8] | H1(6,7,:) = [6 7] |
| mu1 = [0.1250 0.1333 | H1(6,8,:) = [6 7 8] |
| 0.1427 0.1534 0.1657 | H1(7,1,:) = [1 2 3 4 5 6 7] |
| 0.1797 0.1950 0.2075] | H1(7,2,:) = [2 3 4 5 6 7] |
| H1(1,1,:) = [1] | H1(7,3,:) = [3 4 5 6 7] |
| H1(1,2,:) = [1 2] | H1(7,4,:) = [4 5 6 7] |
| H1(1,3,:) = [1 2 3] | H1(7,5,:) = [5 6 7] |
| H1(1,4,:) = [1 2 3 4] | H1(7,6,:) = [6 7] |
| H1(1,5,:) = [1 2 3 4 5] | H1(7,7,:) = [7] |
| H1(7,8,:) = [7 8] | H2(5,7,:) = [2 3 4 5 6 7] |
| H1(8,1,:) = [1 2 3 4 5 6 7 8] | H2(5,8,:) = [1 2 3 4 5 6 7 8] |
| H1(8,2,:) = [2 3 4 5 6 7 8] | H2(6,1,:) = [1 2 3 6 7 8] |
| H1(8,3,:) = [3 4 5 6 7 8] | H2(6,2,:) = [2 3 6 7] |
| H1(8,4,:) = [4 5 6 7 8] | H2(6,3,:) = [3 6] |
| H1(8,5,:) = [5 6 7 8] | H2(6,4,:) = [3 4 5 6] |
| H1(8,6,:) = [6 7 8] | H2(6,5,:) = [3 4 5 6] |
| H1(8,7,:) = [7 8] | H2(6,6,:) = [3 6] |
| H1(8,8,:) = [8] | H2(6,7,:) = [2 3 6 7] |
| mu2 = [0.2957 0.2823 | H2(6,8,:) = [1 2 3 6 7 8] |
| 0.2720 0.2672 0.2672 | H2(7,1,:) = [1 2 7 8] |
| 0.2720 0.2823 0.2957] | H2(7,2,:) = [2 7] |
| H2(1,1,:) = [1 8] | H2(7,3,:) = [2 3 6 7] |
| H2(1,2,:) = [1 2 7 8] | H2(7,4,:) = [2 3 4 5 6 7] |
| H2(1,3,:) = [1 2 3 6 7 8] | H2(7,5,:) = [2 3 4 5 6 7] |
| H2(1,4,:) = [1 2 3 4 5 6 7 8] | H2(7,6,:) = [2 3 6 7] |
| H2(1,5,:) = [1 2 3 4 5 6 7 8] | H2(7,7,:) = [2 7] |
| H2(1,6,:) = [1 2 3 6 7 8] | H2(7,8,:) = [1 2 7 8] |
| H2(1,7,:) = [1 2 7 8] | H2(8,1,:) = [1 8] |
| H2(1,8,:) = [1 8] | H2(8,2,:) = [1 2 7 8] |
| H2(2,1,:) = [1 2 7 8] | H2(8,3,:) = [1 2 3 6 7 8] |
| H2(2,2,:) = [2 7] | H2(8,4,:) = [1 2 3 4 5 6 7 8] |
| H2(2,3,:) = [2 3 6 7] | H2(8,5,:) = [1 2 3 4 5 6 7 8] |
| H2(2,4,:) = [2 3 4 5 6 7] | H2(8,6,:) = [1 2 3 6 7 8] |
| H2(2,5,:) = [2 3 4 5 6 7] | H2(8,7,:) = [1 2 7 8] |
| H2(2,6,:) = [2 3 6 7] | H2(8,8,:) = [1 8] |
| H2(2,7,:) = [2 7] | mu3 = [0.2262 0.2197 |
| H2(2,8,:) = [1 2 7 8] | 0.2197 0.2262 0.2262 |
| H2(3,1,:) = [1 2 3 6 7 8] | 0.2197 0.2197 0.2262] |
| H2(3,2,:) = [2 3 6 7] | H3(1,1,:) = [1 4 5 8] |
| H2(3,3,:) = [3 6] | H3(1,2,:) = [1 2 3 4 5 6 7 8] |
| H2(3,4,:) = [3 4 5 6] | H3(1,3,:) = [1 2 3 4 5 6 7 8] |
| H2(3,5,:) = [3 4 5 6] | H3(1,4,:) = [1 4 5 8] |
| H2(3,6,:) = [3 6] | H3(1,5,:) = [1 4 5 8] |
| H2(3,7,:) = [2 3 6 7] | H3(1,6,:) = [1 2 3 4 5 6 7 8] |
| H2(3,8,:) = [1 2 3 6 7 8] | H3(1,7,:) = [1 2 3 4 5 6 7 8] |
| H2(4,1,:) = [1 2 3 4 5 6 7 8] | H3(1,8,:) = [1 4 5 8] |
| H2(4,2,:) = [2 3 4 5 6 7] | H3(2,1,:) = [1 2 3 4 5 6 7 8] |
| H2(4,3,:) = [3 4 5 6] | H3(2,2,:) = [2 3 6 7] |
| H2(4,4,:) = [4 5] | H3(2,3,:) = [2 3 6 7] |
| H2(4,5,:) = [4 5] | H3(2,4,:) = [1 2 3 4 5 6 7 8] |
| H2(4,6,:) = [3 4 5 6] | H3(2,5,:) = [1 2 3 4 5 6 7 8] |
| H2(4,7,:) = [2 3 4 5 6 7] | H3(2,6,:) = [2 3 6 7] |
| H2(4,8,:) = [1 2 3 4 5 6 7 8] | H3(2,7,:) = [2 3 6 7] |
| H2(5,1,:) = [1 2 3 4 5 6 7 8] | H3(2,8,:) = [1 2 3 4 5 6 7 8] |
| H2(5,2,:) = [2 3 4 5 6 7] | H3(3,1,:) = [1 2 3 4 5 6 7 8] |
| H2(5,3,:) = [3 4 5 6] | H3(3,2,:) = [2 3 6 7] |
| H2(5,4,:) = [4 5] | H3(3,3,:) = [2 3 6 7] |
| H2(5,5,:) = [4 5] | H3(3,4,:) = [1 2 3 4 5 6 7 8] |
| H2(5,6,:) = [3 4 5 6] | H3(3,5,:) = [1 2 3 4 5 6 7 8] |
| H3(3,6,:) = [2 3 6 7] | H3(6,6,:) = [2 3 6 7] |
| H3(3,7,:) = [2 3 6 7] | H3(6,7,:) = [2 3 6 7] |
| H3(3,8,:) = [1 2 3 4 5 6 7 8] | H3(6,8,:) = [1 2 3 4 5 6 7 8] |
| H3(4,1,:) = [1 4 5 8] | H3(7,1,:) = [1 2 3 4 5 6 7 8] |
| H3(4,2,:) = [1 2 3 4 5 6 7 8] | H3(7,2,:) = [2 3 6 7] |
| H3(4,3,:) = [1 2 3 4 5 6 7 8] | H3(7,3,:) = [2 3 6 7] |
| H3(4,4,:) = [1 4 5 8] | H3(7,4,:) = [1 2 3 4 5 6 7 8] |
| H3(4,5,:) = [1 4 5 8] | H3(7,5,:) = [1 2 3 4 5 6 7 8] |
| H3(4,6,:) = [1 2 3 4 5 6 7 8] | H3(7,6,:) = [2 3 6 7] |
| H3(4,7,:) = [1 2 3 4 5 6 7 8] | H3(7,7,:) = [2 3 6 7] |
| H3(4,8,:) = [1 4 5 8] | H3(7,8,:) = [1 2 3 4 5 6 7 8] |
| H3(5,1,:) = [1 4 5 8] | H3(8,1,:) = [1 4 5 8] |
| H3(5,2,:) = [1 2 3 4 5 6 7 8] | H3(8,2,:) = [1 2 3 4 5 6 7 8] |
| H3(5,3,:) = [1 2 3 4 5 6 7 8] | H3(8,3,:) = [1 2 3 4 5 6 7 8] |
| H3(5,4,:) = [1 4 5 8] | H3(8,4,:) = [1 4 5 8] |
| H3(5,5,:) = [1 4 5 8] | H3(8,5,:) = [1 4 5 8] |
| H3(5,6,:) = [1 2 3 4 5 6 7 8] | H3(8,6,:) = [1 2 3 4 5 6 7 8] |
| H3(5,7,:) = [1 2 3 4 5 6 7 8] | H3(8,7,:) = [1 2 3 4 5 6 7 8] |
| H3(5,8,:) = [1 4 5 8] | H3(8,8,:) = [1 4 5 8] |
| H3(6,1,:) = [1 2 3 4 5 6 7 8] | mu4 = [0.1667 0.1667 |
| H3(6,2,:) = [2 3 6 7] | 0.1667 0.1667 0.1667 |
| H3(6,3,:) = [2 3 6 7] | 0.1667 0.1667 0.1667] |
| H3(6,4,:) = [1 2 3 4 5 6 7 8] | The strong fuzzy grade of H |
| H3(6,5,:) = [1 2 3 4 5 6 7 8] | with n=8 is 4. |
4. Conclusions
In this paper, we present a MATLAB program for an algorithm that determines the strong fuzzy grade for small cardinal hypergroups: 3, 4, 5, 6, 8 For the hypergroup of cardinal 7, there is no strong fuzzy grade. In future research, we intend to obtain programs in order to calculate the strong fuzzy grade for hypergroups of large cardinals and to calculate the fuzzy grade, both for small and larger hypergroupoids, using GPU acceleration.
Author Contributions
Conceptualization, Y.F. and V.L.-F.; methodology, V.L.-F.; validation, V.L.-F. formal analysis, Y.F. and V.L.-F.; investigation, Y.F.; writing—original draft preparation, Y.F. and V.L.-F.; writing—review and editing, Y.F. and V.L.-F.; supervision, V.L.-F.; funding acquisition, Y.F. All authors have read and agreed to the published version of the manuscript.
Funding
This work is sponsored by the Natural Science Foundation of Chongqing, P.R. China (2024NSCQ-LZX0121, 2024NSCQ-LZX0120, 2023TIAD-ZXX0017, CSTB2023NSCQ-LZX0135), the Scientific and Technological Research Program of Chongqing Municipal Education Commission, P.R. China (KJZD-K202301023), the Scientific and Technological Research Program of Wanzhou District, P.R. China (WZSTC-20230309), the National Natural Science Foundation of China (12201086), and Program of Chongqing Municipal Education Commission, P.R. China (KJQN202201209, 233356).
Data Availability Statement
Data is contained within the article. Further inquiries can be directed to the corresponding author.
Conflicts of Interest
The authors declare no conflicts of interest.
Correction Statement
This article has been republished with a minor correction to the Data Availability Statement. This change does not affect the scientific content of the article.
References
- Corsini, P.; Leoreanu, V. Applications of Hyperstructure Theory; Advances in Mathematics; Kluwer Academic Publishers: Alphen aan den Rijn, The Netherlands, 2003; Volume 5. [Google Scholar]
- Leoreanu-Fotea, V.; Hoskova-Mayerova, S. Join Spaces and Lattices. Axioms 2024, 13, 705. [Google Scholar] [CrossRef]
- Rosenfeld, A. Fuzzy groups. J. Math. Anal. Appl. 1971, 35, 512–517. [Google Scholar] [CrossRef]
- Corsini, P. Join spaces, power sets, fuzzy sets. In Proceedings of the Fifth International Congress on A.H.A., Iaşi, Romania, 15 June 1993; Hadronic Press: Palm Harbor, FL, USA, 1994; pp. 45–52. [Google Scholar]
- Corsini, P. A new connection between hypergroups and fuzzy sets. Southeast Bull. Math. 2003, 27, 221–229. [Google Scholar]
- Kankaras, M.; Cristea, I. Fuzzy Reduced Hypergroups. Mathematics 2020, 8, 263. [Google Scholar] [CrossRef]
- Corsini, P.; Cristea, I. Fuzzy grade of ips hypergroups of order 7. Iran. J. Fuzzy Syst. 2004, 1, 15. [Google Scholar]
- Corsini, P.; Cristea, I. Fuzzy sets and non complete 1-hypergroups. An. St. Univ. Ovidius Constanta 2005, 13, 27–54. [Google Scholar]
- Angheluta, C.; Cristea, I. Fuzzy grade of the complete hypergroups. Iran. J. Fuzzy Syst. 2012, 9, 43–56. [Google Scholar]
- Corsini, P. Hypergraphs and hypergroups. Algebra Universalis 1996, 36, 548–555. [Google Scholar] [CrossRef]
- Corsini, P.; Leoreanu, V.; Iranmanesh, A. On the Sequence of Hypergroups and Membership Functions Determined by a Hypergraph. J.-Mult. Log. Soft Comput. 2008, 14, 565–577. [Google Scholar]
- Cristea, I. Hyperstructures and fuzzy sets endowed with two membership functions. Fuzzy Sets Syst. 2009, 160, 1114–1124. [Google Scholar] [CrossRef]
- Leoreanu-Fotea, V.; Sonea, A.; Davvaz, B. The fuzzy degree of a genetic hypergroup. Ann. Fuzzy Math. Inform. 2023, 25, 125–138. [Google Scholar]
- Feng, Y.; Jiang, Y.; Leoreanu-Fotea, V. On the grade of a sequence of fuzzy sets and join spaces determined by a hypergraph II. Afr. Math. 2013, 24, 83–91. [Google Scholar] [CrossRef]
- Ştefănescu, M.; Cristea, I. On the fuzzy grade of hypergroups. Fuzzy Sets Syst. 2008, 159, 1097–1106. [Google Scholar] [CrossRef]
- Al-Tahan, M.; Davvaz, B. On quasi-ordering hypergroups, ordered hyperstructures and their applications in genetics. Math. Interdiscip. Res. 2022, 7, 1–19. [Google Scholar]
- Al-Tahan, M.; Davvaz, B. Hv module of functions over Hv ring of arithmetics and its fundamental modules. An. St. Univ. Ovidius Constanța 2024, 32, 5–18. [Google Scholar]
- Al-Tahan, M.; Davvaz, B. Algebraic hyperstructures associated to biological inheritance. Math. Biosci. 2017, 285, 112–118. [Google Scholar] [CrossRef] [PubMed]
- Cristea, I. A property of the connection between fuzzy sets and hypergroupoids. Ital. J. Pure Appl. Math. 2007, 21, 73–82. [Google Scholar]
Disclaimer/Publisher’s Note: The statements, opinions and data contained in all publications are solely those of the individual author(s) and contributor(s) and not of MDPI and/or the editor(s). MDPI and/or the editor(s) disclaim responsibility for any injury to people or property resulting from any ideas, methods, instructions or products referred to in the content. |
© 2025 by the authors. Licensee MDPI, Basel, Switzerland. This article is an open access article distributed under the terms and conditions of the Creative Commons Attribution (CC BY) license (https://creativecommons.org/licenses/by/4.0/).