A New Capital Regulation For Large Financial Institutions

We design a new, implementable capital requirement for large financial institutions (LFIs) that are too big to fail. Our mechanism mimics the operation of margin accounts. To ensure that LFIs do not default on either their deposits or their derivative contracts, we require that they maintain an equity cushion sufficiently great that their own credit default swap price stays below a threshold level, and a cushion of long term bonds sufficiently large that, even if the equity is wiped out, the systemically relevant obligations are safe. If the CDS price goes above the threshold, the LFI regulator forces the LFI to issue equity until the CDS price moves back down. If this does not happen within a predetermined period of time, the regulator intervenes. We show that this mechanism ensures that LFIs are always solvent, while preserving some of the disciplinary effects of debt.Banks, Capital Requirement, Too Big to Fail

Acute: high-level programming language design for distributed computation

Existing languages provide good support for typeful programming of standalone programs. In a distributed system, however, there may be interaction between multiple instances of many distinct programs, sharing some (but not necessarily all) of their module structure, and with some instances rebuilt with new versions of certain modules as time goes on. In this paper we discuss programming language support for such systems, focussing on their typing and naming issues. We describe an experimental language, Acute, which extends an ML core to support distributed development, deployment, and execution, allowing type-safe interaction between separately-built programs. The main features are: (1) type-safe marshalling of arbitrary values; (2) type names that are generated (freshly and by hashing) to ensure that type equality tests suffice to protect the invariants of abstract types, across the entire distributed system; (3) expression-level names generated to ensure that name equality tests suffice for type-safety of associated values, e.g. values carried on named channels; (4) controlled dynamic rebinding of marshalled values to local resources; and (5) thunkification of threads and mutexes to support computation mobility. These features are a large part of what is needed for typeful distributed programming. They are a relatively lightweight extension of ML, should be efficiently implementable, and are expressive enough to enable a wide variety of distributed infrastructure layers to be written as simple library code above the byte-string network and persistent store APIs. This disentangles the language runtime from communication intricacies. This paper highlights the main design choices in Acute. It is supported by a full language definition (of typing, compilation, and operational semantics), by a prototype implementation, and by example distribution libraries

Illiquidity and all its Friends

The recent crisis was characterized by massive illiquidity. This paper reviews what we know and don't know about illiquidity and all its friends: market freezes, fire sales, contagion, and ultimately insolvencies and bailouts. It first explains why liquidity cannot easily be apprehended through a single statistics, and asks whether liquidity should be regulated given that a capital adequacy requirement is already in place. The paper then analyzes market breakdowns due to either adverse selection or shortages of financial muscle, and explains why such breakdowns are endogenous to balance sheet choices and to information acquisition. It then looks at what economics can contribute to the debate on systemic risk and its containment. Finally, the paper takes a macroeconomic perspective, discusses shortages of aggregate liquidity and analyses how market value accounting and capital adequacy should react to asset prices. It concludes with a topical form of liquidity provision, monetary bailouts and recapitalizations, and analyses optimal combinations thereof; it stresses the need for macro-prudential policies.Liquidity, Contagion, Bailouts, Regulation

Open-end real estate funds : danger or diamond?

Both banks and open end real estate funds effectuate liquidity transformation in large amounts and high scales. Because of this similarity the latter should be analyzed using the same methodologies as usually applied for banks. We show that the work in the tradition of Diamond and Dybvig (1983), especially Allen and Gale (1998) and Diamond and Rajan (2001), provides an applicable theoretical framework. We used this as the basis for our model for open end real estate funds. We then examined the usefulness of the modeling structure in analyzing open end real estate funds. First, we could show that withdrawing of capital resulting in a run is not always inefficient. Instead, withdrawing can as well be referred to the situation where the low return of an open end fund unit in comparison to other opportunities makes, (partial) withdrawal viewed from the risk-sharing perspective optimal. Even with costly liquidation, this result will hold, though we will have deadweight losses in such a situation. Second, introducing a secondary market in our model does, not in general, resolve the problem of deadweight losses associated with foreclosure. If assets are sold during a run, we do not only have a transfer of value but it can also create an economic cost. Because funds are forced to liquidate the illiquid asset in order to fulfill their obligations, the price of the real estate asset is forced down making the crisis worse. Rather than providing insurance, such that investors receive a transfer in negative outcomes, the secondary market does the opposite. It provides a negative insurance instead. Third, our model proves that the open end structure provides a monitoring function which serves as an efficient instrument to discipline the funds management. Therefore, we argue that an open end structure can represent a more adequate solution to securitize real estate or other illiquid assets. Instead of transforming open end in closed end structures, fund runs should be accepted as a normal phenomenon to clear the market from funds with mismanagement

Financial Innovation and Financial Fragility

We present a standard model of financial innovation, in which intermediaries engineer securities with cash flows that investors seek, but modify two assumptions. First, investors (and possibly intermediaries) neglect certain unlikely risks. Second, investors demand securities with safe cash flows. Financial intermediaries cater to these preferences and beliefs by engineering securities perceived to be safe but exposed to neglected risks. Because the risks are neglected, security issuance is excessive. As investors eventually recognize these risks, they fly back to safety of traditional securities and markets become fragile, even without leverage, precisely because the volume of new claims is excessive. Financial innovation can make both investors and intermediaries worse off. The model mimics several facts from recent historical experiences, and points to new avenues for financial reform.Financial Innovation, Financial Fragility, Securities, Risks