Real Assets

Multiple real assets are available in the economy that can be used for different purposes. A real asset might be a chicken egg or a complex machine to produce other real assets. At this point it is not yet relevant who, for example, produces the real assets or who owns them.

Agents

Agents can be thought of as individual human beings being active in the economy. They might be involved in producing real assets, consuming them or trading them. They accept money during transactions and spend it during others. An agent might also be an institution like a bank that allows other agents to deposit money on which it then pays interest.

Time

Economic activity, like trading real assets, takes place at discrete points in time only. Formally, it holds for a point in time $t\in 0,1,2,3,...$ or $t\in {\mathbb{N}}_0$. In the following, only the two points in time $t=0$ and $t=1$ are relevant. They should be best interpreted as today and one year from today, although it is not necessarily the only interpretation of the relevant time interval. In many contexts, one can also think of today and tomorrow. In any case, financial theory speaks of a static economy if only two points in time are relevant.

The Python data type to model the natural numbers $\mathbb{N}$ is int which stands for integers.² Typical arithmetic operations are possible on integers like addition, subtraction, multiplication and more.

In [1]: 1 + 3  
Out[1]: 4

In [2]: 3 * 4  
Out[2]: 12

In [3]: t = 0  

In [4]: t  
Out[4]: 0

In [5]: t = 1  

In [6]: type(t)  
Out[6]: int

Adds up two integer values.

Multiplies two integer values.

Assigns a value of 0 to the variable name t.

Prints out the value of variable t.

Assigns a new value of 1 to t.

Looks up and prints the Python type of t.

Money

In the economy, there is money (or currency) in unlimited supply available. Money is also infinitely divisible. Money and currency should be thought of in abstract terms only and not in terms of cash (physical coins or bills).

Money in general serves as the numeraire in the economy in that the value of one unit of money (think USD, EUR, GBP, etc.) is normalized to exactly 1. The prices for all other goods are then expressed in such units and are fractions or multiples of such units. Formally, units of the currency are represented as (positive) real numbers $c\in {ℝ}_{\ge 0}$.

In Python, float is the standard data type used to represent real numbers $ℝ$. It stands for floating point numbers. Like the int type, it allows, among others, for typical arithmetic operations, like addition and subtraction.

In [7]: 1 + 0.5   
Out[7]: 1.5

In [8]: 10.5 - 2  
Out[8]: 8.5

In [9]: c = 2 + 0.75  

In [10]: c  
Out[10]: 2.75

In [11]: type(c)  
Out[11]: float

Adding two numbers.

Subtracting two numbers.

Assigning the result of the addition to the variable name c.

Printing the value of the variable c.

Looking up and printing out the Python type of the variable c.

Beyond serving as a numeraire, money also allows to buy and sell real assets or to store value over time. These two functions rest on the trust that money has indeed intrinsic value today and also in one year. In general, this translates into trust in people and institutions being willing to accept money both today and later for any kind of transaction. The numeraire function is independent of this trust since it is a numerical operation only.

Return

Consider an investment project with cash flows $c=(c_0,c_1)=(-10,12)$. The return $R\in ℝ$ of the project is the sum of the cash flows $R=c_0+c_1=-10+12=2$. The rate of return $r\in ℝ$ is the return $R$ divided by $\left|c_0\right|$, that is by the absolute value of the investment outlay today:

In Python, this boils down to simple arithmetic operations.

In [26]: c = (-10, 12)  

In [27]: R = sum(c)  

In [28]: R  
Out[28]: 2

In [29]: r = R / abs(c[0])  

In [30]: r  
Out[30]: 0.2

Defines the cash flow pair as tuple object.

Calculates the return R by taking the sum of all elements of c and …

… prints out the result.

Calculates the rate of return r with abs(x) giving the absolute value of x and …

… prints out the result.

Interest

There is a difference between a cash flow today and a cash flow in one year. The difference results from interest that is being earned on currency units or that has to be paid to borrow currency units. Interest in this context is the price being paid for having control over money that belongs to another agent.

