commit e1af0af7280ca6beb9d9582fd0e8387a8b0eb744
Author: xfarrow <ale99napoli@icloud.com>
Date:   Mon Aug 14 14:08:19 2023 +0200

    Add files via upload

diff --git a/algorithms-and-data-structures/Algoritmo di Kadane/Algoritmo di Kadane.latex b/algorithms-and-data-structures/Algoritmo di Kadane/Algoritmo di Kadane.latex
new file mode 100644
index 0000000..0519d72
--- /dev/null
+++ b/algorithms-and-data-structures/Algoritmo di Kadane/Algoritmo di Kadane.latex	
@@ -0,0 +1,136 @@
+\documentclass{article}
+
+% Language setting
+% Replace `english' with e.g. `spanish' to change the document language
+\usepackage[italian]{babel}
+
+% Set page size and margins
+% Replace `letterpaper' with `a4paper' for UK/EU standard size
+\usepackage[letterpaper,top=2cm,bottom=2cm,left=3cm,right=3cm,marginparwidth=1.75cm]{geometry}
+
+% Useful packages
+\usepackage{amsmath}
+\usepackage{amssymb}
+\usepackage{graphicx}
+\usepackage{listings}
+\usepackage[colorlinks=true, allcolors=blue]{hyperref}
+
+\title{Algoritmo di Kadane}
+\author{Alessandro Ferro}
+
+\begin{document}
+\maketitle
+
+\begin{abstract}
+Si vuole dimostrare la correttezza dell'Algoritmo di Kadane, in particolare la versione che ammette l'esistenza di una sotto-sequenza vuota (ovvero l'algoritmo non restituirà mai un valore inferiore a 0).
+\end{abstract}
+
+\section{Teorema}
+Per dimostrare la correttezza dell'algoritmo, enunciamo il seguente teorema:
+
+
+Fissati $i,r \in \mathbb{N} $, se $\forall j $ compreso nell'intervallo $ i \leq j < r $ si verifica che 
+
+\begin{itemize}
+\item $SUM(i,j) \geq 0 $
+\item $SUM(i,r) < 0 $
+\end{itemize}
+
+$\implies$
+
+\begin{enumerate}
+\item $SUM(p,q) \leq SUM(i,q) \ \forall p,q $ comprese nell'intervallo $i\leq p \leq q \leq r$
+\item $SUM(p,r+k) < SUM(r+1, r+k) \ \forall p$ comprese nell'intervallo $i \leq p \leq r$ con $k \geq 1$
+\end{enumerate}
+
+\subsection{Dimostrazione informale}
+Dimostriamo dapprima il punto $1$:\\
+Tutte le sequenze $(i,i),(i+1),(i+2),...,(i,q)$ hanno somma non negativa per ipotesi (in quanto $q$ è nell'intervallo $i \leq q < r$), pertanto è evidente che una somma che ha più termini ($SUM(i,q)$) sia maggiore o uguale di una somma che ne ha di meno o in egual misura ($SUM(p,q)$).\\
+
+Adesso dimostriamo il punto $2$:\\
+Tramite una più formale dimostrazione scopriremo che $SUM(p,r) < 0$. Avremo quindi che\\ $SUM(p,r+k) = SUM(p,r) + SUM(r+1,r+k) \implies SUM(p,r+k) < SUM(r+1,r+k)$.
+
+\subsection{Dimostrazione}
+Dimostrazione punto $1$:\\
+Se $p=i$ allora si ha banalmente $SUM(p,q) = SUM(i,q)$. Dimostriamo allora quando $i<p$.\\ \\
+\begin{gather*}
+SUM(i,q) = SUM(i,p-1) + SUM(p,q)\\
+\implies\\
+SUM(p,q) = SUM(i,q) - SUM(i,p-1)
+\end{gather*}
+Sappiamo che $SUM(i,p-1) \geq 0$ in quanto $i \leq p-1 < r$\\ \\
+Ma allora
+\begin{gather*}
+    SUM(p,q) \leq SUM(i,q)
+\end{gather*}
+
+Dimostrazione punto $2$:
+\begin{gather*}
+    SUM(p,r) = SUM(p,r-1) + SUM(r,r)\\
+\end{gather*}
+Sappiamo che $SUM(p,r-1) \leq SUM(i,r-1)$ grazie al teorema del punto $1$ supponendo $q = r-1$\\
+Quindi
+\begin{gather*}
+    SUM(p,r-1) \leq SUM(i,r-1)\\
+     \implies \\
+    SUM(p,r-1) + SUM(r,r) \leq SUM(i,r-1) + SUM(r,r)\\
+\end{gather*}
+
+Sapendo che $SUM(i,r-1) + SUM(r,r) = SUM(i,r)$ e sapendo inoltre che $SUM(i,r) < 0$ si ha che
+
+\begin{gather*}
+    SUM(p,r) \leq SUM(i,r) < 0\\
+    \implies\\
+    SUM(p,r) < 0
+\end{gather*}
+
+Inoltre sappiamo che
+\begin{gather*}
+    SUM(p,r+k) = SUM(p,r) + SUM(r+1,r+k)\\
+    \implies\\
+    SUM(p,r+k) < SUM(r+1,r+k)
+\end{gather*}
+In quanto $SUM(p,r) < 0.$
+
+
+
+
+\subsection{Significato e applicazione del teorema}
+
+Se sappiamo che si verifica questa proprietà allora
+\begin{itemize}
+\item Grazie al punto 1 possiamo dire che $SUM(x,y)$ con $i < x \leq y \leq r$ sarà sempre minore o uguale a $SUM(i,y).$ Poiché il valore di $SUM(i,y)$ lo si conosce già [in quanto abbiamo già analizzato tutte le sequenze $(i,i),(i,i+1),...,(i,r)$], è inutile generare tali sotto-sequenze.
+
+Se per assurdo si avesse che $SUM(x,y) > SUM(i,y)$, la sotto-sequenza localmente massima potrebbe essere $(x,y)$, e dunque sarebbe necessario valutarne il valore della somma.
+\item Grazie al punto $2$ possiamo dire che è inutile analizzare le sequenze $(x,r+k)$ con $x$ nell'intervallo $[i,r]$ perché più avanti si troverà sicuramente una sottosequenza di somma maggiore. 
+\end{itemize}
+
+Dunque, se abbiamo analizzato le sequenze $(i,i),(i,i+1),(i,i+2),...,(i,r)$ sarà inutile analizzare una sequenza $(x,y)$ con $x$ compreso nell'intervallo $i < x \leq r$, perché comunque preso $y$, sarà inutile la sua analisi. 
+
+\newpage
+
+\section{Algoritmo}
+\begin{lstlisting}
+KadaneAlgorithm(Array v){
+	n = v.Length();
+	max_sum = 0;
+	local_sum = 0;
+	
+	for(i = 0 ; i < n ; i++){
+		local_sum = local_sum + v[i];
+		if( local_sum < 0 ){
+			local_sum = 0;
+		}
+		else if( local_sum > max_sum ){
+			max_sum = local_sum;
+		}
+	}
+	
+	return max_sum;
+}
+\end{lstlisting}
+\subsection{Spiegazione}
+L'algoritmo ha una complessità $T(n) = \Theta(n)$ in quanto non genera tutte le sottosequenze possibili (altrimenti il tempo sarebbe stato un $\Omega(n^2)$).\\
+
+Infatti se trova che $SUM(i,r) < 0$ resetta $sum$ a 0 e riparte iniziando a sommare dalla cella $r+1$ in avanti, in virtù del fatto che generare qualsiasi sotto-sequenza $(x,y)$ con $i<x \leq r$ sarebbe inutile.
+\end{document}
\ No newline at end of file
diff --git a/algorithms-and-data-structures/Algoritmo di Kadane/Dimostrazione_Algoritmo_di_Kadane.pdf b/algorithms-and-data-structures/Algoritmo di Kadane/Dimostrazione_Algoritmo_di_Kadane.pdf
new file mode 100644
index 0000000..db94ae1
Binary files /dev/null and b/algorithms-and-data-structures/Algoritmo di Kadane/Dimostrazione_Algoritmo_di_Kadane.pdf differ
diff --git a/algorithms-and-data-structures/Dimostrazione Altezza Albero Red-Black/Dimostrazione Altezza Albero Red-Black.latex b/algorithms-and-data-structures/Dimostrazione Altezza Albero Red-Black/Dimostrazione Altezza Albero Red-Black.latex
new file mode 100644
index 0000000..3fb4fc1
--- /dev/null
+++ b/algorithms-and-data-structures/Dimostrazione Altezza Albero Red-Black/Dimostrazione Altezza Albero Red-Black.latex	
@@ -0,0 +1,137 @@
+documentclass{article}
+
+% Language setting
+% Replace `english' with e.g. `spanish' to change the document language
+usepackage[english]{babel}
+
+% Set page size and margins
+% Replace `letterpaper' with`a4paper' for UKEU standard size
+usepackage[letterpaper,top=2cm,bottom=2cm,left=3cm,right=3cm,marginparwidth=1.75cm]{geometry}
+
+% Useful packages
+usepackage{amsmath}
+usepackage{graphicx}
+usepackage[colorlinks=true, allcolors=blue]{hyperref}
+
+title{Alberi RB $h leq 2log_2(n+1) in O(log_2(n))$}
+author{Alessandro Ferro}
+
+begin{document}
+maketitle
+
+begin{abstract}
+Si vuole dimostrare che l'altezza di un albero Red-Black è un O - grande del logaritmo in base 2 del numero di nodi. In particolare l'altezza è sempre minore o uguale a $2log_2(n+1)$
+end{abstract}
+
+section{Dimostrazione}
+
+Sia 
+$cdot$ h(x) l'altezza dell'albero radicata nel nodo x;
+$cdot$ bh(x) [black height], il numero di nodi neri lungo qualche percorso dal nodo x a una foglia. Viene escluso il colore di x stesso. Questo numero viene indicato come altezza nera.
+$cdot$ NNI(x) il numero di nodi interni (ovvero il numero di nodi non foglia) nell'albero radicato nel nodo x.
+
+subsection{Dimostrazione NNI(x) $geq 2^{bh(x)}-1$}
+
+Prima di procedere a dimostrare la tesi principale, dobbiamo prima dimostrare che il numero di nodi interni radicati nel nodo x è maggiore o uguale a $2^{bh(x)-1}-1$
+paragraph{Dimostrazione 1}
+Dimostriamo questo per induzione sull'altezza dell'albero radicato nel nodo $x$.
+underline{textit{Caso base h(x) = 0}}
+Se l'altezza radicata nel nodo $x$ è 0, allora $x$ è una foglia nera textit{null}. L'altezza nera radicata in $x$ è 0 $[bh(x) = 0]$, così come il numero di nodi interni [NNI(x) = 0].
+Otteniamo dunque
+$$NNI(x) geq 2^{bh(x)}-1$$
+$$NNI(x) geq 0$$
+dunque è quindi valido per il caso base. 
+underline{textit{Caso induttivo h(x) $geq$ 1}}
+Se l'altezza dell'albero radicata in $x$ è maggiore o uguale di 1, allora $x$ è un nodo interno con 2 figli.
+Sappiamo che l'altezza di un albero è sicuramente maggiore dell'altezza dei suoi sottoalberi, ma non possiamo dire lo stesso dell'altezza textbf{nera}.
+Infatti, supponiamo che $y$ sia un nodo figlio di $x$. 
+$y.color = RED implies bh(x) = bh(y)$;
+$y.color = BLACK implies bh(x) = bh(y)+1$ 
+Allora, $bh(y) geq bh(x)-1$.
+Sia $z$ un altro figlio di $x$ vale lo stesso ragionamento fatto con $y$, allora
+$$left{
+begin{array}{c l}	
+    bh(y) geq bh(x)-1 
+    bh(z) geq bh(x)-1
+end{array}right.$$
+Poiché la funzione esponenziale è una funzione monotona, possiamo scrivere
+$$ iff left{
+begin{array}{c l}	
+    2^{bh(y)} geq 2^{bh(x)-1} 
+    2^{bh(z)} geq 2^{bh(x)-1}
+end{array}right.$$
+Sottraiamo 1 ambo i membri
+$$ iff left{
+begin{array}{c l}	
+    2^{bh(y)}-1 geq 2^{bh(x)-1}-1 
+    2^{bh(z)}-1 geq 2^{bh(x)-1}-1
+end{array}right.$$
+
+Poiché gli alberi radicati in $y$ e $z$ hanno un'altezza inferiore all'albero radicato in $x$, per ipotesi induttiva possiamo scrivere
+$$ left{
+begin{array}{c l}	
+    NNI(y) geq 2^{bh(y)}-1 
+    NNI(z) geq 2^{bh(z)}-1
+end{array}right.$$
+Ma allora
+$$ left{
+begin{array}{c l}	
+    NNI(y) geq 2^{bh(y)}-1 geq 2^{bh(x)-1}-1 
+    NNI(z) geq 2^{bh(z)}-1 geq 2^{bh(x)-1}-1
+end{array}right.$$
+Quindi per transitività otteniamo
+$$ left{
+begin{array}{c l}	
+    NNI(y)  geq 2^{bh(x)-1}-1 
+    NNI(z)  geq 2^{bh(x)-1}-1
+end{array}right.$$
+
+E quindi la seguente equazione ha senso
+$$ NNI(y) + NNI(z) geq 2^{bh(x)-1}-1 + 2^{bh(x)-1}-1$$
+
+Sommiamo ambo i membri $1$
+$$ 1+NNI(y) + NNI(z) geq 1+2^{bh(x)-1}-1 + 2^{bh(x)-1}-1$$
+
+e sapendo che il numero di nodi interni di un albero equivale a uno più la somma dei nodi interni dei suoi due sotto-alberi (ovvero $NNI(x) = 1 + NNI(y) + NNI(z)$)
+otteniamo
+$$NNI(x) geq 2  2^{bh(x)-1}-1$$
+$$iff NNI(x) geq 2^{bh(x)}-1 $$
+cvd.
+paragraph{Dimostrazione 2}
+L'albero Red-Black di altezza fissata $bh(x)$ con meno nodi possibile che posso costruire è l'albero pieno con tutti nodi neri $[h(x) = bh(x)]$.
+In un albero pieno, il numero di nodi interni è
+$$2^{bh(x)+1}-1$$
+ma a questo punto per conoscere il numero di nodi interni ci basta calcolare il numero di nodi dell'albero di altezza $bh(x)-1$
+$$NNI(x) = 2^{(bh(x)-1)+1}-1 = 2^{bh(x)}-1$$
+A questo punto possiamo affermare che qualunque albero RB di altezza nera fissata, $bh(x)$ avrà perlomeno $2^{bh(x)}-1$ nodi interni.
+subsection{Dimostrazione $bh(x) geq frac{h(x)}{2}$}
+Fissato $bh(x)$, l'altezza minima che è possibile avere è $bh(x) = h(x)$, ovvero quando il percorso da $x$ a una foglia comprende solo nodi neri, e quindi banalmente
+$$bh(x) geq frac{h(x)}{2}$$
+L'altezza massima che è possibile avere è quando si alterna un nodo nero con uno rosso in quanto per una delle proprietà degli alberi Red-Black non è possibile avere due nodi rossi consecutivi. Avremo quindi che ci sarà un nodo rosso per ogni nodo nero
+$$2bh(x) = h(x) iff bh(x) = frac{h(x)}{2}$$
+e quindi
+$$bh(x) geq frac{h(x)}{2}$$
+vale.
+subsection{Dimostrazione $h leq 2log_2(n+1) in O(log_2(n))$}
+Sapendo che $bh(x) geq frac{h(x)}{2}$ e sapendo che la funzione esponenziale è una funzione monotona, possiamo scrivere
+$$2^{bh(x)} geq 2^{frac{h(x)}{2}}$$
+Sottraiamo 1 ambo i membri
+$$2^{bh(x)} - 1 geq 2^{frac{h(x)}{2}}-1$$
+Da questo e dalla dimostrazione $1.1$ possiamo dire che
+$$NNI(x) geq 2^{bh(x)} -1 geq 2^{frac{h(x)}{2}}-1$$
+e per transitività
+$$NNI(x) geq 2^{frac{h(x)}{2}}-1$$
+Impostiamo $x$ essere la radice dell'albero. Il numero di nodi interni in un albero RB equivale al numero di dati effettivamente presenti (in quanto le foglie non contengono informazione). Quindi $NNI(X) = n$, dunque
+$$n geq 2^{frac{h}{2}}-1$$
+$$iff n+1 geq 2^{frac{h}{2}}$$
+$$iff log_2(n+1) geq frac{h}{2}$$
+$$iff h leq 2log_2(n+1)$$
+$$iff h in O(log_2(n))$$
+cvd.
+bibliographystyle{alpha}
+bibliography{sample}
+begin{itemize}
+item Introduction to Algorithms by Cormen, Leiserson, Rivest, and Stein
+end{itemize}
+
+end{document}
\ No newline at end of file
diff --git a/algorithms-and-data-structures/Dimostrazione Altezza Albero Red-Black/Dimostrazione_Altezza_Albero_Red_Black.pdf b/algorithms-and-data-structures/Dimostrazione Altezza Albero Red-Black/Dimostrazione_Altezza_Albero_Red_Black.pdf
new file mode 100644
index 0000000..c33accc
Binary files /dev/null and b/algorithms-and-data-structures/Dimostrazione Altezza Albero Red-Black/Dimostrazione_Altezza_Albero_Red_Black.pdf differ
diff --git a/algorithms-and-data-structures/Linearity Property applied to convergent series/Linearity Property applied to convergent series.latex b/algorithms-and-data-structures/Linearity Property applied to convergent series/Linearity Property applied to convergent series.latex
new file mode 100644
index 0000000..6d41ad9
--- /dev/null
+++ b/algorithms-and-data-structures/Linearity Property applied to convergent series/Linearity Property applied to convergent series.latex	
@@ -0,0 +1,63 @@
+\documentclass{article}
+\usepackage[utf8]{inputenc}
+\usepackage[letterpaper,top=2cm,bottom=2cm,left=3cm,right=3cm,marginparwidth=1.75cm]{geometry}
+
+% Useful packages
+\usepackage{amsmath}
+\usepackage{graphicx}
+\usepackage[colorlinks=true, allcolors=blue]{hyperref}
+\usepackage{amsmath}
+\usepackage{amssymb}
+
+\title{Linearity Property applied to convergent series}
+\author{Alessandro Ferro}
+\date{May 2022}
+
+\begin{document}
+
+\maketitle
+
+\section{Introduction}
+We want to prove that
+$$  \sum \Theta(f(n)) \in \Theta(\sum f(n))  $$
+
+\section{Proof}
+\subsection{Assumptions}
+$$\sum \Theta(f(n))$$
+$$and$$
+$$\Theta(\sum f(n))$$ 
+could also imply that $f(n)$ is not the same function throughout each sum, but variable accordingly the iterator variable of the sum, so we assume that 
+$$\sum \Theta(f(n))$$ 
+means
+$$\Theta(h(n)) + \Theta(g(n)) + ...$$
+(similarly for $\Theta(\sum f(n))$), so it's the most general way.
+
+\subsection{Proof}
+We prove the theorem by proving that $\Theta(h(n)) + \Theta(g(n)) \in \Theta(h(n) + g(n))$.
+\\
+\\
+To simplify the proof, we'll prove that $O(h(n)) + O(g(n)) \in O(h(n) + g(n))$, since proving it for $\Omega$ is specular. The validity of these claims will eventually prove it for $\Theta$.
+\newpage
+So we want to prove
+$$ O(h(n)) + O(g(n)) \in O(h(n) + g(n)) $$
+By definition of $BigO$ we have that\\
+$\exists c_1 > 0, n_1 > 0 \ : \ \forall n \geq n_1, \ h'(n) \leq c_1 h(n) $
+\\
+$\exists c_2 > 0, n_2 > 0 \ : \ \forall n \geq n_2, \ g'(n) \leq c_2 g(n) $
+\\
+Where $h'(n)$ and $g'(n)$ are the anonymous functions contained in $O(h(n))$ and $O(g(n))$.
+\\
+Let $n_3 = MAX(n_1,n_2)$, then
+$$h'(n) + g'(n) \leq c_1h(n) + c_2g(n) \ \forall n \geq n_3$$
+Let $c_3 = MAX(c_1,c_2)$, then
+$$h'(n) + g'(n) \leq c_1h(n) + c_2g(n) \leq c_3(h(n) + g(n)) \ \forall n \geq n_3$$
+$$\implies h'(n) + g'(n) \leq c_3(h(n) + g(n)) \ \forall n \geq n_3$$
+which means that $h'(n) + g'(n) \in O(h(n)+g(n))$
+\\
+$\square$
+
+\section{Notes}
+Most books do an abuse of notation, reporting this theorem as
+$$\sum \Theta(f(n)) = \Theta(\sum f(n))$$
+
+\end{document}
diff --git a/algorithms-and-data-structures/Linearity Property applied to convergent series/Linearity_Property_applied_to_convergent_series.pdf b/algorithms-and-data-structures/Linearity Property applied to convergent series/Linearity_Property_applied_to_convergent_series.pdf
new file mode 100644
index 0000000..6d39b11
Binary files /dev/null and b/algorithms-and-data-structures/Linearity Property applied to convergent series/Linearity_Property_applied_to_convergent_series.pdf differ
diff --git a/algorithms-and-data-structures/Maximum number of simple paths generable from a graph/Maximum number of simple paths generable from a graph.latex b/algorithms-and-data-structures/Maximum number of simple paths generable from a graph/Maximum number of simple paths generable from a graph.latex
new file mode 100644
index 0000000..268f8ac
--- /dev/null
+++ b/algorithms-and-data-structures/Maximum number of simple paths generable from a graph/Maximum number of simple paths generable from a graph.latex	
@@ -0,0 +1,42 @@
+\documentclass{article}
+
+% Language setting
+% Replace `english' with e.g. `spanish' to change the document language
+\usepackage[english]{babel}
+
+% Set page size and margins
+% Replace `letterpaper' with`a4paper' for UK/EU standard size
+\usepackage[letterpaper,top=2cm,bottom=2cm,left=3cm,right=3cm,marginparwidth=1.75cm]{geometry}
+
+% Useful packages
+\usepackage{amsmath}
+\usepackage{graphicx}
+\usepackage[colorlinks=true, allcolors=blue]{hyperref}
+
+\title{Maximum number of simple paths generable from a graph}
+\author{Alessandro Ferro}
+
+\begin{document}
+\maketitle
+
+\begin{abstract}
+I want to give an exact formula that represents the maximum number of simple paths generable from a graph
+\end{abstract}
+
+\section{Formula}
+
+Let $ G = \langle V,E\rangle $ be a directed graph.\
+The maximum number of simple paths generable from $G$ is
+$$\sum_{i=0}^{|V|}\frac{|V|!}{(|V|-i)!}$$
+
+\subsection{Corollary}
+Let $ G = \langle V,E\rangle $ be an undirected graph.\
+The maximum number of simple paths generable from $G$ is
+$$\sum_{i=0}^{|V|}{\frac{|V|!}{i! * (|V|-i)!}}$$
+
+\section{Explaination}
+
+The formula is derived from the number of possible permutations from a set whose cardinality is $|V|$ into a set whose cardinality is $i$.\newline
+If $S$ is a sequence $\langle s_1, s_2, ... , s_i \rangle $ then we can generate $\frac{|V|!}{(|V|-i)!}$ different simple paths. Then we shall sum the number of possible simple paths for any sequence whose length is $0$ to $|V|$.
+
+\end{document}
\ No newline at end of file
diff --git a/algorithms-and-data-structures/Maximum number of simple paths generable from a graph/Maximum_number_of_simple_paths_in_a_graph.pdf b/algorithms-and-data-structures/Maximum number of simple paths generable from a graph/Maximum_number_of_simple_paths_in_a_graph.pdf
new file mode 100644
index 0000000..575770c
Binary files /dev/null and b/algorithms-and-data-structures/Maximum number of simple paths generable from a graph/Maximum_number_of_simple_paths_in_a_graph.pdf differ
diff --git a/algorithms-and-data-structures/Simplifying Mathematical Notations in Recurrence Equations/Simplifying Mathematical Notations in Recurrence Equations.latex b/algorithms-and-data-structures/Simplifying Mathematical Notations in Recurrence Equations/Simplifying Mathematical Notations in Recurrence Equations.latex
new file mode 100644
index 0000000..e41a94a
--- /dev/null
+++ b/algorithms-and-data-structures/Simplifying Mathematical Notations in Recurrence Equations/Simplifying Mathematical Notations in Recurrence Equations.latex	
@@ -0,0 +1,77 @@
+\documentclass{article}
+\usepackage[utf8]{inputenc}
+\usepackage{amsmath}
+\title{Simplifying Mathematical Notations in Recurrence Equations}
+\author{Alessandro Ferro}
+\date{April 2022}
+
+\begin{document}
+
+\maketitle
+
+\section{Introduction}
+In the book "Introduction to Algorithms" written by CLRS, section 4.4, the following recurrence equation is given:
+
+    \begin{equation}
+        T(n)=
+        \begin{cases}
+        \Theta(1), & \text{if}\ n=1 \\
+        3T(\lfloor n/4 \rfloor) + \Theta(n^2), & \text{otherwise}
+    \end{cases}
+  \end{equation}
+  
+  which later on was simplified as
+  
+      \begin{equation}
+        T(n)=
+        \begin{cases}
+        \Theta(1), & \text{if}\ n=1 \\
+        3T(\lfloor n/4 \rfloor) + cn^2, & \text{otherwise}
+    \end{cases}
+  \end{equation}
+  
+  we will argue that even if $\Theta(n^2)$ is a set, and $c*n^2$ is a scalar and they generally cannot be swapped one with the other, in this case it can be done and will help the equation to be more tractable. 
+ 
+\section{Proof} 
+Let's consider the general case only, so we have
+\begin{gather*}
+    3T(\lfloor n/4 \rfloor) + \Theta(n^2)
+\end{gather*}
+
+which expanded is
+\begin{gather*}
+    3T(\lfloor n/4 \rfloor) + f(n) \ \text{where} \ f(n) \in \Theta(n^2)
+\end{gather*}
+
+$f(n) \in \Theta(n^2)$ means that 
+
+$\exists \ c_1>0,c_2>0,n_0>0$ such that $c_1*n^2 \leq f(n) \leq c_2*n^2 \ \forall n \geq n_0$
+\\ \\
+So we have
+\begin{gather*}
+    3T(\lfloor n/4 \rfloor) + c_1 * n^2 \leq 3T(\lfloor n/4 \rfloor) + f(n) \leq 3T(\lfloor n/4 \rfloor) + c_2 * n^2 \ \forall n \geq n_0
+    \\
+    = 
+    \\
+    \underbrace{3T(\lfloor n/4 \rfloor) + c_1 * n^2}_{\alpha} \leq T(n) \leq \underbrace{3T(\lfloor n/4 \rfloor) + c_2 * n^2}_{\beta} \ \forall n \geq n_0
+\end{gather*}
+So if we resolve $\alpha$ only, we'll have a lower bound for $T(n)$. If we resolve $\beta$ only, we'll have an upper bound for $T(n)$.
+
+
+But $\alpha$ and $\beta$ are asymptotically equivalent, that means that $T(n)$ is asymptotycally equivalent to $\alpha$ and $\beta$ too.
+
+So we just need to resolve either $\alpha$ or $\beta$ to obtain the asymptotic value of $T(n)$, so we can just resolve for a generic $c$ :
+
+      \begin{equation}
+        T(n)=
+        \begin{cases}
+        \Theta(1), & \text{if}\ n=1 \\
+        3T(\lfloor n/4 \rfloor) + cn^2, & \text{otherwise}
+    \end{cases}
+  \end{equation}
+  
+  since using a generic constant won't change the asymptotic value.
+
+\section{Conclusions}
+The concept described in this document and the relative proof can be easily extended to any similar recurrence, and generalized.
+\end{document}
diff --git a/algorithms-and-data-structures/Simplifying Mathematical Notations in Recurrence Equations/Simplifying_Mathematical_Notations_in_Recurrence_Equations.pdf b/algorithms-and-data-structures/Simplifying Mathematical Notations in Recurrence Equations/Simplifying_Mathematical_Notations_in_Recurrence_Equations.pdf
new file mode 100644
index 0000000..3e59e40
Binary files /dev/null and b/algorithms-and-data-structures/Simplifying Mathematical Notations in Recurrence Equations/Simplifying_Mathematical_Notations_in_Recurrence_Equations.pdf differ