# Fuzzy Mathematics with FuzzPy (Part 1)

FuzzPy is a python library that exposes specialized datatypes to deal with a wide range of fuzzy number types, fuzzy sets, and fuzzy graphs. Binary operations against each type, such as set unions and intersections, can be performed using some of python’s native binary operators (|, &, ==), or specialized methods if you wish to deviate from the default functions for these computations.

FuzzPy also provides several helper methods such as kernel and neighbors isolation, alpha-cuts, cardinality testing, shortest-path computation, and minimum spanning trees. A powerful visualization framework also allows you to quickly create and save visualizations for your data.

In this post, we will examine fuzzy sets and fuzzy graphs, and see how one can use FuzzPy to work with these types, providing examples for each. In the next post of this series, we will examine the different types of fuzzy numbers, generate visualizations, and explore advanced concepts such as automatic fuzzification, and importing graph data from fuzzy adjacency matrices.

## Fuzzy Sets

A fuzzy set is simply a set in which each element has an associated degree of membership into the set. This membership value is called $\mu$-value of the element. A $\mu$-value of zero indicates that the element does not belong to the set, while any value between zero (exclusive) and one (inclusive), indicates that the element is, to a certain degree, a set member.

Creating a fuzzy set with FuzzPy is just a matter of creating a new FuzzySet object, then either calling the add(FuzzyElement(value, mu)) method for each element to import, or using the update(elements) method, providing it with a list of FuzzyElement(value, $\mu$-value) tuples for bulk import.

from fuzz import FuzzySet, FuzzyElement   # Create two lists of FuzzyElements elements_a = [(1, 0.3), (2, 0.5), (3, 0.7), (4, 0.9)] elements_b = [(3, 0.8), (6, 0.6), (1, 0.4), (8, 0.2)]   elements_a = [FuzzyElement(x[0], x[1]) for x in elements_a] elements_b = [FuzzyElement(x[0], x[1]) for x in elements_b]   # Create two fuzzy sets set_a = FuzzySet() set_b = FuzzySet()   set_a.update(elements_a) set_b.update(elements_b)

We’ve just created a couple fuzzy sets with four elements each. Notice that two of the elements are common to both set_a and set_b (albeit with different $\mu$-values). We can now perform several operations against these sample sets. Save the code above in a file called example.py and fire up the python interpreter to test fuzzy set functionality against our sets:

>>> from example import * >>> # Set Difference ... >>> set_a - set_b FuzzySet([FuzzyElement(2, 0.500000), FuzzyElement(4, 0.900000)]) >>> set_b - set_a FuzzySet([FuzzyElement(8, 0.200000), FuzzyElement(6, 0.600000)]) # Set Union ... >>> set_a | set_b FuzzySet([FuzzyElement(1, 0.400000), FuzzyElement(2, 0.500000), FuzzyElement(3, 0.800000), FuzzyElement(4, 0.900000), FuzzyElement(6, 0.600000), FuzzyElement(8, 0.200000)]) # Set Intersection ... >>> set_a & set_b FuzzySet([FuzzyElement(1, 0.300000), FuzzyElement(3, 0.700000)])

## Fuzzy graphs

In a fuzzy graph or digraph, each vertice and each edge can be associated with a $\mu$-value. The $\mu$-value of a vertice indicates the vertice’s degree of membership into the graph, while an edge or arc’s $\mu$-value indicates the degree of connectivity between the head and tail vertices.

The creation of fuzzy graphs is also pretty straightforward: create a set or fuzzy set (see above), then feed that set to the fuzz.Graph constructor, along with the directed boolean value to specify whether you’d like to create a graph or a digraph. You can then use the fuzz.Graph.connect(head, tail, mu) method to add edges to the graph:

import fuzz   # Create two sets of vertices set_a = set([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) set_b = set([11, 12, 13, 14, 15, 16, 17, 18, 19, 20])   # Create our graph objects graph_a = fuzz.FuzzyGraph(viter=set_a, directed=False) graph_b = fuzz.FuzzyGraph(viter=set_b, directed=True)   # Create some arcs in graph_a graph_a.connect(1, 3, 0.5) graph_a.connect(3, 6, 0.06) graph_a.connect(2, 8, 0.2) graph_a.connect(4, 1, 0.9)   # And some in graph_b graph_b.connect(11, 19, 0.9) graph_b.connect(14, 12, 0.3) graph_b.connect(15, 14, 0.5)

Save the code above in a file named graphs.py and fire up your python interpreter so we can experiment with graph operations:

>>> from graphs import * >>> # Retrieve the mu value of the edge between 1 and 3 ... >>> graph_a.mu(3, 1) 0.5 >>> # Retrieve an alpha-cut of graph_b against mu-value of 0.5 ... >>> graph_b.alpha(0.5) Graph(viter = set([11, 12, 13, 14, 15, 16, 17, 18, 19, 20]), eiter = set([(15, 14), (11, 19)]), directed = True) >>> # Is graph_a a subgraph of graph_b? (no) ... graph_a.issubgraph(graph_b) False >>> # Detect adjacent (connected) vertices ... >>> graph_a.adjacent(1, 2) False >>> graph_a.adjacent(1, 3) True >>> # Find all the neighbours of the vertex with value 3 ... >>> graph_a.neighbors(3) set([1, 6]) >>> # Find the shortest path to all vertices using 6 as origin ... >>> graph_a.dijkstra(6) {1: 3, 2: None, 3: 6, 4: 1, 5: None, 6: None, 7: None, 8: None, 9: None, 10: None} >>> # Find the minimum spanning tree of graph_a ... >>> graph_a.minimum_spanning_tree() Graph(viter = set([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]), eiter = set([(2, 8), (1, 3), (4, 1), (3, 6)]), directed = False)

There are a few more operations available for both crisp and fuzzy graphs/digraphs. You should consult the API doc for a comprehensive list.

You should also consult the examples provided as part of the module on GitHub to see FuzzPy in action.

Related posts: