bringing permutation-minimal up to date

.hlint.yaml

@@ -0,0 +1,6 @@
+- ignore: {name: Use camelCase}
+- ignore: {name: Reduce duplication}
+- ignore: {name: Use &&}
+- ignore: {name: Use ++}
+- ignore: {name: Redundant return}
+- ignore: {name: Monad law, left identity}

.vscode/settings.json

@@ -0,0 +1,5 @@
+{
+    "haskell.plugin.hlint.config.flags": [
+        "--hint=.hlint.yaml"
+    ],
+}

Makefile

@@ -71,6 +71,7 @@ test:
 		stack test --test-arguments '--hide-successes --limit-time ${LIMIT_TIME}';\
 	fi
 
+.PHONY: stack.yaml
 stack.yaml: etc/hs-deps/stack-${GHC_VERSION}.yaml
 	@cp etc/hs-deps/stack-${GHC_VERSION}.yaml stack.yaml
 

conjure-cp.cabal

@@ -20,6 +20,8 @@ Library
                      , Conjure.Bug
                      , Conjure.UserError
 
+                     , Conjure.Util.Permutation
+
                      -- definitions of language constructs
                      , Conjure.Language
                      , Conjure.Language.AbstractLiteral
@@ -59,8 +61,10 @@ Library
                      , Conjure.Language.Expression.Op.Apart
                      , Conjure.Language.Expression.Op.AtLeast
                      , Conjure.Language.Expression.Op.AtMost
+                     , Conjure.Language.Expression.Op.Compose
                      , Conjure.Language.Expression.Op.AttributeAsConstraint
                      , Conjure.Language.Expression.Op.CatchUndef
+                     , Conjure.Language.Expression.Op.QuickPermutationOrder
                      , Conjure.Language.Expression.Op.Defined
                      , Conjure.Language.Expression.Op.Div
                      , Conjure.Language.Expression.Op.DontCare
@@ -98,6 +102,7 @@ Library
                      , Conjure.Language.Expression.Op.Participants
                      , Conjure.Language.Expression.Op.Parts
                      , Conjure.Language.Expression.Op.Party
+                     , Conjure.Language.Expression.Op.PermInverse
                      , Conjure.Language.Expression.Op.Pow
                      , Conjure.Language.Expression.Op.PowerSet
                      , Conjure.Language.Expression.Op.Pred
@@ -186,6 +191,7 @@ Library
                      , Conjure.Representations.Function.FunctionNDPartialDummy
                      , Conjure.Representations.Function.FunctionAsRelation
                      , Conjure.Representations.Sequence.ExplicitBounded
+                     , Conjure.Representations.Permutation.PermutationAsFunction
                      , Conjure.Representations.Relation.RelationAsMatrix
                      , Conjure.Representations.Relation.RelationAsSet
                      , Conjure.Representations.Partition.Occurrence
@@ -233,6 +239,9 @@ Library
 
                      , Conjure.Rules.Transform
 
+                     , Conjure.Rules.Horizontal.Permutation
+                     , Conjure.Rules.Vertical.Permutation.PermutationAsFunction
+
                      , Conjure.Rules.BubbleUp
                      , Conjure.Rules.DontCare
                      , Conjure.Rules.TildeOrdering

docs/conjure-help.html

@@ -40,6 +40,7 @@
 <tr><td style='padding-left:2ex;'>&nbsp;<td style='padding-left:1ex; white-space:nowrap;'>--representations-cuts=STRATEGY</td><td style='padding-left:2ex;'>Strategy for choosing a representation for cuts in 'branching on'.<br />Default value: same as --representations</td></tr>
 <tr><td style='padding-left:2ex;'>&nbsp;<td style='padding-left:1ex; white-space:nowrap;'>--channelling</td><td style='padding-left:2ex;'>Whether to produce channelled models (true by default).<br /></td></tr>
 <tr><td style='padding-left:2ex;'>&nbsp;<td style='padding-left:1ex; white-space:nowrap;'>--representation-levels</td><td style='padding-left:2ex;'>Whether to use built-in precedence levels when choosing representations. Used to cut down the number of generated models.<br />Default: true</td></tr>
+<tr><td style='padding-left:2ex;'>&nbsp;<td style='padding-left:1ex; white-space:nowrap;'>--unnamed-symmetry-breaking=ITEM</td><td style='padding-left:2ex;'>Level to use for breaking symmetries arising from unnamed types. Options: none / fast-consecutive / fast-allpairs / complete-independently / complete.<br />Default: none</td></tr>
 <tr><td style='padding-left:2ex;'>&nbsp;<td style='padding-left:1ex; white-space:nowrap;'>--follow-model=ITEM</td><td style='padding-left:2ex;'>Provide a Conjure-generated Essence Prime model to be used as a guide during model generation. Conjure will try to imitate the modelling decisions from this file.</td></tr>
 <tr><td style='padding-left:2ex;'>&nbsp;<td style='padding-left:1ex; white-space:nowrap;'>--seed=INT</td><td style='padding-left:2ex;'>Random number generator seed.</td></tr>
 <tr><td style='padding-left:2ex;'>&nbsp;<td style='padding-left:1ex; white-space:nowrap;'>--limit-models=INT</td><td style='padding-left:2ex;'>Maximum number of models to generate.</td></tr>
