Simulation of LLV (2012)

Calculation of \( \lambda \) and \( \Pi_{\delta} \).

From LLV (2012), we have that cost of capital is calculated as
\[ \left({\frac{(N r_I \Pi_I)}{1+r_I \Pi_I \lambda} +w \Pi_U}\right)^{-1}, \]
where \( \lambda \) is calculated as the solution to equation (A5) of LLV (2012):

eq_A5 <- function(lambda, N, rI, w, sig_v, sig_e, sig_z) {

    rI^3 * w * sig_z * (sig_v + sig_e)^3 * lambda^4 + rI^2 * sig_v * sig_z * 
        (sig_v + sig_e)^2 * (rI * (sig_v + sig_e) * (N - 2) + 3 * w * sig_e) * 
        lambda^3 + rI * sig_v^2 * (sig_v + sig_e) * ((3 * sig_z * sig_e^2 + 
        N^2 * rI^2 * (sig_v + sig_e)) * w + rI * sig_z * sig_e * (sig_v + sig_e) * 
        (2 * N - 5)) * lambda^2 + sig_v^3 * sig_e * ((N^2 * rI^2 * (sig_v + 
        sig_e) + sig_z * sig_e^2) * w + rI * (sig_v + sig_e) * (sig_z * sig_e * 
        (N - 4) + N^2 * rI^2 * (N - 2))) * lambda - sig_v^4 * sig_e^2 * (sig_z * 
        sig_e + N^2 * rI^2)
}

and \( \Pi_U = \Pi_v + \Pi_{\delta} \), where equation (A6) gives
\[ \Pi_{\delta} = \frac{N^2 r_I^2 \sigma_v^4}{(r_I^2 \sigma^2_z (\sigma^2_v + \sigma_{\epsilon})^2 \lambda^2 + 2 r_I \sigma^2_v \sigma^2_{\epsilon} \sigma^2_z (\sigma^2_v + \sigma^2_{\epsilon}) \lambda + \sigma_v^4 \sigma^2_{\epsilon} (N^2 r_I^2 + \sigma^2_{\epsilon} \sigma^2_z))}. \]

