my-markdown-library 0.1.0

data/F24Lec_MD/lec05/Lec5-Cobb-Douglas.md

@@ -0,0 +1,131 @@
+---
+title: "Lec5-Cobb-Douglas"
+type: lecture-notebook
+week: 5
+source_path: "/Users/ericvandusen/Documents/Data88E-ForTraining/F24Lec_NBs/lec05/Lec5-Cobb-Douglas.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>, Fall 2024<br>
+            Dr. Eric Van Dusen
+        </p></td></tr>
+</table>
+
+# Cobb-Douglas Regression and Penn World Table
+
+The following code is in Pandas - a more advanced data science library you are not required to know.  
+Just understanding the outputs of the following cells should be good!
+
+```python
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import scipy.stats
+```
+
+```python
+pwt = pd.read_excel('pwt1001.xlsx', sheet_name='Data')
+pwt
+```
+
+```python
+pwt['countrycode'].unique()
+```
+
+```python
+#Graphs of ln(Y/L) vs ln(K/L)
+def graph_cobbs(ccodes, begin_date, end_date):
+    for ccode in ccodes:
+        first = pwt.loc[pwt["countrycode"] == ccode]
+        second = first[ (first['year'] >= begin_date) & (first['year'] <= end_date) ]
+        third = {}
+        third['Y'] = second['cgdpe'] / second['cgdpe'].iloc[0]
+        third['K'] = second['cn'] / second['cn'].iloc[0]
+        third['L'] = second['emp'] / second['emp'].iloc[0]
+        third['YL'] = third['Y'] /third['L']
+        third['KL'] = third['K'] /third['L']
+        third['lnYL'] = np.log(third['YL'])
+        third['lnKL'] = np.log(third['KL'])
+        third = pd.DataFrame(third)
+        third = third.dropna()
+        if(len(third)>0):
+            f = plt.figure()
+            ax = f.add_subplot(111)
+            ax.scatter(third['lnKL'], third['lnYL'], label='')
+            m, b, r_value, p_value, std_err = scipy.stats.linregress(third['lnKL'], third['lnYL'])
+            ax.plot(third['lnKL'], m*third['lnKL'] + b, label='y = %.4f x + %.4f \n$R^2$ = %.4f' %(m, b, r_value**2))
+            ax.legend()
+            ax.set_xlabel('ln(K/L)')
+            ax.set_ylabel('ln(Y/L)')
+            plt.grid()
+            ax.set_title(second['country'].iloc[0] + ' (' + ccode + '): '+ str(begin_date) + ' to '+ str(end_date))
+            ax.text(0.0, 0.0, "Data Source: Penn World Tables", color='blue', fontstyle='italic', transform=f.transFigure)
+         #   plt.savefig('Cobb-Douglas-' + ccode + '.png')
+            plt.show()
+```
+
+```python
+ccodes =['NER','SDN', 'IND', 'CHN', 'NOR', 'USA']
+graph_cobbs(ccodes, 1994, 2017)
+```
+
+The coefficient of $x$ represents the relative impact of capital ($K$) on GDP ($Y$). Here is a brief refresher on $\alpha$ and the log form of the Cobb Douglas equation (seen above):
+$$\ln{\frac{Y}{L}} = \alpha \ln{\frac{K}{L}} + A$$
+$$e^{\ln{\frac{Y}{L}}} = e^{\alpha \ln{\frac{K}{L}} + A}$$
+$$\frac{Y}{L} =  (\frac{K}{L})^{\alpha} * e^{A}$$
+$$ Y = A K^{\alpha} L^{1 - \alpha}$$
+
+```python
+graph_cobbs(['RUS'], 1994, 2017)
+graph_cobbs(['RUS'], 2003, 2017)
+```
+
+```python
+#Graphs of Y and K vs time
+begin_date = 1994
+end_date = 2017
+ccodes = pwt.countrycode.unique().tolist()
+ccodes =['ZWE', 'RUS', 'CHN', 'VEN']
+for ccode in ccodes:
+    first = pwt.loc[pwt["countrycode"] == ccode]
+    second = first[ (first['year'] >= begin_date) & (first['year'] <= end_date) ]
+    third = {}
+    third['year'] = second['year']
+    third['Y'] = second['cgdpe'] / second['cgdpe'].iloc[0]
+    third['K'] = second['cn'] / second['cn'].iloc[0]
+    third['L'] = second['emp'] / second['emp'].iloc[0]
+    third['YL'] = third['Y'] /third['L']
+    third['KL'] = third['K'] /third['L']
+    third['lnYL'] = np.log(third['YL'])
+    third['lnKL'] = np.log(third['KL'])
+    third = pd.DataFrame(third)
+    third = third.dropna()
+    if(len(third)>0):
+        f = plt.figure(figsize=(10,6))
+        ax = f.add_subplot(111)
+        ax.scatter(third['year'], third['Y'], label='')
+        m_y, b_y, r_value_y, p_value_y, std_err_y = scipy.stats.linregress(third['year'], third['Y'])
+        ax.plot(third['year'], m_y*third['year'] + b_y, label='Y = %.4f x + %.4f \n$R^2$ = %.4f' %(m_y, b_y, r_value_y**2))
+        ax.scatter(third['year'], third['K'], label='')
+        m_k, b_k, r_value_k, p_value_k, std_err_k = scipy.stats.linregress(third['year'], third['K'])
+        ax.plot(third['year'], m_k*third['year'] + b_k, label='K = %.4f x + %.4f \n$R^2$ = %.4f' %(m_k, b_k, r_value_k**2))
+        ax.scatter(third['year'], third['L'], label='')
+        m_l, b_l, r_value_l, p_value_l, std_err_l = scipy.stats.linregress(third['year'], third['L'])
+        ax.plot(third['year'], m_l*third['year'] + b_l, label='L = %.4f x + %.4f \n$R^2$ = %.4f' %(m_l, b_l, r_value_l**2))
+        ax.legend()
+        ax.set_xlabel('Year')
+        ax.set_ylabel('Y/K')
+        plt.grid()
+        ax.set_title(second['country'].iloc[0] + ' (' + ccode + '): '+ str(begin_date) + ' to '+ str(end_date))
+        ax.text(0.0, 0.0, "Data Source: Penn World Tables", color='blue', fontstyle='italic', transform=f.transFigure)
+       # plt.savefig('Cobb-Douglas-' + ccode + '.png')
+        plt.show()
+```
+
+```python
+
+```
+

