• Implement an iterative Scala 3 program 
  that computes the factorial of a number
  

• def factorial(n: Int) : Int = 
    var result = 1
    for i <- 1 to n do
      result *= i    
    result
  

• How do we use factorial?
• Is the code correct?
• How can we convince ourselves whether code is correct?

def factorial(n: Int) : Int = 
  var result = 1
  for i <- 1 to n do
    result *= i    
  result

class FactorialTests 
  extends AnyFlatSpec with should.Matchers:
  "Factorial" should "compute 0! correctly" in {
    factorial(0) should be (1)
  }
  it should "compute 1! correctly" in {
    factorial(1) should be (1)
  }
  it should "compute 3! correctly" in {
    factorial(3) should be (6)
  }

Specification

• Hoare triples: {P} C {Q}
• Modal logic: P -> [C]Q

• Code:

  def C() = {
    require (P)
    // ...
  } ensuring (Q)
  

Verification

• Theorem proving shows correctness mathematically for all possible inputs and all possible executions
• Model checking shows correctness for finite-length executions
• Runtime verification checks contracts while executing the software and throws exceptions when violated

def factorial(n: Int) : Int = {
  require (n>=0)
  var result = 1
  for i <- 1 to n do
    result *= i    
  result
} ensuring {
  (result: Int) => 
    result == factorialContract(n)
}

• Useful?

  def factorialContract(n: Int) : Int =
    var result = 1
    for i <- 1 to n do result *= i
    result
  

• Alternative solution!

  def factorialContract(n: Int) : Int = 
    if n<=1 then 1
    else n * factorialContract(n-1)