Euler Diagram | Why Must Know? Ultimate and Detailed Explanation Ever

An Euler diagram is a type of diagram used to represent sets and their relationships. The diagram is composed of circles or other closed shapes, which are used to represent sets or categories, and overlapping regions, which represent the relationships between those sets.

The diagram is named after the Swiss mathematician Leonhard Euler, who first used this type of diagram to study the relationships between sets in mathematics.

Euler diagrams are often used to visualize logical relationships, such as the relationships between different types of animals, plants, or objects. They can also be used to represent the relationships between different concepts or ideas, such as in the fields of philosophy or linguistics.

One of the key benefits of Euler Diagrams is that they can help us to see patterns and relationships in data that might not be immediately apparent from a simple list or table. By visualizing these relationships, we can gain a deeper understanding of the data and use that knowledge to make better decisions. The most important usage for us is the explanation of logic in programming in a visual way. This is what we'll talk about today.

Explanation

In simple terms, before the Euler diagram, these are two sets that either have nothing to do with each other at all, or interact with each other and this interaction can be visualized. Since we are all involved in IT in one way or another, I will try to give real examples in this industry. No cats and dogs, balloons and ice cream, sorry. I'll start with the simplest example with lists.

  list1 = [125, 567, 908, 230, 742]
  list2 = [36, 125, 742, 649, 101]                    
          

Example 1

There are lists in every programming language, and I think this example will already make a lot of things clear. Imagine that we have two lists with absolutely random numbers. For clarity, let's imagine that these are the unique identifiers of the students attending webinar A and webinar B.

With a database of five rows, it would not be difficult to determine which students attended both events, but for a million rows, this is hardly feasible. To determine the common elements, a simple python script will help us:

  list1 = [125, 567, 908, 230, 742]
  list2 = [36, 125, 742, 649, 101]
            
  common_elements = []
            
  for element in list1:
    if element in list2:
      common_elements.append(element)
            
  print("The common elements in the two lists are:", common_elements)                     
          

However, visually, this can be displayed on the Euler diagram, on these pretty multi-colored circles. Each circle represents a set of values (in our case, a list), and the intersection of these circles represents common values, which is quite logical.

list1 And list2 Common Elements

Someone will ask why this is necessary. Will explain. This is a great way to understand the code. If you copy code and paste it from some Overflow Stask mindlessly and don't even look at how it works, but only evaluate the result, then this is a problem. Yes, this way you will achieve results faster, but you will not be able to grow and develop professionally in this way. Cultivate a keen interest in how your code works, especially if you are just starting to do it, if you are a beginner.

Example 2

I love Euler diagrams also because of their versatility, because in fact I can visualize any set with them. Let's take another example and add, for example, the third set.

For the following lists

  list1 = [125, 567, 908, 230, 742]
  list2 = [36, 125, 742, 649, 101]
  list3 = [42, 36, 71, 101, 4]                      
          

Euler diagrams will look like this:

list1, list2 And list3 Common Elements

As you can see, each set has its own intersections with another, neighboring set. You can borrow a drill from the upstairs neighbor and a corkscrew from the downstairs neighbor. You will have these two tools, but you will share them with your neighbors, since they do not belong to you.

Example 3

Following the absolutely identical logic from the previous example, we can make it so that all of our three sets have common elements, and not each with a connection separately. Returning to the list example, it would look like this:

  list1 = [125, 567, 908, 230, 742]
  list2 = [36, 125, 742, 649, 101]
  list3 = [42, 125, 71, 742, 4]                      
          

And on the diagram it will look like this:

Common Elements in 3 Sets

Citing the previous example with neighbors. Imagine that you save something, you bought one drill for three apartments, since you don’t use this tool so often. This common tool for the three of you will be the intersection in this diagram.

Example 4

Cool, we figured out the basic logic. Now it will be a little more complicated and we will add some restrictions and conditions. For example, which area on this diagram corresponds to the condition - the element is present in the set A, B, but absent in the set C.

More Complicated Euler Diagrams Example

Translating the explanation into human language - our downstairs neighbor and I have a toolbox, and the upstairs neighbor has his own tools. From our compiled diagram, you can easily start writing code:

  list1 = [125, 567, 908, 230, 742]
  list2 = [36, 125, 742, 649, 101]
  list3 = [42, 125, 71, 742, 4]
            
  for element in list1:
    if element in list2 and element not in list3:
      print(element)               
          

Example 5

Consider another complex example with sets. When one of the sets has common elements with others separately and does not have common elements among three at once. Such a diagram would look like this.

More Complicated Euler Diagrams Example

Again, translating into human language - I have a screwdriver with my neighbor from below (each), and with a neighbor from above I have a drill (each). At the same time, the neighbor above and the neighbor below do not have common tools.

According to the diagram, we can now write code

  result = set()

  for element in A.union(B):
    if element in A and element in B and element not in C:
      result.add(element)
            
  print(result)              
          

Conclusion

Euler Diagrams are a powerful and useful tool for representing the relationships between different sets of data. They have been used in a wide range of fields, from mathematics and science to philosophy and linguistics, and they can help us to visualize complex relationships in a way that is easy to understand.

Whether you are working with data in a scientific or academic setting, or simply trying to organize your thoughts and ideas, Euler Diagrams can be an incredibly valuable tool. By understanding the basics of how these diagrams work and some of the many ways in which they can be used, you can gain a deeper insight into the relationships between data sets and make more informed decisions as a result.

The purpose of my article was to show you that parsing the logic of code is a very useful activity, especially when you are just learning to program. You can disassemble logic in a huge number of ways, and I showed you one of the most popular and useful, from my point of view. I hope I was able to convey this to you. The site also has an article about Euler diagrams. If you still have questions, be sure to read and the questions will disappear.