F#: is it OK for developing theorem provers?

Question

Please advise. I am a lawyer, I work in the field of Law Informatics. I have been a programmer for a long time (Basic, RPG, Fortran, Pascal, Cobol, VB.NET, C#). I am currently i

Answer 1

First, the project you describe sounds (and I believe this is the correct legal term) totally freaking awesome.

Second, while F# is a good choice for math applications, its also extremely well-suited for any applications which perform a lot of symbolic processing. Its worth noting that F# is part of the ML family of languages which were originally designed for the specific purpose of developing theorem provers. It sounds like you're writing an application which appeals directly to the niche ML languages are geared for.

I would personally recommend writing any theorem proving applications you have in F# rather than C# -- only because the resulting F# code will be about 1/10th the size of the C# equivalent. I posted this sample demonstrating how to evaluate propositional logic in C# and F#, you can see the difference for yourself.

Answer 2

F# has many features that make this type of logic processing natural. To get a feel for what the language looks like, here is one possible way to decide which side of an argument has won, and by how much. Uses a random result for the argument, since the interesting (read "very hard to impossible") part will be parsing out the argument text and deciding how persuasive it would be to an actual human.

/// Declare a 'weight' unit-of-measure, so the compiler can do static typechecking
[<Measure>] type weight

/// Type of tokenized argument
type Argument = string

/// Type of argument reduced to side & weight
type ArgumentResult =
    | Pro of float<weight>
    | Con of float<weight>
    | Draw

/// Convert a tokenized argument into a side & weight
/// Presently returns a random side and weight
let ParseArgument =
    let rnd = System.Random()
    let nextArg() = rnd.NextDouble() * 1.0<weight>
    fun (line:string) ->
        // The REALLY interesting code goes here!
        match rnd.Next(0,3) with
        | 1 -> Pro(nextArg())
        | 2 -> Con(nextArg())
        | _ -> Draw

/// Tally the argument scored
let Score args = 
    // Sum up all pro & con scores, and keep track of count for avg calculation
    let totalPro, totalCon, count =
        args
        |> Seq.map ParseArgument
        |> Seq.fold
            (fun (pros, cons, count) arg ->
                match arg with
                | Pro(w) -> (pros+w, cons, count+1)
                | Con(w) -> (pros, cons+w, count+1)
                | Draw   -> (pros, cons,   count+1)
                )
             (0.0<weight>, 0.0<weight>, 0)
    let fcount = float(count)
    let avgPro, avgCon = totalPro/fcount, totalCon/ fcoun
    let diff = avgPro - avgCon
    match diff with
    // consider < 1% a draw
    | d when abs d < 0.01<weight>   -> Draw
    | d when d > 0.0<weight>        -> Pro(d)
    | d                             -> Con(-d)

let testScore = ["yes"; "no"; "yes"; "no"; "no"; "YES!"; "YES!"]
                |> Score
printfn "Test score = %A" testScore

Answer 3

F# does not support logic programming as Prolog does. you might want to check out the P# compiler.

Answer 4

While F# is certainly more suitable than C# for this kind of application since there're going to be several algorithms which F# allows you to express in a very concise and elegant way, you should consider the difference between functional, OO, and logic programming. In fact, porting from F# will most likely require you to use a solver (or implement your own) and that might take you some time to get used to. Otherwise you should consider making a library with your prolog code and access it from .NET (see more about interop at this page and remember that everything you can access from C# you can also access from F#).

Answer 5

Porting from prolog to F# wont be that straight forward. While they are both non-imperative languages. Prolog is a declarative language and f# is functional. I never used C# Prolog libraries but I think it will be easier then converting the whole thing to f#.

Answer 6

It sounds like the functional aspects of F# are appealing to you, but you wonder if it can handle the non-functional aspects. You should know that F# has the entire .NET Framework at its disposal. It also is not a purely functional language; you can write imperative code in it if you want to.

Finally, if there are still things you want to do from C#, it is possible to call F# functions from C#, and vice versa.