data/F24Lec_MD/lec05/Lec5-CobbD-AER1928.md

@@ -0,0 +1,283 @@
+---
+title: "Lec5-CobbD-AER1928"
+type: lecture-notebook
+week: 5
+source_path: "/Users/ericvandusen/Documents/Data88E-ForTraining/F24Lec_NBs/lec05/Lec5-CobbD-AER1928.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>, Fall 2024<br>
+            Dr. Eric Van Dusen <br>
+        </p></td></tr>
+</table>
+
+## Recreating Key Parts of the Cobb-Douglas Seminal Journal Article from 1928
+
+This Jupyter Notebook aims to recreate and analyze key parts of the seminal journal article "A Theory of Production" by Charles W. Cobb and Paul H. Douglas, published in the American Economic Review in 1928. The article introduced the Cobb-Douglas production function, which has become a fundamental concept in economics.
+
+### Overview
+
+The Cobb-Douglas production function is a mathematical representation of the relationship between inputs (capital and labor) and output in the production process. The function is typically expressed as:
+$$
+Y = A \cdot K^\alpha \cdot L^\beta
+$$
+
+Where:
+
+- \( Y \) is the total production (output),
+- \( A \) is the total factor productivity,
+- \( K \) is the capital input,
+- \( L \) is the labor input,
+- \( $\alpha$\) and \( $\beta$ \) are the output elasticities of capital and labor, respectively.
+- In the simplified CD formulation \( $\alpha$\) + \( $\beta$ \) = 1
+
+### Data and Analysis
+
+**Dataset was manually compiled from the original article and is available in a csv file . The dataset contains historical data on labor, capital, and output for the United States from 1909 to 1929.**
+
+
+In this notebook, we will:
+1. Load and explore the historical data used by Cobb and Douglas.
+2. Visualize the data to understand the trends in labor, capital, and output over time.
+3. Estimate the parameters \( $\alpha$ \) and \( $A$ \) of the Cobb-Douglas production function using regression techniques.
+4. Compare the predicted output values with the actual values to assess the model's accuracy.
+5. Visualize the differences between the actual and predicted values.
+
+
+### Steps
+
+1. **Data Loading and Exploration**: We start by loading the historical data from a CSV file and exploring its structure.
+2. **Data Visualization**: We create various plots to visualize the trends in labor, capital, and output over the years, seeking to make a plot that is reminiscent of the hand-drawn figure in the original article.
+3. **Parameter Estimation**: Using regression techniques, we estimate the parameters \( \alpha \) and \( A \) of the Cobb-Douglas production function.
+4. **Model Comparison**: We compare the predicted output values with the actual values and visualize the differences.
+
+By following these steps, we aim to gain a deeper understanding of the Cobb-Douglas production function and its application to historical economic data.
+
+**Please take a look at the original article for a more detailed explanation of the theory and methodology.**
+From the 1928 Journal Article
+https://www.jstor.org/stable/1811556
+
+
+A Theory of Production
+Charles W. Cobb, Paul H. Douglas
+The American Economic Review, Vol. 18, No. 1, Supplement, Papers and Proceedings of the Fortieth Annual Meeting of the American Economic Association (Mar., 1928), pp. 139-165 (27 pages)
+
+```python
+from datascience import *
+import numpy as np
+import matplotlib.pyplot as plt
+import matplotlib.ticker as mticker
+
+import pandas as pd
+%matplotlib inline
+```
+
+## Cobb Douglas graph of US Economic Output 1899-1922
+
+![image.png](attachment:image.png)
+
+```python
+cobbd = Table.read_table('Cobb.csv')
+cobbd
+```
+
+Step 1 - A simple plot over time using the datascience commands
+
+```python
+cobbd.select('Year', 'EmplIndex', 'CapitalIndex', 'PhProdIndex').plot('Year')
+```
+
+Step 2- Making the Y-Axis a log-scale
+
+```python
+cobbd.select('Year', 'EmplIndex', 'CapitalIndex', 'PhProdIndex').plot('Year')
+
+plt.yscale('log')
+
+plt.show()
+```
+
+Step 3 - Changing properties for th  Y-Axis
+
+```python
+cobbd.select('Year', 'EmplIndex', 'CapitalIndex', 'PhProdIndex').plot('Year')
+
+
+plt.yscale('log')
+
+plt.gca().set_yticks([100, 200, 300, 400, 500])  # Set specific y-tick values
+plt.gca().get_yaxis().set_major_formatter(mticker.ScalarFormatter())  # Format as scalar
+
+plt.show()
+```
+
+Step 4 - *Try to make the plot look like the original !*
+- Change the properties of the lines
+- add Gridlines
+- Title and Legend
+
+```python
+cobbd.select('Year', 'EmplIndex', 'CapitalIndex', 'PhProdIndex').plot('Year')
+
+plt.yscale('log')
+
+# Customize line styles
+empl_line, = plt.plot(cobbd.column('Year'), cobbd.column('EmplIndex'), label='Labor Index', color='black', marker='o', markerfacecolor='white', linewidth=2)
+capital_line, = plt.plot(cobbd.column('Year'), cobbd.column('CapitalIndex'), label='Capital Index', color='black', marker='o', linewidth=2)
+phprod_line, = plt.plot(cobbd.column('Year'), cobbd.column('PhProdIndex'), label='Physical Product Index', color='black', linewidth=2)
+
+plt.gca().set_yticks([75, 100, 200, 300, 400, 500])
+plt.gca().get_yaxis().set_major_formatter(mticker.ScalarFormatter())
+
+# Add gridlines in black and white
+plt.grid(True, which='both', linestyle='-', linewidth=0.5, color='gray')
+
+# Customize title and labels
+plt.title("PROGRESS IN MANUFACTURING \n 1899-1922  (1899=100)", fontsize=16)
+plt.xlabel("Year", fontsize=14)
+
+plt.legend([empl_line, capital_line, phprod_line], 
+           ['LABOR FORCE', 'FIXED CAPITAL', 'PHYSICAL PRODUCT'],  # Legend labels
+           loc='upper center',  # Move to center
+           frameon=True)  # Optional: removes the legend box frame
+
+plt.show()
+```
+
+##  Part 2 - Estimate Alpha and A
+### Adding Columns for Ratios
+
+1. **Add a Column for the Ratio of Capital to Labor:**
+    - Use the variable names from the `cobbd` table.
+    - Take the natural logarithms of the ratios
+    - Add this as a new column to the `cobbd` table.
+
+2. **Add a Column for the Ratio of Output to Labor:**
+    - Use the variable names from the `cobbd` table.
+    - Take the natural logarithms of the ratios
+    - Add this as a new column to the `cobbd` table.
+
+```python
+
+cobbd = cobbd.with_column("ln(K/L)", np.log(cobbd.column("CapitalIndex")/cobbd.column("EmplIndex")))
+
+cobbd = cobbd.with_column("ln(Y/L)", np.log(cobbd.column("PhProdIndex")/cobbd.column("EmplIndex")))
+cobbd
+```
+
+### Estimating the Coefficients of the Cobb-Douglas Production Function
+
+To estimate the coefficients of the Cobb-Douglas production function, we will use the `np.polyfit` function from the NumPy library. This function will help us perform a linear regression on the logarithmic ratios of capital to labor (\( \ln(K/L) \)) and output to labor (\( \ln(Y/L) \)).
+
+The `log_ratios` table contains the necessary data for this estimation. By fitting a linear model to these logarithmic ratios, we can derive the coefficients \( \alpha \) and \( A \) of the Cobb-Douglas production function.
+
+The steps involved are as follows:
+1. Use `np.polyfit` to perform a linear regression on the `log_ratios` table.
+2. Extract the coefficients from the regression output.
+3. Interpret these coefficients in the context of the Cobb-Douglas production function.
+
+This approach allows us to quantify the relationship between capital, labor, and output in the production process, providing valuable insights into the underlying economic dynamics.
+
+```python
+CDestimates = np.polyfit(cobbd.column("ln(K/L)"), cobbd.column("ln(Y/L)"), 1)
+```
+
+```python
+alpha = CDestimates.item(0)
+beta = 1-alpha
+A = np.exp(CDestimates.item(1))
+```
+
+```python
+print("alpha: ", alpha)
+print("beta: ", beta)
+print("A: ", A)
+```
+
+### Regression Analysis Using Statsmodels
+
+In addition to using NumPy's `polyfit` function, we can also perform the regression analysis using the `statsmodels` library. This allows us to regress $ \ln(Y/L) $ on $\ln(K/L)$ and obtain detailed statistical information about the regression model.
+
+The steps involved are as follows:
+1. Use `statsmodels` to perform an Ordinary Least Squares (OLS) regression.
+2. Compare the results with those obtained using `np.polyfit`.
+
+This approach is beyond the scope of Data 8 but would be familiar to those who have taken an econometrics class
+
+```python
+import statsmodels.api as sm
+
+sm.OLS(cobbd.column("ln(Y/L)"), sm.add_constant(cobbd.column("ln(K/L)"))).fit().summary()
+```
+
+```python
+# get the coefficients for alpha from the statsmodels output
+model = sm.OLS(cobbd.column("ln(Y/L)"), sm.add_constant(cobbd.column("ln(K/L)"))).fit()
+alpha2 = model.params[1]
+A2= np.exp(model.params[0])
+print("alpha2: ", alpha2)
+print("A2: ", A2)
+```
+
+What have we learned?
+ - Np.polyfit returns the same output as statsmodels
+ - Cobb-Douglas got the right result before computers had been invented
+
+Now lets set this up to make  predictions for Y  and add that column to our table 
+$$
+A \cdot K^{\alpha} \cdot L^{1 - \alpha}
+$$
+
+or 
+$$
+1.01 \cdot K^{0.25} \cdot L^{0.75}
+$$
+
+or 
+$$
+1.01 \cdot K^{\frac{1}{4}} \cdot L^{\frac{1}{4}}
+$$
+
+```python
+
+cobbd = cobbd.with_column("PredictedY", A*cobbd.column("CapitalIndex")**alpha*cobbd.column("EmplIndex")**(1-alpha))
+cobbd
+```
+
+```python
+# now we need a line plot the actual values of Y vs year and a pplot of predicted Y vs year 
+cobbd.select('Year', 'PhProdIndex', 'PredictedY').plot('Year')
+```
+
+```python
+# Let's add the difference between the actual and predicted values of Y to the cobbd table
+cobbd = cobbd.with_column("Difference", cobbd.column("PredictedY") - cobbd.column("PhProdIndex") )
+# lets add the percentage difference to the table which is actual - predicted / actual * 100
+cobbd = cobbd.with_column("Percent Difference", cobbd.column("Difference")/cobbd.column("PhProdIndex")*100)
+cobbd.show(24)
+```
+
+And if we plot this we can compare it to 'Chart IV' in the original paper ( page 155)
+
+```python
+cobbd.select('Year', 'Difference').plot('Year')
+```
+
+```python
+cobbd.select('Year', 'Difference').plot('Year')
+
+# Add gridlines in black and white
+plt.grid(True, which='both', linestyle='-', linewidth=0.5, color='gray')
+
+# Customize title and labels
+plt.title("Percentage Deviations \n  of Computed from Actual Product\n  1899-1922", fontsize=16)
+plt.xlabel("Year", fontsize=14)
+```
+
+Not quite matching the graph in the article?
+
+
+