Note that I have simplified the expression for the cost of capital by cancelling out the \( N r_I + \omega \) term that cancels out from both components of Equation 18 (see here for evidence that this doesn't affect the calculations).

Cost of capital

CoC <- function(w, sig_e, sig_z, sig_v, rI, N) {

    # First, find the root for Equation (A5) to solve for \lambda
    sol <- uniroot(eq_A5, c(0, 1), N = N, rI = rI, w = w, sig_v = sig_v, sig_e = sig_e, 
        sig_z = sig_z)
    lambda <- sol$root
    lambda <- 1

    # Calculate precisions. First, for informed investor ...
    Pi_v <- 1/sig_v
    Pi_e <- 1/sig_e
    Pi_i <- Pi_v + Pi_e

    # Then, using Equation (A.6), solve for precision of uninformed investor.
    Pi_d <- (N^2 * rI^2 * sig_v^2)/(rI^2 * sig_z * (sig_v + sig_e)^2 * lambda^2 + 
        2 * rI * sig_v * sig_e * sig_z * (sig_v + sig_e) * lambda + sig_v^2 * 
        sig_e * (N^2 * rI^2 + sig_e * sig_z))
    Pi_u <- Pi_v + Pi_d

    # Eq. (18)
    CoC <- (((1 + rI * Pi_i * lambda)^-1 * (N * rI * Pi_i) + w * Pi_u))^-1

    # Return cost of capital
    return(CoC)
}

Some surface plots

The 2nd step is to do two plots. First, do a plot with \( \sigma_{\epsilon}^2 \) on the \( x \)-axis, \( \omega \) on the \( y \)-axis, and the cost of capital on the \( z \)-axis.

library(lattice)
sig_e <- seq(from = 0.2, to = 1.2, by = 0.05)
w <- seq(from = 0.2, to = 1, by = 0.02)
N <- 5
rI <- 0.5
sig_z <- 1
sig_v <- 1

avg_precision <- function(sig_v, sig_z, N, rI, w, sig_e, Pi_avg = 0) {
    Pi_v <- 1/sig_v
    Pi_e <- 1/sig_e
    Pi_i <- Pi_v + Pi_e

    sol <- uniroot(eq_A5, c(0, 1), N = N, rI = rI, w = w, sig_v = sig_v, sig_e = sig_e, 
        sig_z = sig_z)

    lambda <- sol$root

    Pi_d <- (N^2 * rI^2 * sig_v^2)/(rI^2 * sig_z * (sig_v + sig_e)^2 * lambda^2 + 
        2 * rI * sig_v * sig_e * sig_z * (sig_v + sig_e) * lambda + sig_v^2 * 
        sig_e * (N^2 * rI^2 + sig_e * sig_z))
    Pi_u <- Pi_v + Pi_d

    (N * rI * Pi_i + w * Pi_u)/(N * rI + w) - Pi_avg
}

Pi_avg <- avg_precision(sig_v, sig_z, N, rI, min(w), min(sig_e))
cat("Pi_avg=", Pi_avg)

## Pi_avg= 5.981

params <- merge(w, sig_e)
names(params) <- c("w", "sig_e")

solve_sig_v <- function(w, sig_e, N, rI, sig_z, Pi_avg = Pi_avg) {
    # print(c( N, rI, w, sig_v, sig_e, Pi_avg))
    sol <- uniroot(avg_precision, c(0.1, 100), N = N, rI = rI, w = w, sig_z = sig_z, 
        sig_e = sig_e, Pi_avg = Pi_avg)
    sig_v <- sol$root
    return(sig_v)
}

library(parallel)
params$sig_v <- mcmapply(solve_sig_v, w = params$w, sig_e = params$sig_e, 
    N = N, rI = rI, sig_z = sig_z, Pi_avg = Pi_avg)

output1 <- data.frame(params, coc = mcmapply(CoC, w = params$w, sig_e = params$sig_e, 
    N = N, rI = rI, sig_z = sig_v, sig_v = params$sig_v))
wireframe(coc ~ sig_e * w, data = output1, zlab = "CoC", ylab = expression(omega), 
    xlab = expression(sigma[epsilon]^2))

Then do a plot with \( \sigma_v^2 \) on the \( x \)-axis, \( \omega \) on the \( y \)-axis, and the cost of capital on
the \( z \)-axis.

w <- sig_v <- seq(from = 0.2, to = 1.2, by = 0.05)
N <- 5
rI <- 0.5
sig_z <- 1
avg_precision_e <- function(sig_e, sig_v, sig_z, N, rI, w, Pi_avg = 0) {
    avg_precision(sig_v, sig_z, N, rI, w, sig_e, Pi_avg)
}
# avg_precision <- function(sig_v, sig_z, N, rI, w, sig_e, Pi_avg=0)
Pi_avg <- avg_precision(min(sig_v), sig_z, N, rI, min(w), sig_e = 1)

cat("Pi_avg=", Pi_avg)

## Pi_avg= 5.985

params <- merge(w, sig_v)
names(params) <- c("w", "sig_v")

solve_sig_e <- function(w, sig_v, N, rI, sig_z, Pi_avg = Pi_avg) {
    sol <- uniroot(avg_precision, c(0.1, 100), N = N, rI = rI, w = w, sig_z = sig_z, 
        sig_v = sig_v, Pi_avg = Pi_avg)
    sig_e <- sol$root
    return(sig_e)
}

params$sig_e <- mcmapply(solve_sig_e, w = params$w, sig_v = params$sig_v, 
    N = N, rI = rI, sig_z = sig_z, Pi_avg = Pi_avg)
output2 <- data.frame(params, coc = mcmapply(CoC, w = params$w, sig_v = params$sig_v, 
    N = 5, rI = 0.5, sig_z = 1, sig_e = params$sig_e))

wireframe(coc ~ sig_v * w, data = output2, zlab = "CoC", ylab = expression(omega), 
    xlab = expression(sigma[v]^2))