Expanding recursive case of function in equational reasoning - liquid-haskell

Question

Context: I am proving some properties about a Haskell quicksort implementation. The following code is all that is required to define a nondeterministic permute function. Note that I am using LList rather than Haskell's base [] type. The problem area is the permute_LCons_expansion_correct theorem (it's not much of a theorem).
-- Data. A list is either `LNil` or constructed with a `vhead` element and a
-- `vtail` list.
data LList a = LNil | LCons {vhead :: a, vtail :: LList a}
-- Function. Append two lists.
{-# reflect lappend #-}
lappend :: LList a -> LList a -> LList a
lappend LNil ys = ys
lappend (LCons x xs) ys = LCons x (lappend xs ys)
-- Function. Construct a list with 1 element.
{-# reflect llist1 #-}
llist1 :: a -> LList a
llist1 x = LCons x LNil
-- Function. Construct a list with 2 elements.
{-# reflect llist2 #-}
llist2 :: a -> a -> LList a
llist2 x y = llist1 x `lappend` llist1 y
-- Function. Map a list-function over a list and concatenate the resulting
-- lists (i.e. list-monadic bind).
{-# reflect lbind #-}
lbind :: LList a -> (a -> LList b) -> LList b
lbind LNil f = LNil
lbind (LCons x xs) f = f x `lappend` lbind xs f
-- Function. Map a function over a list.
{-# reflect lmap #-}
lmap :: (a -> b) -> (LList a -> LList b)
lmap f LNil = LNil
lmap f (LCons x xs) = LCons (f x) (lmap f xs)
{-# reflect lmap2 #-}
-- Function. Map a binary function over two lists (zipping).
lmap2 :: (a -> b -> c) -> LList a -> LList b -> LList c
lmap2 f xs ys = lbind xs (\x -> lbind ys (\y -> llist1 (f x y)))
-- Function. Nondeterministically split a list into two sublists.
{-# reflect split #-}
split :: LList a -> LList (LList a, LList a)
split LNil = llist1 (LNil, LNil)
split (LCons x xs) =
split xs
`lbind` \(ys, zs) ->
llist1 (LCons x ys, zs) `lappend` llist1 (ys, LCons x zs)
-- Function. Nondeterministically permute a list.
{-# reflect permute #-}
permute :: LList a -> LList (LList a)
permute LNil = llist1 LNil
permute (LCons x xs) =
split xs `lbind` \(ys, zs) ->
lmap2
(\ys' zs' -> ys' `lappend` llist1 x `lappend` zs')
(permute ys)
(permute zs)
-- Function. The expanded form of `permute` on an `LCons`.
{-# reflect permute_LCons_expansion #-}
permute_LCons_expansion :: a -> LList a -> LList (LList a)
permute_LCons_expansion x xs =
split xs
`lbind` ( \(ys, zs) ->
lmap2
(\ys' zs' -> ys' `lappend` llist1 x `lappend` zs')
(permute ys)
(permute zs)
)
-- Theorem. `permute_LCons_expansion` corresponds to `permute` on an `LCons`.
{-#
permute_LCons_expansion_correct :: x:a -> xs:LList a ->
{permute (LCons x xs) = permute_LCons_expansion x xs}
#-}
permute_LCons_expansion_correct :: a -> LList a -> Proof
permute_LCons_expansion_correct x xs =
permute (LCons x xs)
==. split xs
`lbind` ( \(ys, zs) ->
lmap2
(\ys' zs' -> ys' `lappend` llist1 x `lappend` zs')
(permute ys)
(permute zs)
)
==. permute_LCons_expansion x xs
*** QED
In permute_LCons_expansion_correct, the equations should be correct because the middle expression is just the body of the LCons case of permute which is also the definition of permute_LCons_expansion. However, when I compile, I get this LH error:
❯ cabal build
Build profile: -w ghc-8.10.3 -O1
{{I have removed project files info}}
**** LIQUID: UNSAFE ************************************************************
src/Test.hs:83:9: error:
Liquid Type Mismatch
.
The inferred type
VV : (Test.LList (Test.LList a))
.
is not a subtype of the required type
VV : {VV : (Test.LList (Test.LList a)) | permute (LCons x xs) == VV}
.
in the context
xs : (Test.LList a)
x : a
|
83 | ==. split xs
| ^^^^^^^^...
Why doesn't LH recognize the implicit equality? Note that I am using (==.) from Language.Haskell.Equational rather than Language.Haskell.ProofCombinators.
Configuration:
ghc version 8.10.3
LiquidHaskell Version 0.8.6.0
cabal version 3.2.0.0