data/F24Lec_MD/lec06/6.1-Sympy-Differentiation.md

@@ -0,0 +1,253 @@
+---
+title: "6.1-Sympy-Differentiation"
+type: lecture-notebook
+week: 6
+source_path: "/Users/ericvandusen/Documents/Data88E-ForTraining/F24Lec_NBs/lec06/6.1-Sympy-Differentiation.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>, Fall 2024<br>
+            Dr. Eric Van Dusen
+        </p></td></tr>
+</table>
+
+# Using Sympy to take Derivatives
+
+```python
+import sympy as sp
+import numpy as np
+import matplotlib.pyplot as plt
+```
+
+## Let's start with the Cobb - Douglas Production Function
+
+$Q = A  \cdot L^{\alpha} \cdot K^\beta$
+
+$\frac{dQ}{dL} = A \cdot \alpha \cdot L^{\alpha - 1} \cdot K^\beta$
+
+$\frac{d^2Q}{dL^2} = A \cdot \alpha (\alpha - 1) \cdot L^{\alpha - 2} \cdot K^\beta$
+
+Define the symbols and variables
+ - which symbols will we need for the Cobb Douglas formulation?
+ - Declare them as symbols
+
+```python
+Q, A, L, K, alpha, beta = sp.symbols('Q A L K alpha beta')
+```
+
+Define the Cobb-Douglas production function
+ - writing this equation in its Python formulation
+ - using the symbols we have already defined
+
+```python
+cobb_douglas = A * L**alpha * K**beta
+```
+
+Calculate the **first derivative** with respect to **L**
+
+- This is a *partial derivative*
+
+- sympy.diff ( original equation, thing you are taking the derivative over ) 
+
+- Save that as an equation for future use!
+
+```python
+first_derivative = sp.diff(cobb_douglas, L)
+```
+
+Print this result
+ - you can just ask sympy to print - spprint ()
+ - you can add some text "First Derivative is.."
+
+```python
+print("First Derivative:")
+sp.pprint(first_derivative)
+```
+
+This doesnt Look so great 
+- lets pass in our function and get sympy to simplify it
+- what form you want an equaiton to be in can take many forms
+
+```python
+simplified_first_derivative = sp.simplify(first_derivative)
+print(simplified_first_derivative)
+```
+
+Print Result - Variation
+- you can also save as Latex !
+- It won't render yet - but you can copy paste this into Markdown cell
+
+```python
+first_derivative_latex = sp.latex(first_derivative)
+print("First Derivative (LaTeX):")
+print(first_derivative_latex)
+```
+
+$\frac{A K^{\beta} L^{\alpha} \alpha}{L}$
+
+Calculate the **second derivative** with respect to **L**
+ - use the first derivative that you saved
+ - take the derivatie again with respect to variable of interes, L
+ - save that equation
+
+```python
+second_derivative = sp.diff(first_derivative, L)
+```
+
+```python
+sp.pprint(second_derivative)
+```
+
+```python
+second_derivative_latex = sp.latex(second_derivative)
+print(second_derivative_latex)
+```
+
+Pasting this into a Markdown cell and adding "dollar signs"
+
+$\frac{A K^{\beta} L^{\alpha} \alpha^{2}}{L^{2}} - \frac{A K^{\beta} L^{\alpha} \alpha}{L^{2}}$
+
+First Derivative (LaTeX):
+$\frac{A K^{\beta} L^{\alpha} \alpha}{L}$
+
+Second Derivative (LaTeX):
+$\frac{A K^{\beta} L^{\alpha} \alpha^{2}}{L^{2}} - \frac{A K^{\beta} L^{\alpha} \alpha}{L^{2}}$
+
+Lets simplify both of these and generat the Latex
+
+```python
+first_div_simp_latex = sp.latex(sp.simplify(first_derivative))
+print(first_div_simp_latex)
+```
+
+```python
+second_div_simp_latex = sp.latex(sp.simplify(sp.diff(first_derivative, L)))
+print(second_div_simp_latex)
+```
+
+$$A K^{\beta} L^{\alpha - 1} \alpha$$
+$$A K^{\beta} L^{\alpha - 2} \alpha \left(\alpha - 1\right)$$
+
+## Now 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
+U, X1, X2, alpha = sp.symbols('U, X1, X2, alpha ')
+```
+
+```python
+U =  X1**alpha * X2**(1-alpha)
+```
+
+```python
+first_deriv_x1 = sp.diff(U,X1)
+```
+
+```python
+second_deriv_x1 = sp.diff(first_deriv_x1, X1)
+```
+
+```python
+sp.pprint(first_deriv_x1)
+```
+
+```python
+sp.pprint(second_deriv_x1)
+```
+
+```python
+sp.simplify(first_deriv_x1)
+```
+
+```python
+sp.simplify( second_deriv_x1)
+```
+
+```python
+first_deriv_x1_latex = sp.latex(sp.simplify(first_deriv_x1))
+print(first_deriv_x1_latex)
+second_deriv_x1_latex = sp.latex(sp.simplify(second_deriv_x1))
+print(second_deriv_x1_latex)
+```
+
+First Derivative (LaTeX):
+$X_{1}^{\alpha - 1} X_{2}^{1 - \alpha} \alpha$
+
+Second Derivative (LaTeX):
+$X_{1}^{\alpha - 2} X_{2}^{1 - \alpha} \alpha \left(\alpha - 1\right)
+$
+
+Lets get Numeric!
+- Lets declare some variables as constants ( alpha, x2) 
+- and pass in a range for X1
+
+```python
+alpha = 0.5  # You can change the value of alpha as needed
+X1_values = np.linspace(0.1, 2.0, 100)  # Range of X1 values
+X2 = 1.0  # Fixed value for X2
+```
+
+```python
+X1_values
+```
+
+```python
+U_values = X1_values**alpha * X2**(1 - alpha)
+U_values
+```
+
+```python
+first_derivative_values = alpha * X1_values**(alpha - 1) * X2**(1 - alpha)
+first_derivative_values
+```
+
+```python
+second_derivative_values = alpha * (alpha - 1) * X1_values**(alpha - 2) * X2**(1 - alpha)
+second_derivative_values
+```
+
+```python
+plt.figure(figsize=(8, 6))
+plt.plot(X1_values, U_values, label='U')
+plt.plot(X1_values, first_derivative_values, label='First Derivative')
+plt.plot(X1_values, second_derivative_values, label='Second Derivative')
+plt.xlabel('X1')
+plt.ylabel('First Derivative')
+plt.title('First Derivative and Second Derivative of U')
+plt.legend()
+plt.grid(True)
+plt.show()
+```
+
+```python
+
+
+# Create a figure with two subplots (one for U and one for the first derivative)
+fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 6))
+
+# Plot the original function U on the left subplot
+ax1.plot(X1_values, U_values, label='U')
+ax1.set_xlabel('X1')
+ax1.set_ylabel('U')
+ax1.set_title('Utility Function ')
+
+# Plot the first derivative on the right subplot
+ax2.plot(X1_values, first_derivative_values, label='First Derivative', color='orange')
+ax2.set_xlabel('X1')
+ax2.set_ylabel('First Derivative')
+ax2.set_title('First Derivative')
+
+# Show the plot
+plt.show()
+```
+
+```python
+
+```
+