An agent that has currency units that they do not need today can deposit these with a bank or lend them to another agent to earn interest. If the agent needs more currency units than they have currently available, they can borrow them from a bank or other agents and needs to pay interest.

Suppose an agent deposits $c_0=-10$ currency units today with a bank. According to the deposit contract, they receive $c_1=11$ currency units after one year from the bank. The interest $I\in ℝ$ being paid on the deposit is $I=c_0+c_1=-10+11=1$. The interest rate $i\in ℝ$ accordingly is $i=\frac{I}{\left|c_0\right|}=0.1$.

In the following, it is assumed that the relevant interest rate for both lending and borrowing is the same and that it is fixed for the entire economy.

Present Value

Having lending or depositing options available leads to opportunity costs for deploying money in an investment project. A cash flow of, say, $c_1=12.1$ in one year cannot be compared directly in terms of value with a cash flow of $c_0=12.1$ today since interest can be earned on currency units not deployed in a project.

To appropriately compare cash flows in one year with those of today, the present value needs to be calculated. This is accomplished by discounting using the fixed interest rate in the economy. Discounting can be modeled as a function $D:ℝ\to ℝ,c_1\mapsto D\left(c_1\right)$ which maps a real number (cash flow in one year) to another real number (cash flow today). It holds

for an interest rate of $i=0.1$. This relationship results from the alternative “investment” in deposits with a bank

Python functions are well suited to represent mathematical functions like the one for discounting.

In [31]: i = 0.1  

In [32]: def D(c1):  
             return c1 / (1 + i)  

In [33]: D(12.1)  
Out[33]: 10.999999999999998

In [34]: D(11)  
Out[34]: 10.0

Fixes the interest rate i.

Function definition with def statement; D is the function name; c1 the parameter name.

Returns the present value with the return statement.

Calculates the present value of 12.1; note the rounding error due to internal float point number representation issues.

Calculates the present value of 11 (“exactly” in this case).

Net Present Value

How shall an agent decide whether to conduct an investment project or not? One criterion is the net present value. The net present value $NPV\in ℝ$ is the sum of the cash outflow today and the present value of the cash inflow in one year, $NPV\left(c\right)=c_0+D\left(c_1\right)$. Here, the net present value calculation is a function $NPV:{ℝ}^2\to ℝ$ mapping cash flow tuple to a real number. If the net present value is positive, the project should be conducted; if it is negative, then not --since the alternative of just depositing the money with a bank is more attractive.

Consider an investment project with cash flows $c^A=(-10.5,12.1)$. The net present value is $NPV\left(c^A\right)=-10.5+D(12.1)=-10.5+11=0.5$. The project should be conducted. Consider an alternative investment project with $c^B=(-10.5,11)$. This one has a negative net present value and should not be conducted: $NPV\left(c^B\right)=-10.5+D\left(11\right)=-10.5+10=-0.5$.

Building on previous definitions, a respective Python function is easily defined.

In [35]: def NPV(c):
             return c[0] + D(c[1])

In [36]: cA = (-10.5, 12.1)  

In [37]: cB = (-10.5, 11)  

In [38]: NPV(cA)  
Out[38]: 0.4999999999999982

In [39]: NPV(cB)  
Out[39]: -0.5

Positive net present value project.

Negative net present value project.

Probability Measure

The probabilities for events that are physically possible together form a probability measure. Such a probability measure is a function $P:\wp \left(\{u,d\}\right)\to {ℝ}_{\ge 0}$ mapping all elements of the power set of $\{u,d\}$ — with $\wp \left(\right\{u,d\left\}\right)=\{\varnothing ,\{u\},\{d\},\{u,d\left\}\right\}$ — to the positive real line. The power set in this case embodies all events that are physically possible. In this context, the set $\{u,d\}$ is also called the state space and is symbolized by $\Omega$. The triple $(\Omega ,\wp (\Omega ),P)$ together is called a probability space.

