my-markdown-library 0.1.0

data/F24Lec_MD/lec06/6.4-latex.md

@@ -0,0 +1,138 @@
+---
+title: "6.4-latex"
+type: lecture-notebook
+week: 6
+source_path: "/Users/ericvandusen/Documents/Data88E-ForTraining/F24Lec_NBs/lec06/6.4-latex.ipynb"
+---
+
+<table style="width: 100%;">
+    <tr style="background-color: transparent;"><td>
+        <img src="https://data-88e.github.io/assets/images/blue_text.png" width="250px" style="margin-left: 0;" />
+    </td><td>
+        <p style="text-align: right; font-size: 10pt;"><strong>Economic Models</strong><br>
+            Dr. Eric Van Dusen <br>
+            Akhil Venkatesh
+             </p></td></tr>
+</table>
+
+## Writing Equations in LaTeX
+### Start by building up from elements
+
+Let's start writing equations and make them more complicated little by little - let's use the $ sign to offset the equations within the cell. All of these will be in Markdown cells.  When we use two dollar signs we get the equation displayed on its own line.
+
+Start with a function that takes two arguments K and L
+$$
+f(K, L) 
+$$
+
+then we want to use a greek symbol $alpha$
+that we will use a \ to denote
+$$
+\alpha
+$$
+
+And we want to raise the value of K to the power of $\alpha$
+$$
+K^\alpha
+$$
+
+**Your turn!** You can go ahead and do the same thing for $L$ to the power of $\beta$
+$$
+.... 
+$$
+
+Let's combine these elements to be the basis of the Cobb-Douglas Production Function:
+$$
+f(K, L) = K^\alpha L^\beta \\
+$$
+
+For modeling National GDP we can also add in $Y$ and the technology shifter $A$
+$$
+Y = A \cdot f(K, L) = A K^\alpha L^\beta
+$$
+
+A common simplification is to constrain $ \alpha + \beta = 1 $ which can be rearranged to
+$$
+\beta = 1 - \alpha
+$$
+
+First Derivative
+$$
+X_{1}^{\alpha - 1} X_{2}^{1 - \alpha} \alpha
+$$
+
+Second Derivative 
+
+$$
+X_{1}^{\alpha - 2} X_{2}^{1 - \alpha} \alpha \left(\alpha - 1\right)
+$$
+
+So then we can rewrite the original equation as: 
+$$
+Y = A K^\alpha L^{1 - \alpha}
+$$
+
+## Writing Equations in LaTeX
+Try completing some of these exercises as practice!
+
+If you get stuck, check out the LaTeX Guide: https://math.hws.edu/gassert/LaTeX_Guide_Title.pdf!
+
+**1. Quadratic Formula:**
+
+![quadratic.PNG](attachment:quadratic.PNG)
+
+**Try it out!**
+$$
+.... 
+$$
+
+# Lets try Markdown as well!
+
+# Here's how you get each of the different heading sizes!
+___
+# Heading 1 
+## Heading 2 
+### Heading 3 
+#### Heading 4 
+##### Heading 5 
+###### Heading 6
+
+# How about a List ( unordered) 
+ 1. here is one item
+ 2. here is a second item
+ 3. here is a third
+
+## Here is how to make a table
+
+| Id | Label | Price |
+|--- |----------| ------|
+| 01 | Markdown |\$1600 |
+| 02 | is | \$12 |
+| 03 | AWESOME | \$999 |
+
+**bold text**
+
+*italics*
+
+`code`
+
+```python
+
+```
+
+# How about an Emoji?
+## You can copy and paste  or. 
+
+😊
+
+&#128512;
+
+# How about a link
+[What a cool class!](https://data88e.org)
+
+
+
+```python
+
+```
+

data/F24Lec_MD/lec06/6.5-Edgeworth.md

@@ -0,0 +1,269 @@
+---
+title: "6.5-Edgeworth"
+type: lecture-notebook
+week: 6
+source_path: "/Users/ericvandusen/Documents/Data88E-ForTraining/F24Lec_NBs/lec06/6.5-Edgeworth.ipynb"
+---
+
+## Edgeworth Box Demo
+### as another application of Cobb-Douglas Utility Function
+
+
+The code is taken from "Gaby Galvan" 
+https://deepnote.com/app/gaby-galvan/Edgeworth-Box-5c892517-cb51-4f3f-b20d-8e5dd8b5ac46
+
+```python
+import numpy as np
+import matplotlib.pyplot as plt
+import pandas as pd
+```
+
+```python
+out = 0
+```
+
+### Overview of the Edgeworth Box
+
+An **Edgeworth box** is a graphical representation used in microeconomics to illustrate the distribution of resources (goods) between two consumers in a simple exchange economy. It shows all possible allocations of two goods between two consumers and helps analyze their preferences, trade possibilities, and potential for reaching Pareto-efficient outcomes.
+
+In your scenario:
+
+- **Two Consumers**: The consumers are trading Noodles and Cereal.
+- **Objective**: To visualize how these consumers can trade to reach mutually beneficial (Pareto-efficient) allocations based on their utility preferences.
+
+---
+
+### Key Components of the Code
+
+Let’s break down the main elements of your code to understand how it represents the economic concepts:
+
+#### 1. Utility Functions (`U1` and `U2`)
+
+- **Purpose**: Represent the satisfaction (utility) each consumer derives from consuming Noodles (X) and Cereal (Y).
+- **Form**: Must be functions of two variables, e.g., `U1(x, y)` and `U2(x, y)`.
+- **Interpretation**: The shape of the utility functions reflects each consumer's preferences and marginal rates of substitution (MRS) between Noodles and Cereal.
+
+#### 2. Edgeworth Box Dimensions (`Xmax`, `Ymax`, `Xmin`, `Ymin`)
+
+- **`Xmax` and `Ymax`**: Total available quantities of Noodles and Cereal in the economy.
+- **`Xmin` and `Ymin`**: Set close to zero to avoid computational issues with logarithmic utilities or division by zero.
+- **Interpretation**: The box's dimensions represent the entire feasible set of allocations between the two consumers.
+
+#### 3. Indifference Curves
+
+- **Definition**: Curves along which a consumer derives the same level of utility.
+- **Implementation**: The code uses `plt.contour()` to draw these curves for both consumers.
+- **Economic Intuition**:
+    - **Consumer 1**: Indifference curves are plotted from the origin at (0,0).
+    - **Consumer 2**: Indifference curves are plotted from the opposite corner (Xmax, Ymax), reflecting that any consumption by Consumer 1 reduces the amount available to Consumer 2.
+
+#### 4. Contract Curve
+
+- **Definition**: The set of allocations where the indifference curves of the two consumers are tangent—i.e., where their MRS are equal.
+- **Implementation**:
+    - Calculated by finding where the gradients of the utility functions are proportional.
+    - The code computes gradients using `np.gradient()` and identifies where the determinant of the Jacobian (`out`) is zero.
+    - Plotted using `plt.contour()` with specific levels.
+- **Economic Intuition**: Represents all Pareto-efficient allocations—no consumer can be made better off without making the other worse off.
+
+#### 5. Allocation Point (`AlPoint`)
+
+- **Purpose**: Represents a specific allocation of Noodles and Cereal between the two consumers.
+- **Usage**:
+    - If provided, the code plots this point and the corresponding indifference curves passing through it for both consumers.
+    - Helps visualize the initial endowment and potential gains from trade.
+- **Economic Intuition**: Demonstrates how consumers can move from an initial allocation to a Pareto-efficient allocation through mutually beneficial trade.
+
+#### 6. Utility Levels and Number of Indifference Curves (`Utility_Show`, `Num_ind`)
+
+- **`Utility_Show`**: When `True`, displays utility levels on the indifference curves.
+- **`Num_ind`**: Controls the number of indifference curves plotted for each consumer.
+- **Economic Intuition**: More curves provide a detailed view of preferences but may clutter the graph; adjusting `Num_ind` balances detail and clarity.
+
+#### 7. Other Parameters
+
+- **Labels (`Xlab`, `Ylab`)**: Axis labels for clarity—here, they should be set to "Noodles" and "Cereal."
+- **Colors (`colors`)**: Customize the appearance of the plot elements for better distinction.
+- **Endowment (`e`)**: Number of steps used in calculations—higher values lead to smoother curves but increase computation time.
+
+---
+
+### Economic Intuition Behind the Code
+
+#### Mutually Beneficial Trade
+
+- **Starting Point**: Consumers begin with an initial allocation of Noodles and Cereal.
+- **Objective**: Through trade, both aim to reach higher indifference curves, thus achieving higher utility levels.
+- **Visualization**: The movement from the initial allocation point towards the contract curve represents this process.
+
+#### Marginal Rate of Substitution (MRS)
+
+- **Definition**: The rate at which a consumer is willing to trade one good for another while maintaining the same utility level.
+- **Equal MRS**: At points on the contract curve, both consumers have equal MRS, meaning they value the trade-off between Noodles and Cereal equally.
+- **Economic Intuition**: Equating MRS ensures that resources are allocated efficiently between the two consumers.
+
+#### Pareto Efficiency
+
+- **Definition**: An allocation is Pareto-efficient if no consumer can be made better off without making the other worse off.
+- **Contract Curve**: All points along this curve are Pareto-efficient allocations.
+- **Visualization**: The contract curve in the Edgeworth box shows all such allocations.
+
+#### Utility Maximization
+
+- **Consumers' Goal**: Each aims to reach the highest possible indifference curve given their budget constraints (the total available goods).
+- **Constraints**: Limited by the total quantities of Noodles and Cereal in the economy.
+- **Trade-Offs**: Consumers make choices based on their preferences, as depicted by the shapes of their indifference curves.
+
+
+### Interpreting the Graph
+
+#### Axes
+
+- **Horizontal Axis**: Quantity of Noodles consumed by Consumer 1 (Alice).
+- **Vertical Axis**: Quantity of Cereal consumed by Alice.
+- **Origin for Consumer 2 (Bob)**: Located at the top-right corner
+
+```python
+ 
+def draw_Ed_Bow(U1,U2, Xmax, Ymax, Xmin=10**(-6), Ymin=10**(-6), Utility_Show = False, Num_ind = 10,Xlab ="X",Ylab="Y",e=200, Contract_draw=True,AlPoint = None,colors =["black","Orange", "blue","red"],Utility_draw = True):
+    """
+    Input : 
+        U1: Utility of the 1st agent (must depend on 2 variables)
+        U2: Utility of the 2nd agent (must depend on 2 variables)
+        Xmax : the limit of the box
+        Ymax: the limit of the box
+        Xmin=10**(-6): the limit of the box (default: set to ~0 to avoid problems with log expressions)
+        Ymin=10**(-6): the box limit (default: set to ~0 to avoid problems with log expressions)
+        Utility_Show = False: Show utility levels on the Edgeworth box
+        Num_ind = 10 : Number of indifference curves per agent
+        e = 200 : Number of steps to compute the utility levels and the contract curve
+        Contract_draw = True: Draw the contract curve 
+        AlPoint = None : show an allocation point and his 2 indifference curves. Should be a tuple/list (x,y)
+        colors = ["black","Orange", "blue","red"] : To choose the color of : [ContractCurve, endowment point, indifference curves Agent1, indifference curves agent2]
+        Utility_draw = True : Draw the indefrence curves
+    Output:
+        None (but draws the Edgeworth box) 
+    """
+    delta = min((Xmax-Xmin)/e,(Ymax-Ymin)/e)
+
+    x = np.arange(Xmin, Xmax, delta) #Tomates
+    y = np.arange(Ymin, Ymax, delta) #courgettes
+    X, Y = np.meshgrid(x, y)
+    Z1 = lambda x,y : U1(x,y)
+    Z2 = lambda x,y : U2(Xmax-x,Ymax-y)
+
+    #the contract curve
+    Num_ind_1 = Num_ind
+    Num_ind_2 = Num_ind
+
+    if Contract_draw == True:
+        Z2grad = np.gradient(Z2(X,Y))
+        Z1grad = np.gradient(Z1(X,Y))
+
+        global out
+        out = (Z2grad[0]*Z1grad[1]-Z2grad[1]*Z1grad[0])
+
+        Cont = plt.contour(X,Y,out,colors=colors[0],levels=[0])
+        fmt = {}
+        strs = ["Contract  curve"]
+        for l, s in zip(Cont.levels, strs):
+            fmt[l] = s
+        plt.clabel(Cont, Cont.levels, inline = True,
+                fmt = fmt, fontsize = 10)
+        
+        C_curv = abs(pd.DataFrame(out ,index=y, columns=x))
+        C_curv = C_curv.index @ (C_curv == C_curv.apply(min))
+        xC_curv = np.arange(Xmin,Xmax,(Xmax-Xmin)/(Num_ind+1))
+        C_curv = np.interp(xC_curv,C_curv.index,C_curv)
+        Num_ind_1 = pd.Series(Z1(xC_curv,C_curv)).sort_values(ascending=True)
+        Num_ind_2 = pd.Series(Z2(xC_curv,C_curv)).sort_values(ascending=True)
+        
+    #Draw the dotation point and his curves
+    if AlPoint != None:
+        plt.scatter(AlPoint[0],AlPoint[1],s=200,marker=".",color = colors[1],label="Allocation point")
+        Num_ind_1 = [Z1(AlPoint[0],AlPoint[1])]
+        Num_ind_2 = [Z2(AlPoint[0],AlPoint[1])]
+
+    #draw the indifference curve
+    if Utility_draw == True:
+        C1 = plt.contour(X, Y, Z1(X,Y),colors = colors[2],levels=Num_ind_1)
+        C2 = plt.contour(X, Y, Z2(X,Y),colors = colors[3],levels=Num_ind_2)
+        if Utility_Show == True:
+            fmt = {}
+            strs = round(pd.Series(C1.levels[:]),1)
+            for l, s in zip(C1.levels, strs):
+                fmt[l] = s
+            plt.clabel(C1, C1.levels, inline = True,
+                    fmt = fmt, fontsize = 10)
+            #Utility level2
+
+            fmt = {}
+            strs = round(pd.Series(C2.levels[:]),1)
+            for l, s in zip(C2.levels, strs):
+                fmt[l] = s
+            plt.clabel(C2, C2.levels, inline = True,
+                    fmt = fmt, fontsize = 10)
+
+
+    plt.title("Edgeworth box")
+    plt.xlabel(Xlab)
+    plt.ylabel(Ylab)
+```
+
+## We can then set the parameters for Alpha and Beta in the Cobb - Douglas formula
+
+##  Let's consider the simpler case of a Utility function 
+- that has a Cobb-Douglas type formulation 
+- consists of consuming two goods $X1$ and $X2$
+
+$  U = \cdot X1^{\alpha} \cdot X2^{1-\alpha}$
+
+```python
+#Utility of 1st agent (depend on X,Y):
+U1 = lambda c,n : c**0.5 * n**0.5
+#Utility of 2nd agent (depend on X,Y):
+U2 = lambda c,n : c**0.5 * n**0.5
+
+
+draw_Ed_Bow(U1,U2,18,30,colors=["k","Orange", "lightblue","mistyrose"],Num_ind=3)
+draw_Ed_Bow(U1,U2,18,30,Xlab="Cereal",Ylab="Noodles",AlPoint=(10,16),Contract_draw=False)
+plt.show()
+```
+
+```python
+#Utility of 1st agent (depend on X,Y):
+U1 = lambda c,n : c**0.7 * n**0.3
+#Utility of 2nd agent (depend on X,Y):
+U2 = lambda c,n : c**0.5 * n**0.5
+
+
+draw_Ed_Bow(U1,U2,18,30,colors=["k","Orange", "lightblue","mistyrose"],Num_ind=3)
+draw_Ed_Bow(U1,U2,18,30,Xlab="Cereal",Ylab="Noodles",AlPoint=(11.5,13),Contract_draw=False)
+plt.show()
+```
+
+## General parameters for $\alpha $ and $ \beta $
+
+```python
+alpha1 = 0.5
+beta1 = 0.5
+alpha2 = 0.7
+beta2 = 0.3
+```
+
+```python
+#Utility of 1st agent (depend on X,Y):
+U1 = lambda c,n :n**alpha1 * c**beta1
+#Utility of 2nd agent (depend on X,Y):
+U2 = lambda c,n : n**alpha2 * c**beta2
+
+
+draw_Ed_Bow(U1,U2,30,18,colors=["k","Orange", "lightblue","mistyrose"],Num_ind=3)
+draw_Ed_Bow(U1,U2,30,18,Xlab="Cereal",Ylab="Noodles",AlPoint=(18,7),Contract_draw=False)
+plt.show()
+```
+
+```python
+
+```
+

data/F24Lec_MD/lec07/7.1-inequality.md

@@ -0,0 +1,283 @@
+---
+title: "7.1-inequality"
+type: lecture-notebook
+week: 7
+source_path: "/Users/ericvandusen/Documents/Data88E-ForTraining/F24Lec_NBs/lec07/7.1-inequality.ipynb"
+---
+
+<table style="width: 100%;" id="nb-header">
+    <tr style="background-color: transparent;"><td>
+        <img src="https://data-88e.github.io/assets/images/blue_text.png" width="250px" style="margin-left: 0;" />
+    </td><td>
+        <p style="text-align: right; font-size: 10pt;"><strong>Economic Models</strong>, Fall 23<br>
+            Dr. Eric Van Dusen <br>
+        Akhil Venkatesh <br>
+</table>
+
+From the Textbook Chapter
+https://data-88e.github.io/textbook/content/06-inequality/inequality.html
+
+```python
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+from datascience import *
+%matplotlib inline
+#plt.style.use('seaborn-muted')
+```
+
+# Lec 7.1  Measurements of Inequality
+
+## The Lorenz Curve
+The Lorenz Curve visually presents income inequality by plotting household income percentile on the $x$-axis, and the cumulative income share that the bottom $x$ percentile own on the $y$-axis. The households are sorted by income, so that the first household at the 0th percentile has the least amount of income, while the household at the 100th percentile has the greatest income.
+
+For any point $(x,y)$ on the Lorenz curve, “the bottom x percent own y% of the income”. For example, if the $x$-axis reads 0.30 and $y$-axis reads 0.10, then it means that the bottom 30% of the population received 10% of the total population's income. This yields 2 implications for the Lorenz Curve:
+- The points $(0,0)$ and $(1,1)$ are always on the curve. $(0,0)$ represents the 0% of the population owning 0% of the income and $(1,1)$ represents 100% of the population owning 100% of the income.
+- The slope is always increasing. This is because households are sorted by income as percentiles: for a slight increase in $x$, households become richer and hence provide a larger share of total income.
+
+### Line of Perfect Equality
+In a world of perfect equality, everyone would have the exact same income. In this case, the Lorenz curve would just be a 45-degree straight line that runs through $(0,0)$ and $(1,1)$, i.e. $y=x$. Mathematically, this is because the derivative is constant: for a slight increase in $x$, the total share of income increases at a constant rate. Another way to think about this is that the bottom 10% of the population will own 10% of the total income, the bottom 50% of the population will own 50% of the total income, and so on. This line is known as the *line of perfect equality*, and we typically display this line when plotting our Lorenz curves as a reference.
+
+### A Toy Example
+Let's suppose country 1 has the following income distribution: 
+- The bottom 10% owns a cumulative 2% of total income 
+- The bottom 20% owns 5% of total income
+- The bottom 30% owns 9% of total income
+- The bottom 40% owns 15% of total income 
+- The bottom 50% owns 23% of total income
+- The bottom 60% owns 33% of total income
+- The bottom 70% with 45% of total income
+- The bottom 80% with 59% of total income 
+- The bottom 90% with 75% of total income
+- The bottom 100% with 100% of total income
+
+We will create an array of income shares and call it `Country1`.
+
+```python
+Country1 = make_array(0, 0.02, 0.05, 0.09, 0.15, 0.23, 0.33, 0.45, 0.59, 0.75, 1.0)
+```
+
+To better see this information, we will create a table containing population percentage and cumulative income share.
+
+```python
+income_distribution = Table().with_columns(
+    "Population Percentage (%)", np.arange(11) * 10, 
+    "Cumulative Income Share (%)", Country1 * 100, 
+    "Perfect Equality Income Share (%)", np.arange(11) * 10
+)
+income_distribution
+```
+
+How will the Lorenz Curve for this income distribution look?
+
+```python
+income_distribution.scatter(0, 1, width=11, height=7)
+plt.plot([0,100], [0,100], color='k');
+```
+
+### Comparing Lorenz Curves
+Now let's compare 2 countries' Lorenz curves. Suppose country 2 has the following income distribution:
+- The bottom 10% owns a cumulative 3% of total income 
+- The bottom 20% owns 7% of total income
+- The bottom 30% owns 13% of total income
+- The bottom 40% owns 19% of total income 
+- The bottom 50% owns 27% of total income
+- The bottom 60% owns 37% of total income
+- The bottom 70% with 50% of total income
+- The bottom 80% with 65% of total income 
+- The bottom 90% with 81% of total income
+- The bottom 100% with 100% of total income
+
+```python
+Country2 = make_array(0, 0.03, 0.07, 0.13, 0.19, 0.27, 0.37, 0.5, 0.65, 0.81, 1.0)
+income_distribution2 = Table().with_columns(
+    "Population Percentage (%)", np.arange(11) * 10, 
+    "Cumulative Income Share (%)", Country2 * 100, 
+    "Perfect Equality Income Share (%)", np.arange(11) * 10
+)
+income_distribution2
+```
+
+Comparing the 2 countries' income distributions side by side:
+
+```python
+income_distribution.join(
+    ["Population Percentage (%)", "Perfect Equality Income Share (%)"], 
+    income_distribution2, ["Population Percentage (%)", "Perfect Equality Income Share (%)"]
+).relabel(
+    "Cumulative Income Share (%)", "Country 1 Cumulative Income Share (%)"
+).relabel(
+    "Cumulative Income Share (%)_2", "Country 2 Cumulative Income Share (%)"
+)
+```
+
+Plotting both countries' Lorenz curves, can you tell which country has a higher level of income inequality?
+
+```python
+plt.figure(figsize=[7,7])
+plt.plot(income_distribution.column(0), income_distribution.column(1), "-o", c = 'b')
+plt.plot(income_distribution.column(0), income_distribution2.column(1), "-o", c = 'r')
+plt.legend(["Country 1", "Country 2"])
+plt.plot([0,100], [0,100], color='k');
+```
+
+In this case, we can see that country 2's Lorenz curve is closer to the line of equality than that of country 1, which intuitively would suggest that country 2 is more equal. If we were to look at the numbers, we see that the bottom percentiles own a higher % of total national income in country 2 than in country 1, while top percentiles own less in country 2 than in country 1. This would suggest that country 2 is more equal in income than country 1, so that country 1 has a higher level of income inequality.
+
+But now let's consider a different case; suppose country 3 has the following distribution:
+
+```python
+Country3 = make_array(0, 0.03, 0.07, 0.12, 0.18, 0.25, 0.33, 0.42, 0.54, 0.73, 1.0)
+income_distribution3 = Table().with_columns(
+    "Population Percentage (%)", np.arange(11) * 10, 
+    "Cumulative Income Share (%)", Country3 * 100, 
+    "Perfect Equality Income Share (%)", np.arange(11) * 10
+)
+income_distribution.join(
+    ["Population Percentage (%)", "Perfect Equality Income Share (%)"], 
+    income_distribution3, ["Population Percentage (%)", "Perfect Equality Income Share (%)"]
+).relabel(
+    "Cumulative Income Share (%)", "Country 1 Cumulative Income Share (%)"
+).relabel(
+    "Cumulative Income Share (%)_2", "Country 3 Cumulative Income Share (%)"
+)
+```
+
+```python
+plt.figure(figsize=[7,7])
+plt.plot(income_distribution.column(0), income_distribution.column(1), "-o", c = 'b')
+plt.plot(income_distribution.column(0), income_distribution3.column(1), "-o", c = 'r')
+plt.legend(["Country 1", "Country 3"])
+plt.plot([0,100], [0,100], color='k');
+```
+
+Now, ambiguity arises; while bottom income percentiles earn a larger share of national income in country 3, top income percentiles also have a larger share. We can visualize this phenomenon by the 'crossing' of Lorenz curves on the plot. As a result, we do cannot easily tell which country has a higher level of income inequality.
+
+As you may see, the Lorenz curve is not able to produce a 'quantitative' measure of income inequality, making the scenario above hard for us to compare the 2 countries. For this, we turn to the Gini coefficient.
+
+## The Gini Coefficient
+
+We can use the Gini coefficeint to quantify the level of income inequality.
+
+!<img src="Gini.png"  />
+
+The **Gini coefficient** is the ratio of the area between the line of equality and the Lorenz curve to the total area under the line of equality. Referring to $A$ and $B$ from {numref}`gini-coefficient`:
+
+$$\text{Gini} = \frac{\text{Area between line of equality and Lorenz curve}}{\text{Area under line of equality}} = \frac{A}{A+B}$$
+
+If we express the Lorenz curve as $L(x)$, we can use calculus to derive an equation for the Gini coefficient:
+
+$$\text{Gini} = \frac{\frac{1}{2} - \int_0^1 L(x)\text{d}x}{\frac{1}{2}} = 1 - 2\int_0^1 L(x)\text{d}x$$
+```
+
+Intuitively, the closer the Lorenz curve is to the line of equality, the lower income inequality exists. Hence, the smaller the area of A, the lower the inequality. **This means that the smaller the Gini coefficient, the lower the income inequality.** Also note that the Gini coefficient will always be between 0 and 1. Mathematically, since $A$ and $B$ are both positive, $0<\frac{A}{A+B}<1$.
+
+```python
+# This function estimates the Gini coefficient. You don't have to understand how this code works below.
+def gini(distribution):
+    sorted_distribution = sorted(distribution)
+    height = 0
+    area = 0
+    for i in sorted_distribution:
+        height += i
+        area += height - i / 2
+    fair_area = height * len(distribution) / 2.
+    return (fair_area - area) / fair_area
+```
+
+When we use our population as the parameter to the `gini` function, we get:
+
+```python
+gini_coefficient_country1 = gini(Country1)
+gini_coefficient_country1
+```
+
+```python
+gini_coefficient_country2 = gini(Country2)
+gini_coefficient_country2
+```
+
+```python
+gini_coefficient_country3 = gini(Country3)
+gini_coefficient_country3
+```
+
+These results confirm our intuition from the analysis we did previously via Lorenz curves. Previously, we concluded that country 1 had a higher level of income inequality than country 2, and this is supported by country 1's higher gini coefficient. On the other hand, we had trouble comparing levels of inequality between country 1 and country 3. Here, the gini coefficient would indicate that country 1 has a higher level of income inequality than country 3.
+
+# Income Inequality Historically
+
+<!-- Written by Amal Bhatnagar -->
+
+In the last chart on the previous page, you may have noticed that income inequality was rising in the United States in the last few decades. We will examine this in more detail, and also observe global trends in inequality.
+
+## The United States
+
+Let's look at historical trends of income inequality in the US over the last 100 years. The data has been collected from [The World Inequality Database](https://wid.world/), which is co-directed by Berkeley Economics professors Emanuel Saez and Gabriel Zucman. Specifically, we will observe income distributions for the bottom 50 percent, top 10 percent, and top 1 percent.
+
+```python
+us_hist = Table.read_table("US_inequality.csv")
+us_hist.show(5)
+```
+
+```python
+us_hist.take(np.arange(100,105))
+```
+
+Let's begin with some data cleaning: it seems like our 3 brackets are 'vertically stacked' on top of each other. Instead, we would like a table with 5 columns: `Year`, `bottom 50% income share`, `top 10% income share`, and `top 1% income share`.
+
+```python
+bottom_50_us = us_hist.where("Percentile", "p0p50").drop("Percentile").relabeled("Income Share", "Bottom 50% Share")
+top_10_us = us_hist.where("Percentile", "p90p100").drop("Percentile").relabeled("Income Share", "Top 10% Share")
+top_1_us = us_hist.where("Percentile", "p99p100").drop("Percentile").relabeled("Income Share", "Top 1% Share")
+us_hist_joined = bottom_50_us.join("Year", top_10_us).join("Year", top_1_us)
+us_hist_joined
+```
+
+Oh no, there are some `nan` values! NaN (not a number) values are very common in real world datasets: often, we may not have some observations simply because no data was collected, or perhaps the data collected was faulty. Sometimes, we can try to impute or replace NaN values in order to avoid having gaps in our data, but for now let's ignore NaNs and when plotting to see what's going on:
+
+```python
+# mpl.rcParams['figure.dpi'] = 120
+us_hist_joined.plot("Year", width=11, height=7)
+plt.title("Income Share over Time", fontsize = 16)
+plt.ylabel("Proportion", fontsize = 14)
+plt.xlabel("Year", fontsize = 14)
+plt.show()
+```
+
+# Income Inequality for the Rest of the World
+
+Now let's examine the trends of income inequality in other parts of the world.
+
+```python
+world_hist = Table.read_table("World_Inequality.csv")
+bottom_50_world = world_hist.where("Percentile", "p0p50").drop("Percentile")
+top_10_world = world_hist.where("Percentile", "p90p100").drop("Percentile")
+top_1_world = world_hist.where("Percentile", "p99p100").drop("Percentile")
+top_10_world
+```
+
+```python
+top_10_world.plot("Year", width=11, height=7)
+plt.ylabel("Gini Coefficient", fontsize=14)
+plt.xlabel("Year", fontsize=14)
+plt.title("Income Inequality over Time", fontsize=18);
+```
+
+Just like the US, it seems global inequality has been rising around the world, especially in China, India, Russia, and across Europe. However, in absolute terms, the level of income inequality in Europe is much lower than that in the United States. 
+
+Also look at Russia: income inequality spiked up around 1991. This was likely caused by the fall of the USSR: the failing Soviet state left the ownership of state assets uncontested, which allowed former USSR officials to acquire state property through informal deals. This led to the rise of many Russian oligarchs - those who rapidly accumulated wealth during the era of Russian privatization directly follwing the dissolution of the Soviet Union.
+
+```python
+top_10_world.select("Year", "USA", "Europe").plot("Year", width=11, height=7)
+plt.ylabel("Gini Coefficient", fontsize=14)
+plt.xlabel("Year", fontsize=14)
+plt.title("Income Inequality over Time", fontsize=18);
+```
+
+```python
+
+```
+
+```python
+
+```
+