Now that you have finished these two tasks, you have a working resolution algorithm and you can use the unsatisfiable function to test the satisfiability of your formulas.However, often we would like to use the resolution technique to prove not just the satisfiability or unsatisfiability of a single propositional formula, but logical consequence relationships between two propositional formulas.Your final task for this section of the worksheet is to implement an additional function inside Main.hs to do just that. This function should be pretty simple, and should make use of the existing unsatisfiable function. For this to work, you'll need to copy over your solutions from the previous problems once again.Write a function entails which takes two Formulas f and g and returns True if and only if formula g is a logical consequence of f (in which case, we would say that f entails g). Don't forget a type signature!For example:Main> entails [[Pos 'Q', Neg 'P'], [Pos 'P']] [[Pos 'Q']]TrueMain> entails [[Pos 'Q', Neg 'P']] [[Pos 'P', Neg 'Q']]False

To implement the entails function, you can follow these steps:

1. Define the function entails that takes two formulas f and g as input and returns True if and only if formula g is a logical consequence of f.

entails :: Formula -> Formula -> Bool
entails f g = undefined

2. To check if g is a logical consequence of f, you can use the unsatisfiable function on the formula f and the negation of g. If the result is True, then g is a logical consequence of f.

entails f g = unsatisfiable (f ++ map negateFormula g)

Here, negateFormula is a function that negates a formula (e.g., it returns Neg 'A' for Pos 'A' and vice versa).

Here's the complete code:

import Data.List

type Literal = Char
type Clause = [Literal]
type Formula = [Clause]

complementaryLiteral :: Literal -> Literal
complementaryLiteral lit = if lit == 'Pos' then 'Neg' else 'Pos'

negateFormula :: Clause -> Clause
negateFormula = map complementaryLiteral

unsatisfiable :: Formula -> Bool
unsatisfiable f = not (null latest)
  where
    f' = reduce (remove_tautologies (map reduce f))
    (older, latest) = until finished evolve ([], f')
    finished (old, young) = null young || [] `elem` young

entails :: Formula -> Formula -> Bool
entails f g = unsatisfiable (f ++ map negateFormula g)

You can now use the entails function to check if a formula g is a logical consequence of another formula f.