A function $P$ representing a probability measure needs to satisfy three conditions:

1. $P\left(\varnothing \right)=0$

2. $0\le P\left(\omega \right),\omega \in \Omega \le 1$

3. $P\left(\Omega \right)=P\left(u\right)+P\left(d\right)=1$

The first condition implies that at least one of the states must materialize. The second implies that the probability for a state to materialize is between 0 and 1. The third one says that all the probabilities add up to 1.

In the simple model economy with two states only, it is convenient to define $p\equiv P\left(u\right)$ and to accordingly have $P\left(d\right)=1-p$, given the third condition from above. Fixing $p$ then defines the probability measure $P$.

Having a fully specified probability measure available, the model economy is typically called an economy under risk. A model economy without a fully specified probability measure is often called an economy under ambiguity.

In applications, a probability measure is usually modeled also as a vector and ndarray object, respectively. This is at least possible for a discrete state space with a finite number of elements.

In [56]: p = 0.4

In [57]: 1 - p
Out[57]: 0.6

In [58]: P = np.array((p, 1-p))

In [59]: P
Out[59]: array([0.4, 0.6])

Expectation

Based on the probability measure, the expectation of an uncertain quantity, like the price in one year of a financial asset, can be calculated. The expectation can be interpreted as the weighted average where the weights are given by the probabilities. It is an average since the probabilities add up to one.

Consider the financial asset with price process $S=\left(S_0,S_1\right)$. The expectation of the uncertain price $S_1$ in one year under the probability measure $P$ is

with $p\equiv P\left(u\right)$. If $S_1={(20,5)}^T$ and $p=0.4$ hold, the expectation value is

Mathematically, the expectation can be expressed as the dot product (or inner product) of two vectors. If $x,y\in {ℝ}^2$, the dot product is defined as

Therefore, with $P={(p,1-p)}^T$ and $S_1={(S_1^u,S_1^d)}^T$ the expectation is

Working with ndarray objects in Python, the dot product is defined as a function provided by the NumPy package.

In [60]: P  
Out[60]: array([0.4, 0.6])

In [61]: S0 = 10  

In [62]: S1 = np.array((20, 5))  

In [63]: np.dot(P, S1)  
Out[63]: 11.0

The previously defined probability measure.

The price of the financial asset today.

The vector of the uncertain price in one year.

The dot product of the two vectors calculating the expectation value.

Expected Return

Under uncertainty, the notions of return and rate of return need to be adjusted. In such a case, the expected return of a financial asset is given as the expectation of the price in one year minus the price today. This can be seen by taking the expectation of the uncertain return $R={(R^u,R^d)}^T$ and rearranging as follows

With the assumptions from before, one gets

The expected rate of return then simply is the expected return divided by the price today

which can be also derived step-by-step with similar transformations as for the expected return. In what follows, the expected rate of return is symbolized by $\mu \equiv {?}^P\left(r\right)$ for brevity.

The calculation of expected return and rate of return can be modeled in Python by two simple functions.

In [64]: def ER(x0, x1):
             return np.dot(P, x1) - x0  

In [65]: ER(S0, S1)  
Out[65]: 1.0

In [66]: def mu(x0, x1):
             return (np.dot(P, x1) - x0) / x0  

In [67]: mu(S0, S1)  
Out[67]: 0.1

Definition of expected return.

The expected return for the previously defined financial asset.

Definition of the expected rate of return.

The expected rate of return calculate for that asset.

Volatility

In finance, risk and expected return is the dominating pair of concepts. Risk can be measured in many ways, while the volatility measured as the standard deviation of the rates of return is probably the most common measure. In the present context, the variance of the return rates of a financial asset is defined by

with $r^{\omega }\equiv (S_1^{\omega }-S_0)/S_0,\omega \in \Omega$. The volatility is defined as the standard deviation of the return rates which is the square root of the variance