@@ -130,6 +131,7 @@
 <tr><td style='padding-left:2ex;'>&nbsp;<td style='padding-left:1ex; white-space:nowrap;'>--representations-cuts=STRATEGY</td><td style='padding-left:2ex;'>Strategy for choosing a representation for cuts in 'branching on'.<br />Default value: same as --representations</td></tr>
 <tr><td style='padding-left:2ex;'>&nbsp;<td style='padding-left:1ex; white-space:nowrap;'>--channelling</td><td style='padding-left:2ex;'>Whether to produce channelled models (true by default).<br /></td></tr>
 <tr><td style='padding-left:2ex;'>&nbsp;<td style='padding-left:1ex; white-space:nowrap;'>--representation-levels</td><td style='padding-left:2ex;'>Whether to use built-in precedence levels when choosing representations. Used to cut down the number of generated models.<br />Default: true</td></tr>
+<tr><td style='padding-left:2ex;'>&nbsp;<td style='padding-left:1ex; white-space:nowrap;'>--unnamed-symmetry-breaking=ITEM</td><td style='padding-left:2ex;'>Level to use for breaking symmetries arising from unnamed types. Options: none / fast-consecutive / fast-allpairs / complete-independently / complete.<br />Default: none</td></tr>
 <tr><td style='padding-left:2ex;'>&nbsp;<td style='padding-left:1ex; white-space:nowrap;'>--follow-model=ITEM</td><td style='padding-left:2ex;'>Provide a Conjure-generated Essence Prime model to be used as a guide during model generation. Conjure will try to imitate the modelling decisions from this file.</td></tr>
 <tr><td style='padding-left:2ex;'>&nbsp;<td style='padding-left:1ex; white-space:nowrap;'>--seed=INT</td><td style='padding-left:2ex;'>Random number generator seed.</td></tr>
 <tr><td style='padding-left:2ex;'>&nbsp;<td style='padding-left:1ex; white-space:nowrap;'>--limit-models=INT</td><td style='padding-left:2ex;'>Maximum number of models to generate.</td></tr>

docs/conjure-help.txt

@@ -80,6 +80,10 @@
       --representation-levels                 Whether to use built-in precedence levels when choosing representations.
                                               Used to cut down the number of generated models.
                                               Default: true
+      --unnamed-symmetry-breaking=ITEM        Level to use for breaking symmetries arising from unnamed types.
+                                              Options: none / fast-consecutive / fast-allpairs / complete-independently
+                                              / complete.
+                                              Default: none
       --follow-model=ITEM                     Provide a Conjure-generated Essence Prime model to be used as a guide
                                               during model generation. Conjure will try to imitate the modelling
                                               decisions from this file.
@@ -252,6 +256,10 @@
       --representation-levels                 Whether to use built-in precedence levels when choosing representations.
                                               Used to cut down the number of generated models.
                                               Default: true
+      --unnamed-symmetry-breaking=ITEM        Level to use for breaking symmetries arising from unnamed types.
+                                              Options: none / fast-consecutive / fast-allpairs / complete-independently
+                                              / complete.
+                                              Default: none
       --follow-model=ITEM                     Provide a Conjure-generated Essence Prime model to be used as a guide
                                               during model generation. Conjure will try to imitate the modelling
                                               decisions from this file.

etc/build/gen_Operator.hs

