3.2k
views9
comments

functional lang. newbie needs help writing code for a DSEL (financial contracts)

Hi All,
I've decided that I am finally going to learn functional programming. I started by trying to implement the ideas from the following paper:
"How to write a financial contract" ([link:research.microsoft.com]

Immediately I ran into an embarrassing problem...I'm not sure how to even start modeling the primitives described in the paper. Should the primitives be a set of independent functions, or should I start with a data-type...and then write a single (long) function to 'value' the contracts?

A very quick summary (for those who haven't read the paper). This paper builds a library for representing financial contracts such as stocks, options, forex, etc. It defines a few 'primitives' such as: zero, one, give, and , or, cond, scale, when, anytime, until, konst, lift, lift2, date, etc. These primitives can be combined to represent various financial instruments mentioned previously. Another part of the paper then gives another set of primitives to allow these contracts to be valued. In other words, once we have defined a stock and an option, we can figure out how much it would cost to purchase them (price of the stock is just looked up n the market, price of the option needs to be calculated). The authors say that this domain specific embedded language is similar to how one might write a compiler for a language (build ast, optimize the tree, generate machine code for different architectures).

Following are the few lines I've written so far:

type 'a Obs =
    |Konst of 'a
    |Lift of ('a->'a) * 'a Obs
    |Lift2 of ('a->'a->'a) * 'a Obs * 'a Obs
    |Date of System.DateTime Obs

type Currency = Currency of string
//type PR a = 

type Contract = 
  | Zero
  | One of Currency
  | Give of Contract
  | And of Contract * Contract
  | Or of Contract * Contract
  | Cond of bool Obs * Contract * Contract
  | Scale of float Obs * Contract
  | When of bool Obs * Contract
  | Anytime of bool Obs * Contract
  | Until of bool Obs * Contract


(*// doesn't work
let rec Valueate currency contract = match contract with
    |  Zero ->
*)

(*//obviously doesn't work
let rec valuate contract = match contract with
  | Zero -> 0
  | One -> Currency 1
  | Give c -> (-1) * valuate c
  | And (c1, c2) -> 0
  | Or (c1, c2) -> 0
  | Cond (b, c1, c2) -> 0
  | Scale (c1, c2) -> 0
  | When (c1, c2) -> 0
  | Anytime (c1, c2) -> 0
  | Until (c1, c2) -> 0
  *)
  
let x = Currency "USD"
let c1 = Give Zero

Thanks Don,
I read some parts of the paper again, it turns out, on page 7 they mention that 'Observables' are very similar to "Fran's behaviours" from "Functional reactive animation" by Elliot and Hudak (1997). That paper didn't have what I wanted, but another paper, "Functional Reactive programming from First Principles" by Wan and Hudak (2000) has the following definition on page four:

type Behavior a = [Time] -> ['a'] //without quotes, this forum inserts a smiley if i don't put in the quotes

so I wrote the following in F# (after consulting #ocaml on irc):

type 'a obs = date list -> 'a list  //definition of Observable

Following is my code now (there are several syntax errors, and I haven't touched the function to actually value these instruments, but here goes):
----------------

// How to write a financial contract (Peyton Jones and Eber)
// Shahbaz Chaudhary
// Mon Aug 07, 2006

//Mon Aug 9, 2006: changed the observable definition after advice from Don Syme
// and "Functional Reactive programming from First Principles" by Wan and Hudak (2000)
//blah blah
    
type date = System.DateTime
type currency = string //This should perhaps be an enumertion of all currency codes rather than a raw string


//Contract definition
type Contract = 
  | Zero
  | One of currency
  | Give of Contract
  | And of Contract * Contract
  | Or of Contract * Contract
  | Cond of bool obs * Contract * Contract
  | Scale of float obs * Contract
  | When of bool obs * Contract
  | Anytime of bool obs * Contract
  | Until of bool obs * Contract


//Observable definition
type 'a obs = date list -> 'a list

//Observable primitives
let konst a = a obs 
let lift f o = f o //how does it know that 'o' is an observable? type it explicitly?
let lift2 f o1 o2 = f o1 o2 //same type problem
let date = date obs 


//Random Variable
type 'a rv = 'a list //is this right? random variable is a list of possible value of type 'a?
//Value Process
type 'a pr = date-> 'a rv

//Process primitives
let k x = fun dt -> x  //for any date value, 'x' is returned...how does it know that 'fun dt ...' is actually a value process ('a pr)?
let processdate = date pr //?
let cond b pr1 pr2 = if b then pr1 else pr2 //type
//for lift and lift2 of process, use the same functions as observable primitives?
let (+) pr1 pr2 = pr1 + pr2 //*, /, >, <, =, ...

  
let x = "USD" //how does it know that "USD" is actually of type currency? type it explicitly?
let c1 = Give Zero

By falcon on 8/9/2006 7:48 PM (permalink)

If any one is still following this thread, I cleaned up the existing code a little. I've been trying to get through some Fran and FRP papers to understand this stuff better. The book "Haskell School of Expression" has a good chapter on reactive animation, it was fairly helpful. The lift functions for 'process' are not getting typed correctly. The code follows:
------------------------------------

type date =Date of System.DateTime
type currency = string //This should perhaps be an enumertion of all currency codes rather than a raw string

//Observable definition
type 'a obs = Obs of (date -> 'a)

//Contract definition
type Contract = 
  | Zero
  | One of currency
  | Give of Contract
  | And of Contract * Contract
  | Or of Contract * Contract
  | Cond of bool obs * Contract * Contract
  | Scale of float obs * Contract
  | When of bool obs * Contract
  | Anytime of bool obs * Contract
  | Until of bool obs * Contract


//Observable primitives
let konst a = Obs (fun t -> a)
let lift1 f (Obs o) = Obs (fun t-> f (o t))
let lift2 f (Obs o1) (Obs o2) =Obs (fun t-> f (o1 t) (o2 t)) 
let date =Obs (fun t-> t) 


//Random Variable
type 'a rv =RV of 'a list //is this right? random variable is a list of possible value of type 'a?
//Value Process
type 'a pr =PR of (date-> 'a rv)

//Process primitives
let k x = PR (fun t -> RV [x]) 
let procdate = PR (fun t ->RV [t])
let proclift1 (f:'a->'b) (PR a) = PR (fun t-> f (a t)) ///from this point on the code doesn't seem to work, 'f' wants to operate on 'a rv instead of primitives values
let proclift2 f (PR a) (PR b) = PR (fun t-> f (a t) (b t))
let proclift3 f (PR a) (PR b) (PR c) = PR (fun t-> f (a t) (b t) (c t))
let procif b a c = if(b) then a else c
//let procif2 = proclift3 procif
let a =k 1
let b = a 1
let c = List.map (fun x -> x+1) a

let x = "USD" //how does it know that "USD" is actually of type currency? type it explicitly?
let c1 = Give Zero

By falcon on 8/18/2006 3:14 PM (permalink)

Hi,

For what it's worth, an (extended?) OCaml port of the said paper was developped, see [link:www.lexifi.com]

[link:www.lexifi.com] is the most comprehensive file from the resources of the site ( [link:www.lexifi.com] ) although there are some other presentations.

Hopefully it can give you some ideas.

By Julien on 8/10/2006 3:34 AM (permalink)

Julien,
Thanks for the link. The material on their site is mostly marketing, that is to say nothing technical (and since I am using the "Contracts" paper as a learning excercise, I need a lot more detail :) ).

By the way, if it isn't already obvious, lexifi doesn't need to worry about competition from the few lines of code I post here :)