Python functions modeling these two risk measures are given below. Also a helper function to calculate the return rates vector.

In [68]: def r(x0, x1):
             return (x1 - x0) / x0  

In [69]: r(S0, S1)  
Out[69]: array([ 1. , -0.5])

In [70]: mu = np.dot(P, r(S0, S1))  

In [71]: mu  
Out[71]: 0.10000000000000003

In [72]: def sigma2(P, r, mu):
             return np.dot(P, (r - mu) ** 2)  

In [73]: sigma2(P, r(S0, S1), mu)  
Out[73]: 0.54

In [74]: def sigma(P, r, mu):
             return np.sqrt(np.dot(P, (r - mu) ** 2))  

In [75]: sigma(P, r(S0, S1), mu)  
Out[75]: 0.7348469228349535

Vectorized calculation of the rates of return vector.

Applies the function to the financial asset from before.

The expected rate of return via the dot product …

… printed out.

The definition of the variance of the rates of return.

The function applied to the rates of return vector.

The definition of the volatility.

And applied to the rates of return vector.

Replication

When introducing a contingent claim into the economy, an important question that arises is whether the payoff of the contingent claim is redundant or not. Mathematically, one speaks of the payoff vector of the contingent claim being linearly dependent or linearly independent.

The payoff of the call option is said to be linearly dependent — or redundant — when a solution to the following problem exists for

with $b,s\in ℝ$.

This problem can be represented as a system of linear equations

With $S_1^u\ne S_1^d$, solutions are given by

and

Assume as before that two financial assets are traded, a risk-less bond $B=(10,11)$ and a risky stock $S=(10,{(20,5)}^T)$. Assume further $K=15$ such that $C_1={(5,0)}^T$. The optimal numerical solutions then are

and

In words, buying one third of the stock and selling $\frac{5}{33}$ of the bond short perfectly replicates the payoff of the call option. Therefore, the payoff of the call option is linearly dependent given the payoff vectors of the bond and the stock.

Technically, short selling implies borrowing the respective number of units of the financial asset today from another agent and immediately selling it in the market. In one year, the borrowing agent buys the exact number of units of the financial asset back in the market to the then current price and transfers them back to the other agent.

The analysis here assumes that all financial assets — like money — are infinitely divisible which might not be the case in practice. It also assumes that short selling of all traded financial assets is possible which might not be too unrealistic given market practice.

As a preparation for the implementation in Python, consider yet another way of formulating the replication problem. To this end, the mathematical concept of a matrix is needed. While a vector is a one-dimensional object, a matrix is a two-dimensional object. For the purposes of this section, consider a square matrix $ℳ$ with four elements — implying $ℳ\in {ℝ}^{2\times 2}$ — with

The future payoff vectors of the bond and the stock represent the values in the first and second column of the matrix, respectively. The first row contains the payoff of both financial assets in the state $u$ while the second row contains the payoffs from the $d$ state. With these conventions, the replication problem can be represented in matrix form as

where $\varphi \in {ℝ}^2$ is the vector containing the bond and stock portfolio positions for replication $\varphi \equiv {(b,s)}^T$. $\varphi$ is usually simply called a portfolio or trading strategy. Therefore

In this context, matrix multiplication is defined by

which shows the equivalence between this way of representing the replication problem and the one from before.

The ndarray class allows for a modeling of matrices in Python. The NumPy package provides in the sub-package np.linalg a wealth of functions for linear algebra operations among which there is also a function to solve systems of linear equations in matrix form — exactly what is needed here.

In [83]: B = (10, np.array((11, 11)))  

In [84]: S = (10, np.array((20, 5)))  

In [85]: M = np.array((B[1], S[1])).T  

In [86]: M  
Out[86]: array([[11, 20],
                [11,  5]])

In [87]: K = 15  

In [88]: C1 = np.maximum(S[1] - K, 0)  

In [89]: C1  
Out[89]: array([5, 0])