@@ -66,6 +66,7 @@ main = do
 
             , [ ""
               , "instance ( Pretty x"
+              , "         , Data x"
               , "         , ExpressionLike x"
               , "         , ReferenceContainer x"
               , "         , TypeOf x"

src/Conjure/Compute/DomainOf.hs

@@ -108,6 +108,7 @@ instance (DomainOf x, TypeOf x, Pretty x, ExpressionLike x, Domain () x :< x, Do
     domainOf (MkOpAllDiffExcept x) = domainOf x
     domainOf (MkOpAnd x) = domainOf x
     domainOf (MkOpApart x) = domainOf x
+    domainOf (MkOpCompose x) = domainOf x
     domainOf (MkOpAtLeast x) = domainOf x
     domainOf (MkOpAtMost x) = domainOf x
     domainOf (MkOpAttributeAsConstraint x) = domainOf x
@@ -149,6 +150,7 @@ instance (DomainOf x, TypeOf x, Pretty x, ExpressionLike x, Domain () x :< x, Do
     domainOf (MkOpParticipants x) = domainOf x
     domainOf (MkOpParts x) = domainOf x
     domainOf (MkOpParty x) = domainOf x
+    domainOf (MkOpPermInverse x) = domainOf x
     domainOf (MkOpPow x) = domainOf x
     domainOf (MkOpPowerSet x) = domainOf x
     domainOf (MkOpPred x) = domainOf x
@@ -179,12 +181,14 @@ instance (DomainOf x, TypeOf x, Pretty x, ExpressionLike x, Domain () x :< x, Do
     domainOf (MkOpTwoBars x) = domainOf x
     domainOf (MkOpUnion x) = domainOf x
     domainOf (MkOpXor x) = domainOf x
+    domainOf (MkOpQuickPermutationOrder x) = domainOf x
 
     indexDomainsOf (MkOpActive x) = indexDomainsOf x
     indexDomainsOf (MkOpAllDiff x) = indexDomainsOf x
     indexDomainsOf (MkOpAllDiffExcept x) = indexDomainsOf x
     indexDomainsOf (MkOpAnd x) = indexDomainsOf x
     indexDomainsOf (MkOpApart x) = indexDomainsOf x
+    indexDomainsOf (MkOpCompose x) = indexDomainsOf x
     indexDomainsOf (MkOpAtLeast x) = indexDomainsOf x
     indexDomainsOf (MkOpAtMost x) = indexDomainsOf x
     indexDomainsOf (MkOpAttributeAsConstraint x) = indexDomainsOf x
@@ -226,6 +230,7 @@ instance (DomainOf x, TypeOf x, Pretty x, ExpressionLike x, Domain () x :< x, Do
     indexDomainsOf (MkOpParticipants x) = indexDomainsOf x
     indexDomainsOf (MkOpParts x) = indexDomainsOf x
     indexDomainsOf (MkOpParty x) = indexDomainsOf x
+    indexDomainsOf (MkOpPermInverse x) = indexDomainsOf x
     indexDomainsOf (MkOpPow x) = indexDomainsOf x
     indexDomainsOf (MkOpPowerSet x) = indexDomainsOf x
     indexDomainsOf (MkOpPred x) = indexDomainsOf x
@@ -256,6 +261,7 @@ instance (DomainOf x, TypeOf x, Pretty x, ExpressionLike x, Domain () x :< x, Do
     indexDomainsOf (MkOpTwoBars x) = indexDomainsOf x
     indexDomainsOf (MkOpUnion x) = indexDomainsOf x
     indexDomainsOf (MkOpXor x) = indexDomainsOf x
+    indexDomainsOf (MkOpQuickPermutationOrder x) = indexDomainsOf x
 
 instance DomainOf Constant where
     domainOf ConstantBool{}             = return DomainBool
@@ -330,12 +336,14 @@ instance DomainOf (AbstractLiteral Expression) where
         where attr = PartitionAttr (SizeAttr_MaxSize (fromInt $ genericLength xss))
                                    (SizeAttr_MaxSize (fromInt $ maximum [genericLength xs | xs <- xss]))
                                    False
-
+    domainOf (AbsLitPermutation [] ) = return $ DomainPermutation def (PermutationAttr SizeAttr_None) (DomainAny "domainOf-AbsLitPermutation-[]" TypeAny)
+    domainOf (AbsLitPermutation xss) = DomainPermutation def (PermutationAttr SizeAttr_None) <$> (domainUnions =<< mapM domainOf (concat xss))
     indexDomainsOf (AbsLitMatrix ind inn) = (ind :) <$> (mapM domainUnions =<< mapM indexDomainsOf inn)
     indexDomainsOf _ = return []
 
 
 
+
 -- all the `Op`s
 
 instance DomainOf (OpActive x) where
@@ -420,7 +428,8 @@ instance (Pretty x, TypeOf x, DomainOf x) => DomainOf (OpImage x) where
         case fDomain of
             DomainFunction _ _ _ to -> return to
             DomainSequence _ _ to -> return to
-            _ -> failDoc "domainOf, OpImage, not a function or sequence"
+            DomainPermutation _ _ ov -> return ov
+            _ -> failDoc "domainOf, OpImage, not a function, sequence or permutation"
 
 instance (Pretty x, TypeOf x) => DomainOf (OpImageSet x) where
     domainOf op = mkDomainAny ("OpImageSet:" <++> pretty op) <$> typeOf op
@@ -550,6 +559,12 @@ instance DomainOf x => DomainOf (OpParts x) where
 instance (Pretty x, TypeOf x) => DomainOf (OpParty x) where
     domainOf op = mkDomainAny ("OpParty:" <++> pretty op) <$> typeOf op
 
+instance (Pretty x, TypeOf x) => DomainOf (OpPermInverse x) where
+    domainOf op = mkDomainAny ("OpPermInverse:" <++> pretty op) <$> typeOf op
+
+instance (Pretty x, TypeOf x) => DomainOf (OpCompose x) where
+    domainOf op = mkDomainAny ("OpCompose:" <++> pretty op) <$> typeOf op
+
 instance (Pretty x, TypeOf x) => DomainOf (OpPow x) where
     domainOf op = mkDomainAny ("OpPow:" <++> pretty op) <$> typeOf op
 
@@ -682,3 +697,5 @@ instance (Pretty x, TypeOf x, Domain () x :< x) => DomainOf (OpTwoBars x) where
 instance (Pretty x, TypeOf x) => DomainOf (OpUnion x) where
     domainOf op = mkDomainAny ("OpUnion:" <++> pretty op) <$> typeOf op
 
+instance DomainOf (OpQuickPermutationOrder x) where
+    domainOf _ = return DomainBool