By falcon on 8/18/2006 3:40 PM (permalink)

Hi guys,

Normally, I would have hopped in on this one, but things have been a bit crazy. Let me take another look at this thread. I agree with Don, i.e. there is a good topic here and F# works based on this topic would provide a great example for others.

I can't promise time to contribute code right at the moment, but I will at least offer a few ideas.

I've seen a few opinions on these ideas and the corresponding research and haven't had time to become informed.

---O

By optionsScalper on 8/18/2006 4:15 PM (permalink)

Hi all,

here's my 2 pence contribution . I let aside the random variables & Stochastic process for the moment.

 

open System

type date =Date of System.DateTime
type currency = USD
|EUR
|JPY 
|GBP //currency is maybe better with be an enumeration of all currency codes rather than a raw string
//Observable definition
type 'a obs = Obs of (date -> 'a)

//Contract definition (I just added some of the other "combinators" from the contract-icfp.ps working paper)

type Contract = 
| Zero
| One of currency
| Give of Contract
| And of Contract * Contract
| Or of Contract * Contract
| Truncate of date * Contract 
| Then of Contract * Contract 
| Scale of float obs * Contract 
| Get of Contract
| Anytime of Contract 
| Cond of bool obs * Contract * Contract 
| When of bool obs * Contract
| Until of bool obs * Contract

//Observable primitives