In [90]: phi = np.linalg.solve(M, C1)  

In [91]: phi  
Out[91]: array([-0.15151515,  0.33333333])

Defines the price process for the risk-less bond.

Defines the price process for the risky stock.

Defines a matrix — i.e. a two-dimensional ndarray object — with the future payoff vectors.

Shows the matrix with the numerical values.

Fixes the strike price for the call option and …

… calculates the values for the payoff vector in one year.

Shows the numerical values of the payoff vector.

Solves the replication problem in matrix form to obtain the optimal portfolio positions.

Arbitrage Pricing

How much does it cost to replicate the payoff of the call option? Once the portfolio to accomplish the replication is derived, this question is easy to answer. Define the value of the replication portfolio today by $V_0\left(\varphi \right)$. It is given by the dot product

or in numbers

The uncertain value of the replication portfolio in one year $V_1\left(\varphi \right)$ can be represented via matrix multiplication as

Together, one has the value process of the portfolio as $V\left(\varphi \right)=(V_0\left(\varphi \right),V_1\left(\varphi \right))$ or $V=(V_0,V_1)$ for short if there is no ambiguity regarding the portfolio.

Having a portfolio available that perfectly replicates the future payoff of a contingent claim raises the next question: what if the price of the contingent claim today differs from the costs of setting up the replication portfolio? The answer is simple but serious: then there exists an arbitrage or arbitrage opportunity in the economy. An arbitrage is a trading strategy $\varphi$ that creates a risk-less profit out of an investment of zero. Formally, $\varphi$ is an arbitrage if

• $V_0\left(\varphi \right)=0$ and ${?}^P\left(V_1\left(\varphi \right)\right)>0$ or

• $V_0\left(\varphi \right)>0$ and $V_1\left(\varphi \right)=0$

Suppose that the price of the call option is $C_0=2$ which is higher than the cost to set up the replication portfolio. A trading strategy that sells the call option in the market for 2 and buys the replication portfolio for 1.81818 yields an immediate profit of the difference. In one year, the payoff of the replication portfolio and of the call option cancel each other out

by the definition of the replication portfolio. In the other case, when the price of the call option today is lower than the price of the replication portfolio, say $C_0=1.5$ a trading strategy buying the call option and selling the replication portfolio yields a risk-less profit amounting to the difference between the market price of the call option and the cost to set up the replication portfolio. Of course, the risk-less profits in both cases can be increased by simply multiplying the positions by a positive factor greater than one.

A model for an economy which allows for arbitrage opportunities can be considered not viable. Therefore the only price that is consistent with the absence of arbitrage is $C_0=1.818181$. One calls this price the arbitrage price of the call option. Whenever there is a portfolio $\varphi$ replicating the payoff of a contingent claim $V_1\left(\varphi \right)=C_1$, then the arbitrage price of the contingent claim is $C_0=V_0\left(\varphi \right)$.

Formally, the arbitrage price is the dot product of the replication portfolio and the price vector of the replicating financial assets

giving rise to an arbitrage-free price process for the contingent claim of $C=(C_0,C_1)$.

In Python, this is a single calculation given the previous definitions and calculations.

In [92]: C0 = np.dot(phi, (B[0], S[0]))

In [93]: C0
Out[93]: 1.8181818181818183

In [94]: 10/3 - 50/33
Out[94]: 1.8181818181818183

Market Completeness

Does arbitrage pricing work for every contingent claim? Yes, at least for those that are replicable by portfolios of financial assets that are traded in the economy. The set of attainable contingent claims $?$ comprises all those contingent claims that are replicable by trading in the financial assets. It is given by the span which is the set of all linear combinations of the future price vectors of the traded financial assets

if short-selling is prohibited and

if it is allowed in unlimited fashion.

