{-# OPTIONS_HADDOCK show-extensions #-}

-- |
-- Module      :  Phladiprelio.ConstraintsEncoded
-- Copyright   :  (c) OleksandrZhabenko 2020-2023
-- License     :  MIT
-- Stability   :  Experimental
-- Maintainer  :  oleksandr.zhabenko@yahoo.com
--
-- Provides a way to encode the needed constraint with possibly less symbols.
-- Uses arrays instead of vectors.

{-# LANGUAGE FlexibleInstances, FlexibleContexts, NoImplicitPrelude, BangPatterns #-}

module Phladiprelio.ConstraintsEncoded (
  -- * Data types
  EncodedContraints(..)
  , EncodedCnstrs
  -- * Functions to work with them
  -- ** Read functions
 , readMaybeECG
  -- ** Process-encoding functions
  , decodeConstraint1
  , decodeLConstraints
  , isConstraint1
  -- ** Modifiers and getters
  , getIEl
  , setIEl
  -- ** Predicates
  , isE
  , isP
  , isF
  , isQ
  , isT
  , isSA
  , isSB
  , isV
  , isW
  , isH
  , isR
  , isM
  , isN
  , isD
  , isI
  -- * Algebraic general conversion
  , validOrdStr
  , generalConversion
  , filterGeneralConv
) where

import GHC.Base
import GHC.List
import GHC.Num ((+),(-),abs)
import Text.Show (show, Show(..))
import Text.Read (readMaybe, read)
import Data.Maybe
import Data.List (nub, words, groupBy)
import GHC.Arr
import Data.Char (isDigit, isLetter)
import Phladiprelio.Constraints
import Data.SubG (InsertLeft(..), splitAtEndG)
import Data.Tuple (fst)

data EncodedContraints a b c 
  = E  -- ^ Represents no additional constraint, corresponds to the whole set of theoretically possible permutations.
  | P a b  -- ^ Represents the set of permutations with the fixed positions of some elements.
  | Q a a a a a  -- ^ Represents the set of permutations with the preserved pairwise order between first and second, second and third, third and fourth elements.
  | T a a a a   -- ^ Represents the set of permutations with the preserved pairwise order between first and second, second and third elements.
  | SA a a b   -- ^ Represents the set of permutations with the preserved position of the elements AFTER the another selected one.
  | SB a a b -- ^ Represents the set of permutations with the preserved position of the elements BEFORE the another selected one.
  | F a a a  -- ^ Represents the set of permutations with the preserved order between first and second elements.
  | V a a a  -- ^ Represents the set of permutations with the preserved both distance between and order of the two elements.
  | W a a a   -- ^ Represents the set of permutations with the preserved distance between the two elements.
  | H a a a a   -- ^ Represents the set of permutations with the preserved both distances between and order of the three elements.
  | R a a a a   -- ^ Represents the set of permutations with the preserved pairwise distances between the first and second, second and third elements.
  | M a a a a   -- ^ Represents the set of permutations with the preserved pairwise distances between the first and second, second and third elements, and additionally the order of the first and second elements.
  | N a c  -- ^ Represents the set of permutations with the moved fixed positions of some elements (at least one).
  | D a a a a  -- ^ Pepresents the set of permutations with the specified order and distance between the two elements.
  | I a a a a-- ^ Pepresents the set of permutations with the specified distance between the two elements.
  deriving (EncodedContraints a b c -> EncodedContraints a b c -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall a b c.
(Eq a, Eq b, Eq c) =>
EncodedContraints a b c -> EncodedContraints a b c -> Bool
/= :: EncodedContraints a b c -> EncodedContraints a b c -> Bool
$c/= :: forall a b c.
(Eq a, Eq b, Eq c) =>
EncodedContraints a b c -> EncodedContraints a b c -> Bool
== :: EncodedContraints a b c -> EncodedContraints a b c -> Bool
$c== :: forall a b c.
(Eq a, Eq b, Eq c) =>
EncodedContraints a b c -> EncodedContraints a b c -> Bool
Eq, EncodedContraints a b c -> EncodedContraints a b c -> Ordering
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {a} {b} {c}.
(Ord a, Ord b, Ord c) =>
Eq (EncodedContraints a b c)
forall a b c.
(Ord a, Ord b, Ord c) =>
EncodedContraints a b c -> EncodedContraints a b c -> Bool
forall a b c.
(Ord a, Ord b, Ord c) =>
EncodedContraints a b c -> EncodedContraints a b c -> Ordering
forall a b c.
(Ord a, Ord b, Ord c) =>
EncodedContraints a b c
-> EncodedContraints a b c -> EncodedContraints a b c
min :: EncodedContraints a b c
-> EncodedContraints a b c -> EncodedContraints a b c
$cmin :: forall a b c.
(Ord a, Ord b, Ord c) =>
EncodedContraints a b c
-> EncodedContraints a b c -> EncodedContraints a b c
max :: EncodedContraints a b c
-> EncodedContraints a b c -> EncodedContraints a b c
$cmax :: forall a b c.
(Ord a, Ord b, Ord c) =>
EncodedContraints a b c
-> EncodedContraints a b c -> EncodedContraints a b c
>= :: EncodedContraints a b c -> EncodedContraints a b c -> Bool
$c>= :: forall a b c.
(Ord a, Ord b, Ord c) =>
EncodedContraints a b c -> EncodedContraints a b c -> Bool
> :: EncodedContraints a b c -> EncodedContraints a b c -> Bool
$c> :: forall a b c.
(Ord a, Ord b, Ord c) =>
EncodedContraints a b c -> EncodedContraints a b c -> Bool
<= :: EncodedContraints a b c -> EncodedContraints a b c -> Bool
$c<= :: forall a b c.
(Ord a, Ord b, Ord c) =>
EncodedContraints a b c -> EncodedContraints a b c -> Bool
< :: EncodedContraints a b c -> EncodedContraints a b c -> Bool
$c< :: forall a b c.
(Ord a, Ord b, Ord c) =>
EncodedContraints a b c -> EncodedContraints a b c -> Bool
compare :: EncodedContraints a b c -> EncodedContraints a b c -> Ordering
$ccompare :: forall a b c.
(Ord a, Ord b, Ord c) =>
EncodedContraints a b c -> EncodedContraints a b c -> Ordering
Ord, Int -> EncodedContraints a b c -> ShowS
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall a b c.
(Show a, Show b, Show c) =>
Int -> EncodedContraints a b c -> ShowS
forall a b c.
(Show a, Show b, Show c) =>
[EncodedContraints a b c] -> ShowS
forall a b c.
(Show a, Show b, Show c) =>
EncodedContraints a b c -> String
showList :: [EncodedContraints a b c] -> ShowS
$cshowList :: forall a b c.
(Show a, Show b, Show c) =>
[EncodedContraints a b c] -> ShowS
show :: EncodedContraints a b c -> String
$cshow :: forall a b c.
(Show a, Show b, Show c) =>
EncodedContraints a b c -> String
showsPrec :: Int -> EncodedContraints a b c -> ShowS
$cshowsPrec :: forall a b c.
(Show a, Show b, Show c) =>
Int -> EncodedContraints a b c -> ShowS
Show)

validOrdStr0 
  :: String 
  -> Int -- ^ Number of seen so far \'(\' parentheses
  -> Int -- ^ Number of seen so far \')\' parentheses
  -> Bool
validOrdStr0 :: String -> Int -> Int -> Bool
validOrdStr0 xs :: String
xs@(Char
'E':String
ys) Int
n Int
m = String -> Int -> Int -> Bool
validOrdStr0 String
ys Int
n Int
m
validOrdStr0 xs :: String
xs@(Char
' ':Char
y:Char
t:String
ys) Int
n Int
m
  | Char
y forall a. Eq a => a -> [a] -> Bool
`elem` String
"ABDFHIMNPQRTVW" Bool -> Bool -> Bool
&& Char -> Bool
isDigit Char
t = String -> Int -> Int -> Bool
validOrdStr0 (forall a. (a -> Bool) -> [a] -> [a]
dropWhile Char -> Bool
isDigit String
ys) Int
n Int
m
  | Char
y forall a. Eq a => a -> [a] -> Bool
`elem` String
"-(E" = String -> Int -> Int -> Bool
validOrdStr0 (Char
yforall a. a -> [a] -> [a]
:Char
tforall a. a -> [a] -> [a]
:String
ys) Int
n Int
m
  | Bool
otherwise = Bool
False  
validOrdStr0 xs :: String
xs@(Char
'(':Char
y:Char
t:String
ys) Int
n Int
m
  | Char
y forall a. Eq a => a -> [a] -> Bool
`elem` String
"ABDFHIMNPQRTVW" Bool -> Bool -> Bool
&& Char -> Bool
isDigit Char
t = String -> Int -> Int -> Bool
validOrdStr0 (forall a. (a -> Bool) -> [a] -> [a]
dropWhile Char -> Bool
isDigit String
ys) (Int
n forall a. Num a => a -> a -> a
+ Int
1) Int
m
  | Char
y forall a. Eq a => a -> [a] -> Bool
`elem` String
"-(E" = String -> Int -> Int -> Bool
validOrdStr0 (Char
yforall a. a -> [a] -> [a]
:Char
tforall a. a -> [a] -> [a]
:String
ys) (Int
n forall a. Num a => a -> a -> a
+ Int
1) Int
m
  | Bool
otherwise = Bool
False  
validOrdStr0 xs :: String
xs@(Char
')':Char
y:Char
t:String
ys) Int
n Int
m
  | Char
y forall a. Eq a => a -> [a] -> Bool
`elem` String
"ABDFHIMNPQRTVW" Bool -> Bool -> Bool
&& Char -> Bool
isDigit Char
t = String -> Int -> Int -> Bool
validOrdStr0 (forall a. (a -> Bool) -> [a] -> [a]
dropWhile Char -> Bool
isDigit String
ys) Int
n (Int
m forall a. Num a => a -> a -> a
+ Int
1)
  | Char
y forall a. Eq a => a -> [a] -> Bool
`elem` String
"-()E" = String -> Int -> Int -> Bool
validOrdStr0 (Char
yforall a. a -> [a] -> [a]
:Char
tforall a. a -> [a] -> [a]
:String
ys) Int
n (Int
m forall a. Num a => a -> a -> a
+ Int
1)
  | Bool
otherwise = Bool
False  
validOrdStr0 xs :: String
xs@(Char
'-':Char
y:Char
t:String
ys) Int
n Int
m
  | Char
y forall a. Eq a => a -> [a] -> Bool
`elem` String
"ABDFHIMNPQRTVW" Bool -> Bool -> Bool
&& Char -> Bool
isDigit Char
t = String -> Int -> Int -> Bool
validOrdStr0 (forall a. (a -> Bool) -> [a] -> [a]
dropWhile Char -> Bool
isDigit String
ys) Int
n Int
m 
  | Char
y forall a. Eq a => a -> [a] -> Bool
`elem` String
"-)" Bool -> Bool -> Bool
|| Char -> Bool
isDigit Char
y = Bool
False
  | Bool
otherwise = String -> Int -> Int -> Bool
validOrdStr0 (Char
yforall a. a -> [a] -> [a]
:Char
tforall a. a -> [a] -> [a]
:String
ys) Int
n Int
m 
validOrdStr0 xs :: String
xs@(Char
x:Char
y:Char
t:String
ys) Int
n Int
m 
  | Char
x forall a. Eq a => a -> [a] -> Bool
`elem` String
"ABDFHIMNPQRTVW" = if Char -> Bool
isDigit Char
y then String -> Int -> Int -> Bool
validOrdStr0 (forall a. (a -> Bool) -> [a] -> [a]
dropWhile Char -> Bool
isDigit (Char
tforall a. a -> [a] -> [a]
:String
ys)) Int
n Int
m else Bool
False
  | Bool
otherwise = String -> Int -> Int -> Bool
validOrdStr0 (Char
yforall a. a -> [a] -> [a]
:Char
tforall a. a -> [a] -> [a]
:String
ys) Int
n (Int
m forall a. Num a => a -> a -> a
+ Int
1) 
validOrdStr0 xs :: String
xs@(Char
x:Char
')':String
ys) Int
n Int
m 
  | Char -> Bool
isDigit Char
x Bool -> Bool -> Bool
|| Char
x forall a. Eq a => a -> a -> Bool
== Char
')' = String -> Int -> Int -> Bool
validOrdStr0 String
ys Int
n (if Char
x forall a. Eq a => a -> a -> Bool
== Char
')' then Int
m forall a. Num a => a -> a -> a
+ Int
2 else Int
m forall a. Num a => a -> a -> a
+ Int
1) 
  | Bool
otherwise = Bool
False
validOrdStr0 xs :: String
xs@(Char
x:Char
y:String
ys) Int
n Int
m 
  | Char
x forall a. Eq a => a -> [a] -> Bool
`elem` String
"(ABDFHIMNQRTVW" = Bool
False
  | Char
y forall a. Eq a => a -> [a] -> Bool
`elem` String
" -(ABDFHIMNPQRTVW" = Bool
False
  | Char
x forall a. Eq a => a -> a -> Bool
== Char
'P' Bool -> Bool -> Bool
&& Bool -> Bool
not (Char -> Bool
isDigit Char
y) = Bool
False
  | Char
x forall a. Eq a => a -> a -> Bool
== Char
')' Bool -> Bool -> Bool
&& Char
y forall a. Eq a => a -> [a] -> Bool
`notElem` String
")E" = Bool
False
  | Char
x forall a. Eq a => a -> a -> Bool
== Char
'P' Bool -> Bool -> Bool
&& Int
n forall a. Eq a => a -> a -> Bool
== Int
m = Bool
True
  | Char
x forall a. Eq a => a -> a -> Bool
== Char
')' Bool -> Bool -> Bool
&& Char
y forall a. Eq a => a -> a -> Bool
== Char
')' = Int
n forall a. Eq a => a -> a -> Bool
== (Int
m forall a. Num a => a -> a -> a
+ Int
2)
  | Char
x forall a. Eq a => a -> a -> Bool
== Char
')' Bool -> Bool -> Bool
&& Char
y forall a. Eq a => a -> a -> Bool
== Char
'E' = Int
n forall a. Eq a => a -> a -> Bool
== (Int
m forall a. Num a => a -> a -> a
+ Int
1)
  | (Char
x forall a. Eq a => a -> [a] -> Bool
`elem` String
"E -") Bool -> Bool -> Bool
&& Char
y forall a. Eq a => a -> a -> Bool
== Char
'E' = Int
n forall a. Eq a => a -> a -> Bool
== Int
m 
  | Char
x forall a. Eq a => a -> a -> Bool
== Char
'E' Bool -> Bool -> Bool
&& Char
y forall a. Eq a => a -> a -> Bool
== Char
')' = Int
n forall a. Eq a => a -> a -> Bool
== (Int
m forall a. Num a => a -> a -> a
+ Int
1)
  | Bool
otherwise = Bool
False
validOrdStr0 xs :: String
xs@(Char
x:String
ys) Int
n Int
m 
  | Char -> Bool
isDigit Char
x Bool -> Bool -> Bool
|| (Char
x forall a. Eq a => a -> [a] -> Bool
`elem` String
")E") = if Char
x forall a. Eq a => a -> a -> Bool
== Char
')' then Int
n forall a. Eq a => a -> a -> Bool
== (Int
m forall a. Num a => a -> a -> a
+ Int
1) else Int
n forall a. Eq a => a -> a -> Bool
== Int
m 
  | Bool
otherwise = Bool
False
validOrdStr0 String
_ Int
n Int
m  = Int
n forall a. Eq a => a -> a -> Bool
== Int
m

-- | An extended predicate to check whether the 'String' is a probably correct representation of the
-- constraints algebraic expression for 'generalConversion' evaluation.
validOrdStr :: String -> Bool
validOrdStr :: String -> Bool
validOrdStr String
xs = String -> Int -> Int -> Bool
validOrdStr0 String
xs Int
0 Int
0 
{-# INLINE validOrdStr #-}

stage1Parsing :: String -> [String]
stage1Parsing :: String -> [String]
stage1Parsing =  forall a. (a -> a -> Bool) -> [a] -> [[a]]
groupBy (\Char
x Char
y -> Char
x forall a. Eq a => a -> a -> Bool
== Char
'(' Bool -> Bool -> Bool
&& Char
y forall a. Eq a => a -> a -> Bool
== Char
'(' Bool -> Bool -> Bool
|| Char -> Bool
isLetter Char
x Bool -> Bool -> Bool
&& Char -> Bool
isDigit Char
y Bool -> Bool -> Bool
|| Char
x forall a. Eq a => a -> a -> Bool
== Char
')' Bool -> Bool -> Bool
&& Char
y forall a. Eq a => a -> a -> Bool
== Char
')')
{-# INLINE stage1Parsing #-}

convertToBools 
  :: Int 
  -> Array Int Int 
  -> [String] 
  -> String -- ^ The result is a 'String' that Haskell can evaluate to 'Bool' (some logical expression).
convertToBools :: Int -> Array Int Int -> [String] -> String
convertToBools Int
n Array Int Int
arr xss :: [String]
xss@(String
"-":[String]
yss) = String
"not " forall a. Monoid a => a -> a -> a
`mappend` (Int -> Array Int Int -> [String] -> String
convertToBools Int
n Array Int Int
arr [String]
yss)
convertToBools Int
n Array Int Int
arr xss :: [String]
xss@(String
" ":[String]
yss) = String
" || " forall a. Monoid a => a -> a -> a
`mappend` (Int -> Array Int Int -> [String] -> String
convertToBools Int
n Array Int Int
arr [String]
yss)
convertToBools Int
n Array Int Int
arr xss :: [String]
xss@(String
xs:yss :: [String]
yss@(String
ys:[String]
tss))
  | forall a. (a -> Bool) -> [a] -> Bool
any (forall a. Eq a => a -> a -> Bool
== Char
'(') String
xs = String
xs forall a. Monoid a => a -> a -> a
`mappend` String
" " forall a. Monoid a => a -> a -> a
`mappend` Int -> Array Int Int -> [String] -> String
convertToBools Int
n Array Int Int
arr [String]
yss
  | forall a. (a -> Bool) -> [a] -> Bool
any (forall a. Eq a => a -> a -> Bool
== Char
')') String
xs = String
xs forall a. Monoid a => a -> a -> a
`mappend` (if String
ys forall a. Eq a => a -> a -> Bool
== String
" " then String
"" else String
" && ") forall a. Monoid a => a -> a -> a
`mappend` Int -> Array Int Int -> [String] -> String
convertToBools Int
n Array Int Int
arr [String]
yss
  | String
xs forall a. Eq a => a -> [a] -> Bool
`elem` [String
"True",String
"False"] = String
xs forall a. Monoid a => a -> a -> a
`mappend` (case String
ys of 
                                                 Char
')':String
_ -> String
" " 
                                                 String
" "   -> String
" "
                                                 String
_     -> String
" && ") forall a. Monoid a => a -> a -> a
`mappend` Int -> Array Int Int -> [String] -> String
convertToBools Int
n Array Int Int
arr [String]
yss 
  | Bool
otherwise = let cnstrs :: EncodedContraints Int (Array Int Int) (Array Int (Int, Int))
cnstrs = forall a. a -> Maybe a -> a
fromMaybe forall a b c. EncodedContraints a b c
E forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int
-> String
-> Maybe
     (EncodedContraints Int (Array Int Int) (Array Int (Int, Int)))
readMaybeECG Int
n forall a b. (a -> b) -> a -> b
$ String
xs in 
                      forall a. Show a => a -> String
show (Bool
-> Array Int Int
-> EncodedContraints Int (Array Int Int) (Array Int (Int, Int))
-> Bool
isConstraint1 Bool
True Array Int Int
arr EncodedContraints Int (Array Int Int) (Array Int (Int, Int))
cnstrs) 
                      forall a. Monoid a => a -> a -> a
`mappend` (case String
ys of 
                                   Char
')':String
_ -> String
" " 
                                   String
" "   -> String
" "
                                   String
_     -> String
" && ") forall a. Monoid a => a -> a -> a
`mappend` Int -> Array Int Int -> [String] -> String
convertToBools Int
n Array Int Int
arr [String]
yss 
convertToBools Int
n Array Int Int
arr xss :: [String]
xss@(String
xs:[String]
yss) 
  | forall a. (a -> Bool) -> [a] -> Bool
any (forall a. Eq a => a -> a -> Bool
== Char
')') String
xs = String
xs 
  | String
xs forall a. Eq a => a -> [a] -> Bool
`elem` [String
"True",String
"False"] = String
xs
  | Bool
otherwise = (forall a. Show a => a -> String
show forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool
-> Array Int Int
-> EncodedContraints Int (Array Int Int) (Array Int (Int, Int))
-> Bool
isConstraint1 Bool
True Array Int Int
arr forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. a -> Maybe a -> a
fromMaybe forall a b c. EncodedContraints a b c
E forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int
-> String
-> Maybe
     (EncodedContraints Int (Array Int Int) (Array Int (Int, Int)))
readMaybeECG Int
n forall a b. (a -> b) -> a -> b
$ String
xs) -- `mappend` "!!!!!"
convertToBools Int
n Array Int Int
arr [String]
_ = String
""

splitNoParenAtDisjunction :: [String] -> [[String]]
splitNoParenAtDisjunction :: [String] -> [[String]]
splitNoParenAtDisjunction xss :: [String]
xss@(String
xs:[String]
yss) 
  | forall a. [a] -> Bool
null [String]
tss = []
  | Bool
otherwise = [String]
tss forall a. a -> [a] -> [a]
: [String] -> [[String]]
splitNoParenAtDisjunction [String]
wss 
      where ([String]
tss,[String]
uss) = forall a. (a -> Bool) -> [a] -> ([a], [a])
break (forall a. Eq a => a -> a -> Bool
== String
"||") [String]
xss
            wss :: [String]
wss = forall a. Int -> [a] -> [a]
drop Int
1 [String]
uss 
splitNoParenAtDisjunction [String]
_ = []

noParenString0 :: [String] -> Bool 
noParenString0 :: [String] -> Bool
noParenString0 xss :: [String]
xss@(String
xs:String
ys:String
ts:[String]
yss) 
  | String
xs forall a. Eq a => a -> a -> Bool
== String
"not" = 
      case String
ys of 
        String
"True" -> Bool
False 
        String
"False" -> [String] -> Bool
noParenString0 [String]
yss 
  | Bool
otherwise = 
      case String
xs of
        String
"True" -> [String] -> Bool
noParenString0 (String
tsforall a. a -> [a] -> [a]
:[String]
yss)
        String
"False" -> Bool
False 
noParenString0 xss :: [String]
xss@(String
"not":String
ys:[String]
yss) = if String
ys forall a. Eq a => a -> a -> Bool
== String
"True" then Bool
False else Bool
True 
noParenString0 xss :: [String]
xss@(String
xs:[String]
yss) 
  | String
xs forall a. Eq a => a -> a -> Bool
== String
"True" = Bool
True 
  | Bool
otherwise = Bool
False 
noParenString0 [String]
_ = Bool
True

noParenString :: [String] -> Bool
noParenString :: [String] -> Bool
noParenString = [Bool] -> Bool
or forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
map [String] -> Bool
noParenString0 forall b c a. (b -> c) -> (a -> b) -> a -> c
. [String] -> [[String]]
splitNoParenAtDisjunction
{-# INLINE noParenString #-}

oneChange :: Int -> Array Int Int -> [String] -> [String]
oneChange :: Int -> Array Int Int -> [String] -> [String]
oneChange Int
m Array Int Int
arr [String]
xss 
  | forall a. [a] -> Bool
null [String]
wss = [forall a. Show a => a -> String
show forall b c a. (b -> c) -> (a -> b) -> a -> c
. [String] -> Bool
noParenString forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> [String]
words forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Array Int Int -> [String] -> String
convertToBools Int
m Array Int Int
arr forall a b. (a -> b) -> a -> b
$ [String]
xss]
  | Bool
otherwise = ((\([String]
jss, Int
m, [String]
qss) -> [String]
jss forall a. Monoid a => a -> a -> a
`mappend` [forall a. Show a => a -> String
show forall b c a. (b -> c) -> (a -> b) -> a -> c
. [String] -> Bool
noParenString forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> [String]
words forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Array Int Int -> [String] -> String
convertToBools Int
m Array Int Int
arr forall a b. (a -> b) -> a -> b
$ [String]
qss]) forall b c a. (b -> c) -> (a -> b) -> a -> c
. 
                  forall a b. (a -> b -> b) -> b -> [a] -> b
foldr (\String
xs uss :: ([String], Int, [String])
uss@([String]
tss, Int
n, [String]
rss) -> if String
xs forall a. Eq a => a -> a -> Bool
== String
"(" Bool -> Bool -> Bool
&& Int
n forall a. Eq a => a -> a -> Bool
== Int
0 
                                                      then ([String]
tss, Int
1, [String]
rss) 
                                                      else if forall a. (a -> Bool) -> [a] -> Bool
any (forall a. Eq a => a -> a -> Bool
== Char
'(') String
xs Bool -> Bool -> Bool
&& Int
n forall a. Eq a => a -> a -> Bool
== Int
0
                                                               then (forall a. Int -> [a] -> [a]
drop Int
1 String
xsforall a. a -> [a] -> [a]
:[String]
tss, Int
n, [String]
rss)
                                                               else case Int
n of 
                                                                      Int
0 -> ([String]
tss, Int
0, String
xsforall a. a -> [a] -> [a]
:[String]
rss)
                                                                      Int
1 -> (String
xsforall a. a -> [a] -> [a]
:[String]
tss, Int
1, [String]
rss)) ([], Int
0, []) forall a b. (a -> b) -> a -> b
$ [String]
yss) forall a. Monoid a => a -> a -> a
`mappend` [String]
kss
  where ([String]
yss,[String]
wss) = forall a. (a -> Bool) -> [a] -> ([a], [a])
break (forall a. (a -> Bool) -> [a] -> Bool
any (forall a. Eq a => a -> a -> Bool
== Char
')')) [String]
xss
        kss :: [String]
kss = case [String]
wss of
                String
ws:[String]
vss -> if forall a. [a] -> Int
length String
ws forall a. Eq a => a -> a -> Bool
== Int
1 then [String]
vss else forall a. Int -> [a] -> [a]
drop Int
1 String
ws forall a. a -> [a] -> [a]
: [String]
vss
                [String]
_      -> [String]
wss

generalConversion :: Int -> String -> Array Int Int -> Bool
generalConversion :: Int -> String -> Array Int Int -> Bool
generalConversion Int
m String
xs Array Int Int
arr
  | String -> Bool
validOrdStr String
xs =  (\String
ks -> if String
ks forall a. Eq a => a -> a -> Bool
== String
"True" Bool -> Bool -> Bool
|| String
ks forall a. Eq a => a -> a -> Bool
== String
"E" then Bool
True else Bool
False) forall b c a. (b -> c) -> (a -> b) -> a -> c
. 
      forall a. [a] -> a
head forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [a] -> a
head forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. (a -> Bool) -> [a] -> [a]
dropWhile ((forall a. Eq a => a -> a -> Bool
/= Int
1) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [a] -> Int
length)  forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Int -> [a] -> [a]
drop Int
1 forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. (a -> a) -> a -> [a]
iterate (Int -> Array Int Int -> [String] -> [String]
oneChange Int
m Array Int Int
arr) forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> [String]
stage1Parsing forall a b. (a -> b) -> a -> b
$ String
xs 
  | Bool
otherwise = Bool
False
{-# INLINE generalConversion #-}

-- | Can be thought of as 'filter' ('generalConversion' ... ) @<arrays>@ but is somewhat more efficient.
filterGeneralConv :: Int -> String -> [Array Int Int] -> [Array Int Int]
filterGeneralConv :: Int -> String -> [Array Int Int] -> [Array Int Int]
filterGeneralConv Int
m String
cnstrns [Array Int Int]
xs 
  | String -> Bool
validOrdStr String
cnstrns = let !xss :: [String]
xss = String -> [String]
stage1Parsing String
cnstrns in  
    forall a. (a -> Bool) -> [a] -> [a]
filter (\Array Int Int
arr -> (\String
ks -> if String
ks forall a. Eq a => a -> a -> Bool
== String
"True" Bool -> Bool -> Bool
|| String
ks forall a. Eq a => a -> a -> Bool
== String
"E" then Bool
True else Bool
False) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [a] -> a
head forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [a] -> a
head forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. (a -> Bool) -> [a] -> [a]
dropWhile ((forall a. Eq a => a -> a -> Bool
/= Int
1) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [a] -> Int
length) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Int -> [a] -> [a]
drop Int
1 forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. (a -> a) -> a -> [a]
iterate (Int -> Array Int Int -> [String] -> [String]
oneChange Int
m Array Int Int
arr) forall a b. (a -> b) -> a -> b
$ [String]
xss) [Array Int Int]
xs
  | Bool
otherwise = []
{-# INLINE filterGeneralConv #-}

-- | Inspired by the: https://hackage.haskell.org/package/base-4.14.0.0/docs/Data-Maybe.html
-- Is provided here as a more general way to read the 'String' into a 'EncodedCnstrs'. 
-- It is up to user to check whether the parameters are in the correct form, the function does
-- not do the full checking.
readMaybeECG :: Int -> String -> Maybe EncodedCnstrs
readMaybeECG :: Int
-> String
-> Maybe
     (EncodedContraints Int (Array Int Int) (Array Int (Int, Int)))
readMaybeECG Int
n String
xs
 | forall a. [a] -> Bool
null String
xs = forall a. Maybe a
Nothing
 | Int
n forall a. Ord a => a -> a -> Bool
>=Int
0 Bool -> Bool -> Bool
&& Int
n forall a. Ord a => a -> a -> Bool
<= Int
9 =
     let h :: Char
h = forall a. [a] -> a
head String
xs
         ts :: String
ts = forall a. (a -> Bool) -> [a] -> [a]
filter (\Char
x -> Char
x forall a. Ord a => a -> a -> Bool
>= Char
'0' Bool -> Bool -> Bool
&& [Char
x] forall a. Ord a => a -> a -> Bool
<= forall a. Show a => a -> String
show Int
n) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [a] -> [a]
tail forall a b. (a -> b) -> a -> b
$ String
xs in
      case Char
h of
       Char
'E' -> forall a. a -> Maybe a
Just forall a b c. EncodedContraints a b c
E
       Char
_   -> Int
-> Char
-> String
-> Maybe
     (EncodedContraints Int (Array Int Int) (Array Int (Int, Int)))
f Int
n Char
h String
ts
 | Bool
otherwise = forall a. Maybe a
Nothing
         where f :: Int
-> Char
-> String
-> Maybe
     (EncodedContraints Int (Array Int Int) (Array Int (Int, Int)))
f Int
n Char
c String
ts 
                 | Char
c forall a. Eq a => a -> [a] -> Bool
`elem` String
"DFHIMQRQTVW" = 
                       let ys0 :: [Int]
ys0 =forall a. [Maybe a] -> [a]
catMaybes forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
map (\Char
t -> forall a. Read a => String -> Maybe a
readMaybe [Char
t]::Maybe Int) forall a b. (a -> b) -> a -> b
$ String
ts
                           ys :: [Int]
ys = forall a. Eq a => [a] -> [a]
nub [Int]
ys0
                           ([Int]
jjs, [Int]
ps) = forall b (t :: * -> *) a.
(Integral b, InsertLeft t a, Monoid (t a)) =>
b -> t a -> (t a, t a)
splitAtEndG Integer
1 [Int]
ys0
                           res :: Maybe (EncodedContraints Int b c)
res 
                             | forall a. [a] -> Int
length [Int]
ys0 forall a. Ord a => a -> a -> Bool
>= Int
3 Bool -> Bool -> Bool
&& (Char
c forall a. Eq a => a -> [a] -> Bool
`elem` String
"DI") = let qs :: [Int]
qs = forall a. Int -> [a] -> [a]
take Int
2 forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Eq a => [a] -> [a]
nub forall a b. (a -> b) -> a -> b
$ [Int]
jjs
                                                                        [Int
y,Int
z] = forall a b. (a -> b) -> [a] -> [b]
map (\Int
rr ->  if Int
rr forall a. Eq a => a -> a -> Bool
== Int
0 then Int
9 else Int
rr forall a. Num a => a -> a -> a
- Int
1) [Int]
qs in if forall a. [a] -> Int
length [Int]
qs forall a. Eq a => a -> a -> Bool
/= Int
2 Bool -> Bool -> Bool
|| [Int]
ps forall a. Eq a => a -> a -> Bool
== [Int
0] Bool -> Bool -> Bool
|| [Int]
ps forall a. Ord a => a -> a -> Bool
> [Int
n] then forall a. Maybe a
Nothing else forall a. a -> Maybe a
Just ((if Char
c forall a. Eq a => a -> a -> Bool
== Char
'D' then forall a b c. a -> a -> a -> a -> EncodedContraints a b c
D else forall a b c. a -> a -> a -> a -> EncodedContraints a b c
I) Int
n Int
y Int
z (forall a. [a] -> a
head [Int]
ps))
                             | forall a. [a] -> Int
length [Int]
ys forall a. Eq a => a -> a -> Bool
/= forall {a}. Num a => Char -> a
g Char
c = forall a. Maybe a
Nothing
                             | Char
c forall a. Eq a => a -> a -> Bool
== Char
'Q' = let [Int
y,Int
z,Int
u,Int
w] = forall a b. (a -> b) -> [a] -> [b]
map (\Int
rr -> if Int
rr  forall a. Eq a => a -> a -> Bool
== Int
0 then Int
9 else Int
rr forall a. Num a => a -> a -> a
- Int
1) [Int]
ys in forall a. a -> Maybe a
Just (forall a b c. a -> a -> a -> a -> a -> EncodedContraints a b c
Q Int
n Int
y Int
z Int
u Int
w)
                             | Char
c forall a. Eq a => a -> [a] -> Bool
`elem` String
"FVW" = let [Int
y,Int
z] = forall a b. (a -> b) -> [a] -> [b]
map (\Int
rr -> if Int
rr  forall a. Eq a => a -> a -> Bool
== Int
0 then Int
9 else Int
rr forall a. Num a => a -> a -> a
- Int
1) [Int]
ys in forall a. a -> Maybe a
Just ((case Char
c of {Char
'F' -> forall a b c. a -> a -> a -> EncodedContraints a b c
F; Char
'V'-> forall a b c. a -> a -> a -> EncodedContraints a b c
V; ~Char
ww -> forall a b c. a -> a -> a -> EncodedContraints a b c
W}) Int
n Int
y Int
z)
                             | Char
c forall a. Eq a => a -> [a] -> Bool
`elem` String
"HMT" = let [Int
y,Int
z,Int
u] = forall a b. (a -> b) -> [a] -> [b]
map (\Int
rr -> if Int
rr  forall a. Eq a => a -> a -> Bool
== Int
0 then Int
9 else Int
rr forall a. Num a => a -> a -> a
- Int
1) [Int]
ys in forall a. a -> Maybe a
Just ((case Char
c of {Char
'T' -> forall a b c. a -> a -> a -> a -> EncodedContraints a b c
T; Char
'H' -> forall a b c. a -> a -> a -> a -> EncodedContraints a b c
H; Char
'M' -> forall a b c. a -> a -> a -> a -> EncodedContraints a b c
M; ~Char
rr -> forall a b c. a -> a -> a -> a -> EncodedContraints a b c
R}) Int
n Int
y Int
z Int
u)
                             | Bool
otherwise = forall a. Maybe a
Nothing in forall {b} {c}. Maybe (EncodedContraints Int b c)
res
                 | Char
c forall a. Eq a => a -> [a] -> Bool
`elem` String
"AB" = let y :: Maybe Int
y = forall a. Read a => String -> Maybe a
readMaybe (forall a. Int -> [a] -> [a]
take Int
1 String
ts)::Maybe Int in
                                     if forall a. Maybe a -> Bool
isJust Maybe Int
y then
                                         let y0 :: Int
y0 = forall a. HasCallStack => Maybe a -> a
fromJust Maybe Int
y
                                             zs :: [Int]
zs = forall a b. (a -> b) -> [a] -> [b]
map (\Int
rr -> if Int
rr  forall a. Eq a => a -> a -> Bool
== Int
0 then Int
9 else Int
rr forall a. Num a => a -> a -> a
- Int
1) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. (a -> Bool) -> [a] -> [a]
filter (forall a. Eq a => a -> a -> Bool
/= Int
y0) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Eq a => [a] -> [a]
nub forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [Maybe a] -> [a]
catMaybes forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
map (\Char
t -> forall a. Read a => String -> Maybe a
readMaybe [Char
t]::Maybe Int) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Int -> [a] -> [a]
drop Int
1 forall a b. (a -> b) -> a -> b
$ String
ts in
                                               case [Int]
zs of
                                                 [] -> forall a. Maybe a
Nothing
                                                 ~[Int]
x2 -> forall a. a -> Maybe a
Just ((if Char
c forall a. Eq a => a -> a -> Bool
== Char
'A' then forall a b c. a -> a -> b -> EncodedContraints a b c
SA else forall a b c. a -> a -> b -> EncodedContraints a b c
SB) Int
n (if Int
y0 forall a. Eq a => a -> a -> Bool
== Int
0 then Int
9 else Int
y0 forall a. Num a => a -> a -> a
- Int
1) (forall i e. Ix i => (i, i) -> [e] -> Array i e
listArray (Int
0,forall a. [a] -> Int
length [Int]
x2 forall a. Num a => a -> a -> a
- Int
1) [Int]
x2))
                                     else forall a. Maybe a
Nothing 
                 | Char
c forall a. Eq a => a -> a -> Bool
== Char
'P' = if forall a. [a] -> Bool
null String
ts then forall a. a -> Maybe a
Just forall a b c. EncodedContraints a b c
E else forall a. a -> Maybe a
Just forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b c. a -> b -> EncodedContraints a b c
P Int
n forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall i e. Ix i => (i, i) -> [e] -> Array i e
listArray (Int
0,forall a. [a] -> Int
length String
ts forall a. Num a => a -> a -> a
- Int
1) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
map (\Char
r -> case (forall a. HasCallStack => Maybe a -> a
fromJust (forall a. Read a => String -> Maybe a
readMaybe [Char
r]::Maybe Int)) of {Int
0 -> Int
9; Int
n -> Int
nforall a. Num a => a -> a -> a
-Int
1}) forall a b. (a -> b) -> a -> b
$ String
ts
                 | Char
c forall a. Eq a => a -> a -> Bool
== Char
'N' = if Int
tl forall a. Eq a => a -> a -> Bool
== Int
0 then forall a. a -> Maybe a
Just forall a b c. EncodedContraints a b c
E else forall a. a -> Maybe a
Just forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b c. a -> c -> EncodedContraints a b c
N Int
n forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall i e. Ix i => (i, i) -> [e] -> Array i e
listArray (Int
0, Int
tl forall a. Num a => a -> a -> a
- Int
1) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
map ((\[Int
s,Int
w] -> (Int
w, Int
s)) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
map (\Char
r -> case (forall a. HasCallStack => Maybe a -> a
fromJust (forall a. Read a => String -> Maybe a
readMaybe [Char
r]::Maybe Int)) of {Int
0 -> Int
9; Int
n -> Int
nforall a. Num a => a -> a -> a
-Int
1})) forall a b. (a -> b) -> a -> b
$ [String]
h3
                 | Bool
otherwise = forall a. Maybe a
Nothing
                        where h1 :: [a] -> [[a]]
h1 bs :: [a]
bs@(a
b:a
d:[a]
ds) = [a
b,a
d]forall a. a -> [a] -> [a]
:[a] -> [[a]]
h1 [a]
ds
                              h1 [a]
_ = [] 
                              h2 :: [String]
h2 = forall {a}. [a] -> [[a]]
h1 String
ts
                              qqs :: String
qqs = forall a b. (a -> b) -> [a] -> [b]
map forall a. [a] -> a
head [String]
h2
                              pps :: String
pps = forall a b. (a -> b) -> [a] -> [b]
map forall a. [a] -> a
last [String]
h2
                              h3 :: [String]
h3 
                               | forall a. [a] -> Int
length (forall a. Eq a => [a] -> [a]
nub String
qqs) forall a. Eq a => a -> a -> Bool
== forall a. [a] -> Int
length String
qqs Bool -> Bool -> Bool
&& forall a. [a] -> Int
length (forall a. Eq a => [a] -> [a]
nub String
pps) forall a. Eq a => a -> a -> Bool
== forall a. [a] -> Int
length String
pps = [String]
h2
                               | Bool
otherwise = []
                              tl :: Int
tl = forall a. [a] -> Int
length [String]
h3
               g :: Char -> a
g Char
c 
                 | Char
c forall a. Eq a => a -> [a] -> Bool
`elem` String
"FVW" = a
2
                 | Char
c forall a. Eq a => a -> a -> Bool
== Char
'Q' = a
4
                 | Bool
otherwise = a
3


type EncodedCnstrs = EncodedContraints Int (Array Int Int) (Array Int (Int, Int))

-- | Must be applied to the correct array of permutation indeces. Otherwise, it gives runtime error (exception). All the integers inside the
-- 'EncodedCnstrs' must be in the range [0..n-1] where @n@ corresponds to the maximum element in the permutation 'Array' 'Int' 'Int'. 
decodeConstraint1 :: (InsertLeft t (Array Int Int), Monoid (t (Array Int Int))) => EncodedCnstrs -> t (Array Int Int) -> t (Array Int Int)
decodeConstraint1 :: forall (t :: * -> *).
(InsertLeft t (Array Int Int), Monoid (t (Array Int Int))) =>
EncodedContraints Int (Array Int Int) (Array Int (Int, Int))
-> t (Array Int Int) -> t (Array Int Int)
decodeConstraint1 EncodedContraints Int (Array Int Int) (Array Int (Int, Int))
E = forall a. a -> a
id
decodeConstraint1 (P Int
_ Array Int Int
v) = forall (t :: * -> *).
(InsertLeft t (Array Int Int), Monoid (t (Array Int Int))) =>
Array Int Int -> t (Array Int Int) -> t (Array Int Int)
fixedPointsS Array Int Int
v
decodeConstraint1 (Q Int
_ Int
i Int
j Int
k Int
l) = forall (t :: * -> *).
(InsertLeft t (Array Int Int), Monoid (t (Array Int Int))) =>
Int -> Int -> Int -> Int -> t (Array Int Int) -> t (Array Int Int)
unsafeQuadruples Int
i Int
j Int
k Int
l
decodeConstraint1 (T Int
_ Int
i Int
j Int
k) = forall (t :: * -> *).
(InsertLeft t (Array Int Int), Monoid (t (Array Int Int))) =>
Int -> Int -> Int -> t (Array Int Int) -> t (Array Int Int)
unsafeTriples Int
i Int
j Int
k
decodeConstraint1 (SA Int
_ Int
i Array Int Int
v) = forall (t :: * -> *).
(InsertLeft t (Array Int Int), Monoid (t (Array Int Int))) =>
Int -> Array Int Int -> t (Array Int Int) -> t (Array Int Int)
unsafeSeveralA Int
i Array Int Int
v
decodeConstraint1 (SB Int
_ Int
i Array Int Int
v) = forall (t :: * -> *).
(InsertLeft t (Array Int Int), Monoid (t (Array Int Int))) =>
Int -> Array Int Int -> t (Array Int Int) -> t (Array Int Int)
unsafeSeveralB Int
i Array Int Int
v
decodeConstraint1 (F Int
_ Int
i Int
j) = forall (t :: * -> *).
(InsertLeft t (Array Int Int), Monoid (t (Array Int Int))) =>
Int -> Int -> t (Array Int Int) -> t (Array Int Int)
filterOrderIJ Int
i Int
j
decodeConstraint1 (V Int
_ Int
i Int
j) = forall (t :: * -> *).
(InsertLeft t (Array Int Int), Monoid (t (Array Int Int))) =>
Int -> Int -> Int -> t (Array Int Int) -> t (Array Int Int)
filterSignDistanceIJ Int
i Int
j (forall a. Num a => a -> a
abs forall a b. (a -> b) -> a -> b
$ Int
j forall a. Num a => a -> a -> a
- Int
i)
decodeConstraint1 (W Int
_ Int
i Int
j) = forall (t :: * -> *).
(InsertLeft t (Array Int Int), Monoid (t (Array Int Int))) =>
Int -> Int -> Int -> t (Array Int Int) -> t (Array Int Int)
filterUnsignDistanceIJ Int
i Int
j (forall a. Num a => a -> a
abs forall a b. (a -> b) -> a -> b
$ Int
j forall a. Num a => a -> a -> a
- Int
i)
decodeConstraint1 (H Int
_ Int
i Int
j Int
k) = forall (t :: * -> *).
(InsertLeft t (Array Int Int), Monoid (t (Array Int Int))) =>
Int
-> Int
-> Int
-> Int
-> Int
-> t (Array Int Int)
-> t (Array Int Int)
filterSignDistanceIJK3 Int
i Int
j Int
k (forall a. Num a => a -> a
abs forall a b. (a -> b) -> a -> b
$ Int
j forall a. Num a => a -> a -> a
- Int
i) (forall a. Num a => a -> a
abs forall a b. (a -> b) -> a -> b
$ Int
k forall a. Num a => a -> a -> a
- Int
j)
decodeConstraint1 (R Int
_ Int
i Int
j Int
k) = forall (t :: * -> *).
(InsertLeft t (Array Int Int), Monoid (t (Array Int Int))) =>
Int
-> Int
-> Int
-> Int
-> Int
-> t (Array Int Int)
-> t (Array Int Int)
filterUnsignDistanceIJK3 Int
i Int
j Int
k (forall a. Num a => a -> a
abs forall a b. (a -> b) -> a -> b
$ Int
j forall a. Num a => a -> a -> a
- Int
i) (forall a. Num a => a -> a
abs forall a b. (a -> b) -> a -> b
$ Int
k forall a. Num a => a -> a -> a
- Int
j)
decodeConstraint1 (M Int
_ Int
i Int
j Int
k) = forall (t :: * -> *).
(InsertLeft t (Array Int Int), Monoid (t (Array Int Int))) =>
Int
-> Int
-> Int
-> Int
-> Int
-> t (Array Int Int)
-> t (Array Int Int)
filterMixedDistanceIJK3 Int
i Int
j Int
k (forall a. Num a => a -> a
abs forall a b. (a -> b) -> a -> b
$ Int
j forall a. Num a => a -> a -> a
- Int
i) (forall a. Num a => a -> a
abs forall a b. (a -> b) -> a -> b
$ Int
k forall a. Num a => a -> a -> a
- Int
j)
decodeConstraint1 (N Int
_ Array Int (Int, Int)
v) = forall (t :: * -> *).
(InsertLeft t (Array Int Int), Monoid (t (Array Int Int))) =>
Array Int (Int, Int) -> t (Array Int Int) -> t (Array Int Int)
fixedPointsG Array Int (Int, Int)
v
decodeConstraint1 (D Int
_ Int
i Int
j Int
d) = forall (t :: * -> *).
(InsertLeft t (Array Int Int), Monoid (t (Array Int Int))) =>
Int -> Int -> Int -> t (Array Int Int) -> t (Array Int Int)
filterSignDistanceIJ Int
i Int
j (forall a. Num a => a -> a
abs Int
d)
decodeConstraint1 (I Int
_ Int
i Int
j Int
d) = forall (t :: * -> *).
(InsertLeft t (Array Int Int), Monoid (t (Array Int Int))) =>
Int -> Int -> Int -> t (Array Int Int) -> t (Array Int Int)
filterUnsignDistanceIJ Int
i Int
j (forall a. Num a => a -> a
abs Int
d)


-- | Must be applied to the correct array of permutation indeces. Otherwise, it gives runtime error (exception). All the integers inside the
-- 'EncodedCnstrs' must be in the range [0..n-1] where @n@ corresponds to the maximum element in the permutation 'Array' 'Int' 'Int'.
decodeLConstraints :: (InsertLeft t (Array Int Int), Monoid (t (Array Int Int))) => [EncodedCnstrs] -> t (Array Int Int) -> t (Array Int Int)
decodeLConstraints :: forall (t :: * -> *).
(InsertLeft t (Array Int Int), Monoid (t (Array Int Int))) =>
[EncodedContraints Int (Array Int Int) (Array Int (Int, Int))]
-> t (Array Int Int) -> t (Array Int Int)
decodeLConstraints (EncodedContraints Int (Array Int Int) (Array Int (Int, Int))
x:[EncodedContraints Int (Array Int Int) (Array Int (Int, Int))]
xs) = forall (t :: * -> *).
(InsertLeft t (Array Int Int), Monoid (t (Array Int Int))) =>
[EncodedContraints Int (Array Int Int) (Array Int (Int, Int))]
-> t (Array Int Int) -> t (Array Int Int)
decodeLConstraints' [EncodedContraints Int (Array Int Int) (Array Int (Int, Int))]
ys forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: * -> *).
(InsertLeft t (Array Int Int), Monoid (t (Array Int Int))) =>
EncodedContraints Int (Array Int Int) (Array Int (Int, Int))
-> t (Array Int Int) -> t (Array Int Int)
decodeConstraint1 EncodedContraints Int (Array Int Int) (Array Int (Int, Int))
y
  where y :: EncodedContraints Int (Array Int Int) (Array Int (Int, Int))
y = forall a. Ord a => [a] -> a
minimum (EncodedContraints Int (Array Int Int) (Array Int (Int, Int))
xforall a. a -> [a] -> [a]
:[EncodedContraints Int (Array Int Int) (Array Int (Int, Int))]
xs)
        ys :: [EncodedContraints Int (Array Int Int) (Array Int (Int, Int))]
ys = forall a. (a -> Bool) -> [a] -> [a]
filter (forall a. Eq a => a -> a -> Bool
/= EncodedContraints Int (Array Int Int) (Array Int (Int, Int))
y) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall {a} {b} {c}.
[EncodedContraints a b c] -> [EncodedContraints a b c]
g forall a b. (a -> b) -> a -> b
$ (EncodedContraints Int (Array Int Int) (Array Int (Int, Int))
xforall a. a -> [a] -> [a]
:[EncodedContraints Int (Array Int Int) (Array Int (Int, Int))]
xs)
        g :: [EncodedContraints a b c] -> [EncodedContraints a b c]
g (EncodedContraints a b c
E:[EncodedContraints a b c]
zs) = [EncodedContraints a b c] -> [EncodedContraints a b c]
g [EncodedContraints a b c]
zs
        g (EncodedContraints a b c
z:[EncodedContraints a b c]
zs) = EncodedContraints a b c
z forall a. a -> [a] -> [a]
: [EncodedContraints a b c] -> [EncodedContraints a b c]
g [EncodedContraints a b c]
zs
        g [EncodedContraints a b c]
_ = []
        decodeLConstraints' :: [EncodedContraints Int (Array Int Int) (Array Int (Int, Int))]
-> t (Array Int Int) -> t (Array Int Int)
decodeLConstraints' (EncodedContraints Int (Array Int Int) (Array Int (Int, Int))
z:[EncodedContraints Int (Array Int Int) (Array Int (Int, Int))]
zs) = [EncodedContraints Int (Array Int Int) (Array Int (Int, Int))]
-> t (Array Int Int) -> t (Array Int Int)
decodeLConstraints' [EncodedContraints Int (Array Int Int) (Array Int (Int, Int))]
zs forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: * -> *).
(InsertLeft t (Array Int Int), Monoid (t (Array Int Int))) =>
EncodedContraints Int (Array Int Int) (Array Int (Int, Int))
-> t (Array Int Int) -> t (Array Int Int)
decodeConstraint1 EncodedContraints Int (Array Int Int) (Array Int (Int, Int))
z
        decodeLConstraints' [EncodedContraints Int (Array Int Int) (Array Int (Int, Int))]
_ = forall a. a -> a
id
decodeLConstraints [EncodedContraints Int (Array Int Int) (Array Int (Int, Int))]
_ = forall a. a -> a
id

isConstraint1 :: Bool -> Array Int Int -> EncodedCnstrs -> Bool
isConstraint1 :: Bool
-> Array Int Int
-> EncodedContraints Int (Array Int Int) (Array Int (Int, Int))
-> Bool
isConstraint1 Bool
bool Array Int Int
arr EncodedContraints Int (Array Int Int) (Array Int (Int, Int))
E = Bool
bool
isConstraint1 Bool
True Array Int Int
arr (F Int
_ Int
i Int
j) = Int -> Int -> Array Int Int -> Bool
unsafeOrderIJ Int
i Int
j Array Int Int
arr 
isConstraint1 Bool
True Array Int Int
arr (T Int
_ Int
i Int
j Int
k) = Int -> Int -> Int -> Array Int Int -> Bool
isTripleOrdered Int
i Int
j Int
k Array Int Int
arr 
isConstraint1 Bool
True Array Int Int
arr (Q Int
_ Int
i Int
j Int
k Int
l) = Int -> Int -> Int -> Int -> Array Int Int -> Bool
isQuadrupleOrdered Int
i Int
j Int
k Int
l Array Int Int
arr 
isConstraint1 Bool
True Array Int Int
arr (SA Int
_ Int
i Array Int Int
arr2) = Int -> Array Int Int -> Array Int Int -> Bool
isSeveralAOrdered Int
i Array Int Int
arr2 Array Int Int
arr 
isConstraint1 Bool
True Array Int Int
arr (SB Int
_ Int
i Array Int Int
arr2) = Int -> Array Int Int -> Array Int Int -> Bool
isSeveralBOrdered Int
i Array Int Int
arr2 Array Int Int
arr 
isConstraint1 Bool
True Array Int Int
arr (P Int
_ Array Int Int
arr2) = Array Int Int -> Array Int Int -> Bool
isFixedPoint Array Int Int
arr2 Array Int Int
arr 
isConstraint1 Bool
True Array Int Int
arr (H Int
_ Int
i Int
j Int
k) = Int -> Int -> Int -> Int -> Int -> Array Int Int -> Bool
isSignDistIJK3 Int
i Int
j Int
k (forall a. Num a => a -> a
abs forall a b. (a -> b) -> a -> b
$ Int
j forall a. Num a => a -> a -> a
- Int
i) (forall a. Num a => a -> a
abs forall a b. (a -> b) -> a -> b
$ Int
k forall a. Num a => a -> a -> a
- Int
j) Array Int Int
arr 
isConstraint1 Bool
True Array Int Int
arr (M Int
_ Int
i Int
j Int
k) = Int -> Int -> Int -> Int -> Int -> Array Int Int -> Bool
isMixedDistIJK3 Int
i Int
j Int
k (forall a. Num a => a -> a
abs forall a b. (a -> b) -> a -> b
$ Int
j forall a. Num a => a -> a -> a
- Int
i) (forall a. Num a => a -> a
abs forall a b. (a -> b) -> a -> b
$ Int
k forall a. Num a => a -> a -> a
- Int
j) Array Int Int
arr 
isConstraint1 Bool
True Array Int Int
arr (R Int
_ Int
i Int
j Int
k) = Int -> Int -> Int -> Int -> Int -> Array Int Int -> Bool
isUnsignDistIJK3 Int
i Int
j Int
k (forall a. Num a => a -> a
abs forall a b. (a -> b) -> a -> b
$ Int
j forall a. Num a => a -> a -> a
- Int
i) (forall a. Num a => a -> a
abs forall a b. (a -> b) -> a -> b
$ Int
k forall a. Num a => a -> a -> a
- Int
j) Array Int Int
arr 
isConstraint1 Bool
True Array Int Int
arr (V Int
_ Int
i Int
j) = Int -> Int -> Int -> Array Int Int -> Bool
unsafeSignDistanceIJ Int
i Int
j (forall a. Num a => a -> a
abs forall a b. (a -> b) -> a -> b
$ Int
j forall a. Num a => a -> a -> a
- Int
i) Array Int Int
arr 
isConstraint1 Bool
True Array Int Int
arr (W Int
_ Int
i Int
j) = Int -> Int -> Int -> Array Int Int -> Bool
unsafeUnsignDistanceIJ Int
i Int
j (forall a. Num a => a -> a
abs forall a b. (a -> b) -> a -> b
$ Int
j forall a. Num a => a -> a -> a
- Int
i) Array Int Int
arr 
isConstraint1 Bool
True Array Int Int
arr (N Int
_ Array Int (Int, Int)
arr2) = Array Int (Int, Int) -> Array Int Int -> Bool
isFixedPointTup Array Int (Int, Int)
arr2 Array Int Int
arr 
isConstraint1 Bool
True Array Int Int
arr (D Int
_ Int
i Int
j Int
d) = Int -> Int -> Int -> Array Int Int -> Bool
unsafeSignDistanceIJ Int
i Int
j (forall a. Num a => a -> a
abs Int
d) Array Int Int
arr 
isConstraint1 Bool
True Array Int Int
arr (I Int
_ Int
i Int
j Int
d) = Int -> Int -> Int -> Array Int Int -> Bool
unsafeUnsignDistanceIJ Int
i Int
j (forall a. Num a => a -> a
abs Int
d) Array Int Int
arr 
isConstraint1 Bool
False Array Int Int
arr (F Int
_ Int
i Int
j) = Int -> Int -> Array Int Int -> Bool
unsafeOrderIJ Int
j Int
i Array Int Int
arr 
isConstraint1 Bool
False Array Int Int
arr (T Int
_ Int
i Int
j Int
k) = Int -> Int -> Int -> Array Int Int -> Bool
notTripleOrdered Int
i Int
j Int
k Array Int Int
arr 
isConstraint1 Bool
False Array Int Int
arr (Q Int
_ Int
i Int
j Int
k Int
l) = Int -> Int -> Int -> Int -> Array Int Int -> Bool
notQuadrupleOrdered Int
i Int
j Int
k Int
l Array Int Int
arr 
isConstraint1 Bool
False Array Int Int
arr (SA Int
_ Int
i Array Int Int
arr2) = Int -> Array Int Int -> Array Int Int -> Bool
notSeveralAOrdered Int
i Array Int Int
arr2 Array Int Int
arr 
isConstraint1 Bool
False Array Int Int
arr (SB Int
_ Int
i Array Int Int
arr2) = Int -> Array Int Int -> Array Int Int -> Bool
notSeveralBOrdered Int
i Array Int Int
arr2 Array Int Int
arr 
isConstraint1 Bool
False Array Int Int
arr (P Int
_ Array Int Int
arr2) = Array Int Int -> Array Int Int -> Bool
notFixedPoint Array Int Int
arr2 Array Int Int
arr 
isConstraint1 Bool
False Array Int Int
arr (H Int
_ Int
i Int
j Int
k) = Int -> Int -> Int -> Int -> Int -> Array Int Int -> Bool
notSignDistIJK3 Int
i Int
j Int
k (forall a. Num a => a -> a
abs forall a b. (a -> b) -> a -> b
$ Int
j forall a. Num a => a -> a -> a
- Int
i) (forall a. Num a => a -> a
abs forall a b. (a -> b) -> a -> b
$ Int
k forall a. Num a => a -> a -> a
- Int
j) Array Int Int
arr 
isConstraint1 Bool
False Array Int Int
arr (M Int
_ Int
i Int
j Int
k) = Int -> Int -> Int -> Int -> Int -> Array Int Int -> Bool
notMixedDistIJK3 Int
i Int
j Int
k (forall a. Num a => a -> a
abs forall a b. (a -> b) -> a -> b
$ Int
j forall a. Num a => a -> a -> a
- Int
i) (forall a. Num a => a -> a
abs forall a b. (a -> b) -> a -> b
$ Int
k forall a. Num a => a -> a -> a
- Int
j) Array Int Int
arr 
isConstraint1 Bool
False Array Int Int
arr (R Int
_ Int
i Int
j Int
k) = Int -> Int -> Int -> Int -> Int -> Array Int Int -> Bool
notUnsignDistIJK3 Int
i Int
j Int
k (forall a. Num a => a -> a
abs forall a b. (a -> b) -> a -> b
$ Int
j forall a. Num a => a -> a -> a
- Int
i) (forall a. Num a => a -> a
abs forall a b. (a -> b) -> a -> b
$ Int
k forall a. Num a => a -> a -> a
- Int
j) Array Int Int
arr 
isConstraint1 Bool
False Array Int Int
arr (V Int
_ Int
i Int
j) = Int -> Int -> Int -> Array Int Int -> Bool
unsafeSignDistanceIJ Int
j Int
i (forall a. Num a => a -> a
abs forall a b. (a -> b) -> a -> b
$ Int
j forall a. Num a => a -> a -> a
- Int
i) Array Int Int
arr 
isConstraint1 Bool
False Array Int Int
arr (W Int
_ Int
i Int
j) = Bool -> Bool
not forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Int -> Int -> Array Int Int -> Bool
unsafeUnsignDistanceIJ Int
i Int
j (forall a. Num a => a -> a
abs forall a b. (a -> b) -> a -> b
$ Int
j forall a. Num a => a -> a -> a
- Int
i) forall a b. (a -> b) -> a -> b
$ Array Int Int
arr 
isConstraint1 Bool
False Array Int Int
arr (N Int
_ Array Int (Int, Int)
arr2) = Array Int (Int, Int) -> Array Int Int -> Bool
notFixedPointTup Array Int (Int, Int)
arr2 Array Int Int
arr 
isConstraint1 Bool
False Array Int Int
arr (D Int
_ Int
i Int
j Int
d) = Int -> Int -> Int -> Array Int Int -> Bool
unsafeSignDistanceIJ Int
j Int
i (forall a. Num a => a -> a
abs Int
d) Array Int Int
arr 
isConstraint1 Bool
False Array Int Int
arr (I Int
_ Int
i Int
j Int
d) = Bool -> Bool
not forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Int -> Int -> Array Int Int -> Bool
unsafeUnsignDistanceIJ Int
i Int
j (forall a. Num a => a -> a
abs Int
d) forall a b. (a -> b) -> a -> b
$ Array Int Int
arr 

isE :: EncodedCnstrs -> Bool
isE :: EncodedContraints Int (Array Int Int) (Array Int (Int, Int))
-> Bool
isE EncodedContraints Int (Array Int Int) (Array Int (Int, Int))
E = Bool
True
isE EncodedContraints Int (Array Int Int) (Array Int (Int, Int))
_ = Bool
False

isP :: EncodedCnstrs -> Bool
isP :: EncodedContraints Int (Array Int Int) (Array Int (Int, Int))
-> Bool
isP (P Int
_ Array Int Int
_) = Bool
True
isP EncodedContraints Int (Array Int Int) (Array Int (Int, Int))
_ = Bool
False

isF :: EncodedCnstrs -> Bool
isF :: EncodedContraints Int (Array Int Int) (Array Int (Int, Int))
-> Bool
isF (F Int
_ Int
_ Int
_) = Bool
True
isF EncodedContraints Int (Array Int Int) (Array Int (Int, Int))
_ = Bool
False

isT :: EncodedCnstrs -> Bool
isT :: EncodedContraints Int (Array Int Int) (Array Int (Int, Int))
-> Bool
isT (T Int
_ Int
_ Int
_ Int
_) = Bool
True
isT EncodedContraints Int (Array Int Int) (Array Int (Int, Int))
_ = Bool
False

isQ :: EncodedCnstrs -> Bool
isQ :: EncodedContraints Int (Array Int Int) (Array Int (Int, Int))
-> Bool
isQ (Q Int
_ Int
_ Int
_ Int
_ Int
_) = Bool
True
isQ EncodedContraints Int (Array Int Int) (Array Int (Int, Int))
_ = Bool
False

isSA :: EncodedCnstrs -> Bool
isSA :: EncodedContraints Int (Array Int Int) (Array Int (Int, Int))
-> Bool
isSA (SA Int
_ Int
_ Array Int Int
_) = Bool
True
isSA EncodedContraints Int (Array Int Int) (Array Int (Int, Int))
_ = Bool
False

isSB :: EncodedCnstrs -> Bool
isSB :: EncodedContraints Int (Array Int Int) (Array Int (Int, Int))
-> Bool
isSB (SB Int
_ Int
_ Array Int Int
_) = Bool
True
isSB EncodedContraints Int (Array Int Int) (Array Int (Int, Int))
_ = Bool
False

isV :: EncodedCnstrs -> Bool
isV :: EncodedContraints Int (Array Int Int) (Array Int (Int, Int))
-> Bool
isV (V Int
_ Int
_ Int
_) = Bool
True
isV EncodedContraints Int (Array Int Int) (Array Int (Int, Int))
_ = Bool
False

isW :: EncodedCnstrs -> Bool
isW :: EncodedContraints Int (Array Int Int) (Array Int (Int, Int))
-> Bool
isW (W Int
_ Int
_ Int
_) = Bool
True
isW EncodedContraints Int (Array Int Int) (Array Int (Int, Int))
_ = Bool
False

isH :: EncodedCnstrs -> Bool
isH :: EncodedContraints Int (Array Int Int) (Array Int (Int, Int))
-> Bool
isH (H Int
_ Int
_ Int
_ Int
_) = Bool
True
isH EncodedContraints Int (Array Int Int) (Array Int (Int, Int))
_ = Bool
False

isR :: EncodedCnstrs -> Bool
isR :: EncodedContraints Int (Array Int Int) (Array Int (Int, Int))
-> Bool
isR (R Int
_ Int
_ Int
_ Int
_) = Bool
True
isR EncodedContraints Int (Array Int Int) (Array Int (Int, Int))
_ = Bool
False

isM :: EncodedCnstrs -> Bool
isM :: EncodedContraints Int (Array Int Int) (Array Int (Int, Int))
-> Bool
isM (M Int
_ Int
_ Int
_ Int
_) = Bool
True
isM EncodedContraints Int (Array Int Int) (Array Int (Int, Int))
_ = Bool
False

isN :: EncodedCnstrs -> Bool
isN :: EncodedContraints Int (Array Int Int) (Array Int (Int, Int))
-> Bool
isN (N Int
_ Array Int (Int, Int)
_) = Bool
True
isN EncodedContraints Int (Array Int Int) (Array Int (Int, Int))
_ = Bool
False

isD :: EncodedCnstrs -> Bool
isD :: EncodedContraints Int (Array Int Int) (Array Int (Int, Int))
-> Bool
isD (D Int
_ Int
_ Int
_ Int
_) = Bool
True
isD EncodedContraints Int (Array Int Int) (Array Int (Int, Int))
_ = Bool
False

isI :: EncodedCnstrs -> Bool
isI :: EncodedContraints Int (Array Int Int) (Array Int (Int, Int))
-> Bool
isI (I Int
_ Int
_ Int
_ Int
_) = Bool
True
isI EncodedContraints Int (Array Int Int) (Array Int (Int, Int))
_ = Bool
False


{-| Works only with the correctly defined argument though it is not checked. Use with this caution.
-}
getIEl :: EncodedCnstrs -> Int
getIEl :: EncodedContraints Int (Array Int Int) (Array Int (Int, Int)) -> Int
getIEl EncodedContraints Int (Array Int Int) (Array Int (Int, Int))
E = -Int
1
getIEl (P Int
_ Array Int Int
arr) = forall i e. Array i e -> Int -> e
unsafeAt Array Int Int
arr Int
0
getIEl (Q Int
_ Int
i Int
_ Int
_ Int
_) = Int
i
getIEl (T Int
_ Int
i Int
_ Int
_) = Int
i
getIEl (SA Int
_ Int
i Array Int Int
_) = Int
i
getIEl (SB Int
_ Int
i Array Int Int
_) = Int
i
getIEl (F Int
_ Int
i Int
_) = Int
i
getIEl (V Int
_ Int
i Int
_) = Int
i
getIEl (W Int
_ Int
i Int
_) = Int
i
getIEl (H Int
_ Int
i Int
_ Int
_) = Int
i
getIEl (R Int
_ Int
i Int
_ Int
_) = Int
i
getIEl (M Int
_ Int
i Int
_ Int
_) = Int
i
getIEl (N Int
_ Array Int (Int, Int)
arr) = forall a b. (a, b) -> a
fst forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall i e. Array i e -> Int -> e
unsafeAt Array Int (Int, Int)
arr forall a b. (a -> b) -> a -> b
$ Int
0 
getIEl (D Int
_ Int
i Int
_ Int
_) = Int
i
getIEl (I Int
_ Int
i Int
_ Int
_) = Int
i

{-| Works only with the correctly defined arguments though it is not checked. Use with this caution.
-}
setIEl :: Int -> EncodedCnstrs -> EncodedCnstrs
setIEl :: Int
-> EncodedContraints Int (Array Int Int) (Array Int (Int, Int))
-> EncodedContraints Int (Array Int Int) (Array Int (Int, Int))
setIEl Int
_ EncodedContraints Int (Array Int Int) (Array Int (Int, Int))
E = forall a b c. EncodedContraints a b c
E
setIEl Int
i (P Int
n Array Int Int
arr) = forall a b c. a -> b -> EncodedContraints a b c
P Int
n (Array Int Int
arr forall i e. Ix i => Array i e -> [(i, e)] -> Array i e
// [(Int
0,Int
i)])
setIEl Int
i (Q Int
n Int
_ Int
j Int
k Int
l) = forall a b c. a -> a -> a -> a -> a -> EncodedContraints a b c
Q Int
n Int
i Int
j Int
k Int
l
setIEl Int
i (T Int
n Int
_ Int
j Int
k) = forall a b c. a -> a -> a -> a -> EncodedContraints a b c
T Int
n Int
i Int
j Int
k
setIEl Int
i (SA Int
n Int
_ Array Int Int
v) = forall a b c. a -> a -> b -> EncodedContraints a b c
SA Int
n Int
i Array Int Int
v
setIEl Int
i (SB Int
n Int
_ Array Int Int
v) = forall a b c. a -> a -> b -> EncodedContraints a b c
SB Int
n Int
i Array Int Int
v
setIEl Int
i (F Int
n Int
_ Int
j) = forall a b c. a -> a -> a -> EncodedContraints a b c
F Int
n Int
i Int
j
setIEl Int
i (V Int
n Int
_ Int
j) = forall a b c. a -> a -> a -> EncodedContraints a b c
V Int
n Int
i Int
j
setIEl Int
i (W Int
n Int
_ Int
j) = forall a b c. a -> a -> a -> EncodedContraints a b c
W Int
n Int
i Int
j
setIEl Int
i (H Int
n Int
_ Int
j Int
k) = forall a b c. a -> a -> a -> a -> EncodedContraints a b c
H Int
n Int
i Int
j Int
k
setIEl Int
i (R Int
n Int
_ Int
j Int
k) = forall a b c. a -> a -> a -> a -> EncodedContraints a b c
R Int
n Int
i Int
j Int
k
setIEl Int
i (M Int
n Int
_ Int
j Int
k) = forall a b c. a -> a -> a -> a -> EncodedContraints a b c
M Int
n Int
i Int
j Int
k
setIEl Int
i (N Int
n Array Int (Int, Int)
arr) = forall a b c. a -> c -> EncodedContraints a b c
N Int
n Array Int (Int, Int)
arr
setIEl Int
i (D Int
n Int
_ Int
j Int
k) = forall a b c. a -> a -> a -> a -> EncodedContraints a b c
D Int
n Int
i Int
j Int
k
setIEl Int
i (I Int
n Int
_ Int
j Int
k) = forall a b c. a -> a -> a -> a -> EncodedContraints a b c
I Int
n Int
i Int
j Int
k