let konst a = Obs (fun t -> a)
let lift1 f (Obs o) = Obs (fun t-> f (o t))
let lift2 f (Obs o1) (Obs o2) =Obs (fun t-> f (o1 t) (o2 t)) 
let add_obs = lift2 (+.) ;; //Addition on float Obs
let minus_obs = lift2 (-.)
let mult_obs = lift2 ( *.) 
let div_obs = lift2 ( /.) 
let date = Obs (fun t-> t) 
let TempInParis = Obs(fun t -> 9.7);; // first order approx :-)
let TempInParisinKelvin = add_obs TempInParis (konst 273.);;
let scaleK x c = Scale ((konst x), c)
let zcb t x k = scaleK x (Get(Truncate(t,(One k)))) //Zero Coupon Bond
let perhaps t u = Truncate(t , (Or(u,Zero)))
let european t u = Get(perhaps t u) //European option
let american (t1,t2) u = 
 let opt = Anytime(perhaps t2 u) in 
 Then(Get(Truncate(t1,opt)),opt)

let oneBuck = One USD;;
let hundredBucks = Scale((konst 100.),oneBuck);;
let GiltStrip = zcb (Date(new System.DateTime(2007,5,10))) 100. GBP;;

Regards

Julien

By Julien Laugel on 8/21/2006 2:52 PM (permalink)

Thanks Julien,
I'm glad to see I wasn't wildly off the mark. Following are a few more lines of code starting at the "from this point on the code doesn't seem to work..." comment:

let proclift1 f (PR a) = PR (fun t-> List.map f (a t)) 
let proclift2 f (PR a) (PR b) = PR (fun t->List.map2 f (a t) (b t))
let proclift3 f (PR a) (PR b) (PR c) = PR (fun t->map3 f (a t) (b t) (c t))
let procif b a c = if (b) then a else c  //won't this evaluate both 'a' AND 'c' due to eager evaluation???
let procif2 b a c = proclift3 procif b a c 

//Additional process primitives (dependent on valuation model)
let exch currencyTo currencyFrom = currencyTo * currencyFrom //garbage for now

By falcon on 8/21/2006 6:33 PM (permalink)

A few thoughts : shouldn't an observable be more general : a constant observable doesn't depend on time :

let (f : Observable<DateTime -> int>) = fun time -> time.DayOfWeek

seems a bit more logical than having to define your constant as

let (foo : Observable<int>) = (fun _ : DateTime)-> 12345

An idea from the lexifi presentation I mentioned is the use of the Either combinator :

1
2
3

type Contract = 
 | ...
 | Either of list<Contract> (* of which Or is an abbreviation *)

The American option definition (from the icfp paper) is odd. Aside from the date of acquisition, there are no two dates in an american option definition. Unless they were thinking of the acquisition date, but then : why not in the European case? Not sure to get their idea here... An American option is an option that you can exercise anytime between the acquisition date and the expiration date. So the first definition of the paper : Anytime (perhaps expDate payoff) ought to be right....

In his paper, Eber mentions Acquire : bool observable -> Contract -> Contract as a function that returns a contract as soon as the bool observable is true. It seems like a good idea. Rather than using get(truncate t1 c), you'd have acquire (t=t1) c, or something in this vein... More straightforward, and more human-readable.

For the american option (I suppose) you would get :

1
2

let americanOption acqDate expirationDate payoffFunction = 
  acquire {acqDate} (Anytime (perhaps expDate payoff))

As for exchange rates, couldn't we have something like ?

let exchange_rate cur1 cur2 = And (one c1, give (one c2))

julien.

By Julien on 8/22/2006 10:21 AM (permalink)

Hi falcon,

I think it would be excellent to work through a high-quality implementation of this work in F#.

I took a brief look at the paper today and the datatype approach seems the right one for the "Contract" type. I'm not so sure if that's the case for "Observable" - that feels more like it would be best to prototype with that being a concrete type.

In general, wherever Haskell type classes are used you will probably need to pass around dictionaries of operations explicitly (where dictionaries of operations are represented by records of function values), or else make the types concrete. For example, either make "Observable" a concrete type (some representation of the time-varying data whichb allows you to implement Lift, Lift2, Date etc., e.g. time series data). Later you can pass around a dictionary of operations that manipulates abstract Observable values, though in any particular application your representation of observables will probably be fixed.

I'd be glad to take a longer look with you tomorrow - and perhaps Julien and optionsScalper would like to join in ? :-)

don

By dsyme on 8/9/2006 5:12 PM (permalink)

Topic tags

Built with WebSharper

Home

Answers

Events

Courses

Groups and Conferences

Blogs

Jobs

Developers

Topic tags