Consider the risk-less bond and the risky stock from before with price processes $B=(B_0,B_1)$ and $S=\left(S_0,{(S_1^u,S_1^d)}^T\right)$, respectively, where $B_1,S_1\in {ℝ}_{\ge 0}^2$ and $S_1^u\ne S_1^d$. It is then easy to show that the replication problem

has a unique solution for any $C_1\in {ℝ}_{\ge 0}^2$. The solution is given by

and consequently as

which was derived in the context of the replication of the special call option payoff. The solution carries over to the general case since no special assumptions have been made regarding the payoff other than $C_1\in {ℝ}_{\ge 0}^2$.

Since every contingent claim can be replicated by a portfolio consisting of a position in the risk-less bond and the risky stock, one speaks of a complete market model. Therefore, every contingent claim can be priced by replication and arbitrage. Formally, the only requirement being that the price vectors of the two financial assets in one year be linearly independent. This implies that

has only the unique solution ${\varphi }^{*}={(0,0)}^T$ and no other solution. In fact, all replication problems for arbitrary contingent claims have unique solutions under market completeness. The payoff vectors of the two traded financial assets span the ${ℝ}^2$ since they form a basis of the vector space ${ℝ}^2$.

The spanning property can be visualized by the use of Python and the matplotlib package. To this end, 1,000 random portfolio compositions are simulated. The first restriction is that the portfolio positions should be positive and add up to 1. Figure 2-2 shows the result.

In [95]: np.random.seed(100)  

In [96]: n = 1000  

In [97]: b = np.random.random(n)  

In [98]: b[:5]  
Out[98]: array([0.54340494, 0.27836939, 0.42451759, 0.84477613, 0.00471886])

In [99]: s = (1 - b)  

In [100]: s[:5]  
Out[100]: array([0.45659506, 0.72163061, 0.57548241, 0.15522387, 0.99528114])

In [101]: def portfolio(b, s):
              A = [b[i] * B[1] + s[i] * S[1] for i in range(n)]  
              return np.array(A)  

In [102]: A = portfolio(b, s)  

In [103]: A[:3]  
Out[103]: array([[15.10935552,  8.26042965],
                 [17.49467553,  6.67021631],
                 [16.17934168,  7.54710554]])

In [104]: plt.figure(figsize=(10, 6))
          plt.plot(A[:, 0], A[:, 1], 'r.');  

Fixes the seed for the random number generator.

Number of values to be simulated.

Simulates the bond position for values between 0 and 1 by the means of a uniform distribution.

Derives the stock position as the difference between 1 and the bond position.

This calculates the portfolio payoff vectors for all random portfolio compositions and collects them in a list object; this Python idiom is called a list comprehension.

The function returns a ndarray version of the results.

The calculation is initiated.

The results are plotted.

Figure 2-2. The random portfolios span a one-dimensional line only

Figure 2-3 shows the graphical results in the case where the portfolio positions do not need to add up to 1.

In [105]: s = np.random.random(n)  

In [106]: b[:5] + s[:5]
Out[106]: array([0.57113722, 0.66060665, 1.3777685 , 1.06697466, 0.30984498])

In [107]: A = portfolio(b, s)  

In [108]: plt.figure(figsize=(10, 6))
          plt.plot(A[:, 0], A[:, 1], 'r.');

The stock position is freely simulated for values between 0 and 1.

The portfolio payoff vectors are calculated.

Figure 2-3. The random portfolios span a two-dimensional area (rhomb)

Finally, Figure 2-4 allows for positive as well as negative portfolio positions for both the bond and the stock. The resulting portfolio payoff vectors cover an (elliptic) area around the origin.

In [109]: b = np.random.standard_normal(n)  

In [110]: s = np.random.standard_normal(n)  

In [111]: b[:5] + s[:5]  
Out[111]: array([-0.66775696,  1.60724747,  2.65416419,  1.20646469,
           -0.12829258])

In [112]: A = portfolio(b, s)

In [113]: plt.figure(figsize=(10, 6))
          plt.plot(A[:, 0], A[:, 1], 'r.');