diff --git a/Common/Id.hs b/Common/Id.hs index 1e26c07c71..a9d6b16238 100644 --- a/Common/Id.hs +++ b/Common/Id.hs @@ -91,7 +91,7 @@ data Token = Token { tokStr :: String } deriving (Eq, Ord, Typeable, Data) instance Show Token where - show = tokStr + show x = "(mkSimpleId "++['"'] ++ (tokStr x) ++ ['"'] ++ ")" instance Read Token where readsPrec i = map (\ (a, r) -> (mkSimpleId a, r)) . readsPrec i diff --git a/CommonLogic/Morphism.hs b/CommonLogic/Morphism.hs index 99e52fcf52..4dfac6a963 100644 --- a/CommonLogic/Morphism.hs +++ b/CommonLogic/Morphism.hs @@ -197,3 +197,6 @@ morphismUnion mor1 mor2 = { source = unite p1 p2 , target = unite (target mor1) $ target mor2 , propMap = pmap } else Result pds Nothing + + + diff --git a/Comorphisms/LogicGraph.hs b/Comorphisms/LogicGraph.hs index 43178e4c04..731d0bda95 100644 --- a/Comorphisms/LogicGraph.hs +++ b/Comorphisms/LogicGraph.hs @@ -89,6 +89,7 @@ import Comorphisms.QVTR2CASL import Comorphisms.CASL2Hybrid import Comorphisms.Hybrid2CASL +import Comorphisms.UML_CD2CL #ifdef CASLEXTENSIONS import Comorphisms.CoCFOL2IsabelleHOL @@ -244,7 +245,8 @@ comorphismList = , Comorphism QBF2Prop , Comorphism Prop2QBF , Comorphism CSMOF2CASL - , Comorphism QVTR2CASL ] + , Comorphism QVTR2CASL + , Comorphism UML_CD2CL] inclusionList :: [AnyComorphism] inclusionList = diff --git a/Comorphisms/LogicList.hs b/Comorphisms/LogicList.hs index ea58d5a760..bd392786c5 100644 --- a/Comorphisms/LogicList.hs +++ b/Comorphisms/LogicList.hs @@ -86,6 +86,7 @@ import OWL2.Logic_OWL2 import RDF.Logic_RDF #endif import Comorphisms.DynLogicList +import UML.Logic_UML import NeSyPatterns.Logic_NeSyPatterns logicList :: [AnyLogic] @@ -136,6 +137,7 @@ logicList = #endif , Logic CSMOF , Logic QVTR + , Logic UML , Logic NeSyPatterns ] ++ dynLogicList diff --git a/Comorphisms/UML_CD2CL.hs b/Comorphisms/UML_CD2CL.hs new file mode 100644 index 0000000000..fefe1b8912 --- /dev/null +++ b/Comorphisms/UML_CD2CL.hs @@ -0,0 +1,114 @@ +{-# LANGUAGE TypeSynonymInstances, FlexibleInstances, MultiParamTypeClasses #-} +module Comorphisms.UML_CD2CL where + +import Common.ProofTree +import Common.Result +import Common.Id +import Common.AS_Annotation + +import Logic.Logic +import Logic.Comorphism + +import UML.Sign +import UML.Logic_UML +import UML.UML hiding (Id) +import UML.UML2CL +import UML.UML2CL_preamble +import UML.Morphism + +import CommonLogic.Sign as CL_Sign +import CommonLogic.Logic_CommonLogic +import CommonLogic.AS_CommonLogic as As_CL +import CommonLogic.Symbol as Symbol +import CommonLogic.ATC_CommonLogic () +import CommonLogic.Sublogic +import CommonLogic.Morphism +import CommonLogic.Analysis + +import qualified Data.Map as Map +import qualified Data.Set as Set +-- | lid of the morphism +data UML_CD2CL = UML_CD2CL deriving Show + +instance Language UML_CD2CL where + language_name UML_CD2CL = "UML2CommonLogic" + +instance Comorphism UML_CD2CL + UML.Logic_UML.UML + () -- Sublogics + UML.UML.CM -- basic_spec + UML.Sign.Sen -- sentence + () -- symb_items + () -- symb_map_items + UML.Sign.Sign -- sign + UML.Morphism.Morphism -- morphism + () -- symbol + () -- raw_symbol + () -- proof_tree + CommonLogic.Logic_CommonLogic.CommonLogic + CommonLogicSL -- Sublogics + BASIC_SPEC -- basic_spec + TEXT_META -- sentence + SYMB_ITEMS -- symb_items + SYMB_MAP_ITEMS -- symb_map_items + CL_Sign.Sign -- sign + CommonLogic.Morphism.Morphism -- morphism + Symbol -- symbol + Symbol -- raw_symbol + ProofTree -- proof_tree + where + sourceLogic UML_CD2CL = UML.Logic_UML.UML + targetLogic UML_CD2CL = CommonLogic.Logic_CommonLogic.CommonLogic + map_theory UML_CD2CL = mapTheory + map_morphism UML_CD2CL = mapMor + +mapTheory :: (UML.Sign.Sign, [Named Sen]) -> Result (CL_Sign.Sign, [Named TEXT_META]) +mapTheory (sign, sens) = let + sg = (mapSign sign) + t = (translateSign2Phrases sign) + tmSyms = (Set.fromList $ map symName $ foldl (++) [] $ map (symsOfTextMeta.sentence) tms) Set.\\ (allItems sg) + sg2 = CL_Sign.Sign{ discourseNames = Set.union (discourseNames sg) tmSyms, + CL_Sign.nondiscourseNames = CL_Sign.nondiscourseNames sg, + sequenceMarkers = sequenceMarkers sg} + tms = (map (makeNamedSen.emptyAnno) t) ++ (map (mapNamed $ mapSen) sens) + in return (sg2 , tms) + + +mapSen :: UML.Sign.Sen -> TEXT_META +mapSen mf = Text_meta{ As_CL.getText = Text phrases nullRange + , As_CL.textIri = Nothing + , As_CL.nondiscourseNames = Nothing + , As_CL.prefix_map = [] } + where phrases = (Sentence (translateMult2Sen mf)):[]--(translateSign2Phrases sign) + + +mapSign :: UML.Sign.Sign -> CL_Sign.Sign +mapSign sign = CL_Sign.Sign{ + CL_Sign.discourseNames = Set.union (Set.fromList ((map (stringToId.showClassEntityName) $ fst $ signClassHier sign) + ++ (map (stringToId.literalName) $ foldl (++) [] (map enumLiterals $ filterEnums $ fst $ signClassHier sign)) + ++ (map morphTranslateAttr (signAttribute sign)) + ++ (foldl (++) [] $ map morphTranslateOper (signOperations sign)) + ++ (map morphTranslateComp (signCompositions sign)) + ++ (foldl (++) [] $ map morphTranslateAsso (signAssociations sign)))) (foldl (Set.union) Set.empty preambleDiscourseNames), + CL_Sign.nondiscourseNames = (foldl (Set.union) Set.empty preambleNonDiscourseNames), + CL_Sign.sequenceMarkers = (foldl (Set.union) Set.empty preambleSequenceMarkers) +} + +morphTranslateAttr :: (Class,String,Type) -> Id +morphTranslateAttr (c,s,_) = (stringToId $ className c ++ "." ++ s) + +morphTranslateComp :: ((String,ClassEntity),String,(String,Type)) -> Id +morphTranslateComp ((_,_),n,(_,_)) = stringToId n + +morphTranslateAsso :: (String,[(String,Type)]) -> [Id] +morphTranslateAsso (n,endL) = (stringToId n):(map (stringToId.fst) endL) + +morphTranslateOper :: (Class,String,[(String,Type)],Type) -> [Id] +morphTranslateOper (c,n,para,_) = (stringToId $ (className c) ++ "." ++ n):(map (stringToId.fst) para) + +mapMor :: UML.Morphism.Morphism -> Result CommonLogic.Morphism.Morphism +mapMor m = return CommonLogic.Morphism.Morphism + { CommonLogic.Morphism.source = mapSign $ UML.Morphism.source m + , CommonLogic.Morphism.target = mapSign $ UML.Morphism.target m + , CommonLogic.Morphism.propMap = Map.empty + } diff --git a/Driver/Options.hs b/Driver/Options.hs index 066261e506..2af904bc34 100644 --- a/Driver/Options.hs +++ b/Driver/Options.hs @@ -539,6 +539,7 @@ data InType = | CommonLogicIn Bool -- ^ "clf" or "clif" ('True' is long version) | DgXml | Xmi + | UMLCDXmi | Qvt | TPTPIn | HtmlIn -- just to complain @@ -570,6 +571,7 @@ instance Show InType where Xmi -> "xmi" Qvt -> "qvt" HtmlIn -> "html" + UMLCDXmi -> "UMLCD" -- maybe this optional tree prefix can be omitted instance Read InType where diff --git a/Driver/ReadFn.hs b/Driver/ReadFn.hs index 437e013ac7..02c72173d3 100644 --- a/Driver/ReadFn.hs +++ b/Driver/ReadFn.hs @@ -57,6 +57,8 @@ import Data.Char (isSpace) import Data.List (isPrefixOf) import Data.Maybe +import UML.Parser + noPrefix :: QName -> Bool noPrefix = isNothing . qPrefix @@ -69,6 +71,9 @@ isPpXml q = qName q == "Lib" && noPrefix q isDMU :: QName -> Bool isDMU q = qName q == "ClashResult" && noPrefix q +isXMI :: QName -> Bool +isXMI q = qName q == "XMI" + isRDF :: QName -> Bool isRDF q = qName q == "RDF" && qPrefix q == Just "rdf" @@ -87,9 +92,14 @@ guessXmlContent isXml str = case dropWhile isSpace str of | isDMU q -> Left "unexpected DMU xml format" | isPpXml q -> Left "unexpected pp.xml format" | null (qName q) || not isXml -> Right GuessIn + | isUMLCDroot e-> Right UMLCDXmi | otherwise -> Left $ "unknown XML format: " ++ tagEnd q "" _ -> Right GuessIn -- assume that it is no xml content +isUMLCDroot :: Element -> Bool +isUMLCDroot el0 = not $ isNothing $ findModelElement el0 + + isDgXmlFile :: HetcatsOpts -> FilePath -> String -> Bool isDgXmlFile opts file content = guess file (intype opts) == DgXml && guessXmlContent True content == Right DgXml diff --git a/Driver/ReadLibDefn.hs b/Driver/ReadLibDefn.hs index 0f28ebc439..c8416875e3 100644 --- a/Driver/ReadLibDefn.hs +++ b/Driver/ReadLibDefn.hs @@ -34,6 +34,7 @@ import QVTR.ParseQvtAsLibDefn import TPTP.ParseAsLibDefn import FreeCAD.Logic_FreeCAD +import Data.Maybe import Driver.Options import Driver.ReadFn @@ -42,11 +43,15 @@ import Common.Result import Common.ResultT import Text.ParserCombinators.Parsec +import Text.XML.Light import Control.Monad.Trans (MonadIO (..)) import qualified Control.Monad.Fail as Fail import Data.List +import UML.ParseUMLAsLibDefn +import UML.Parser + mimeTypeMap :: [(String, InType)] mimeTypeMap = [ ("xml", DgXml) @@ -96,8 +101,12 @@ guessInput opts mr file input = _ -> return $ joinFileTypes fty ty else return fty +isUMLCDroot :: Element -> Bool +isUMLCDroot el0 = not $ isNothing $ findModelElement el0 + readLibDefn :: LogicGraph -> HetcatsOpts -> Maybe String -> FilePath -> FilePath -> String -> ResultT IO [LIB_DEFN] + readLibDefn lgraph opts mr file fileForPos input = if null input then Fail.fail ("empty input file: " ++ file) else case intype opts of @@ -112,7 +121,12 @@ readLibDefn lgraph opts mr file fileForPos input = #ifdef RDFLOGIC -- RDFIn -> liftIO $ parseRDF file #endif - Xmi -> return [parseXmi file input] + UMLCDXmi -> liftIO $ fmap (: []) $ parseUMLCDasLibDefn file + Xmi -> liftIO $ fmap (: []) $ case parseXMLDoc input of + Nothing -> error "empty XMI" + Just e -> case isUMLCDroot e of + True -> parseUMLCDasLibDefn file + False -> parseXmi file input Qvt -> liftIO $ fmap (: []) $ parseQvt file input TPTPIn -> parseTPTP opts file input #ifndef NOOWLLOGIC diff --git a/Makefile b/Makefile index d050b25cfc..eb9eb9de8b 100755 --- a/Makefile +++ b/Makefile @@ -120,7 +120,7 @@ logics = CASL HasCASL Isabelle Modal Hybrid TopHybrid Temporal \ CoCASL COL CspCASL CASL_DL \ SoftFOL ConstraintCASL Propositional RelationalScheme VSE OMDoc DFOL \ LF Framework Maude ExtModal CommonLogic CSL QBF Adl HolLight Fpl THF \ - FreeCAD OWL2 RDF CSMOF QVTR TPTP NeSyPatterns + FreeCAD OWL2 RDF CSMOF QVTR TPTP UML NeSyPatterns TESTTARGETFILES += Scratch.hs CASL/fromKif.hs CASL/capa.hs HasCASL/hacapa.hs \ Haskell/wrap.hs Isabelle/isa.hs Syntax/hetpa.hs \ @@ -362,6 +362,8 @@ RDF_files = RDF/AS.hs RDF/Symbols.hs RDF/Sign.hs RDF/Morphism.hs \ CSMOF_files = CSMOF/As.hs CSMOF/Sign.hs +UML_files = UML/UML.hs UML/Sign.hs UML/Morphism.hs UML/StateMachine.hs + QVTR_files = QVTR/As.hs QVTR/Sign.hs TPTP_files = TPTP/AS.hs TPTP/Sign.hs TPTP/Sublogic.hs @@ -471,6 +473,9 @@ RDF/ATC_RDF.der.hs: $(RDF_files) $(GENRULES) CSMOF/ATC_CSMOF.der.hs: $(CSMOF_files) $(GENRULES) $(GENRULECALL) -i Common.ATerm.ConvInstances -i Common.Json.ConvInstances -o $@ $(CSMOF_files) +UML/ATC_UML.der.hs: $(UML_files) $(GENRULES) + $(GENRULECALL) -i Common.ATerm.ConvInstances -o $@ $(UML_files) + QVTR/ATC_QVTR.der.hs: $(QVTR_files) CSMOF/ATC_CSMOF.hs $(GENRULES) $(GENRULECALL) -i CSMOF.ATC_CSMOF -i Common.ATerm.ConvInstances -i Common.Json.ConvInstances \ -o $@ $(QVTR_files) diff --git a/OWL2/java/lib/trove4j-3.0.3.jar b/OWL2/java/lib/trove4j-3.0.3.jar deleted file mode 100644 index cd00f93e0a..0000000000 Binary files a/OWL2/java/lib/trove4j-3.0.3.jar and /dev/null differ diff --git a/OWL2/java/lib/uk.ac.manchester.cs.owl.factplusplus-P5.0-v1.6.3.1.jar b/OWL2/java/lib/uk.ac.manchester.cs.owl.factplusplus-P5.0-v1.6.3.1.jar deleted file mode 100644 index d66de16db6..0000000000 Binary files a/OWL2/java/lib/uk.ac.manchester.cs.owl.factplusplus-P5.0-v1.6.3.1.jar and /dev/null differ diff --git a/UML/ClassDiagramParser.hs b/UML/ClassDiagramParser.hs new file mode 100644 index 0000000000..f8ab151777 --- /dev/null +++ b/UML/ClassDiagramParser.hs @@ -0,0 +1,363 @@ +{- | +Description : XMI parser for UML Class Diagrams +Copyright : (c) Martin Glauer + +Maintainer : martin.glauer@st.ovgu.de +Stability : experimental + +-} + +-- |This module implements a parser from xmi to a single UML Class Model +module UML.ClassDiagramParser where + +import Data.List +import qualified Data.Map as Map +import Data.Maybe +import Text.XML.Light +import UML.UML +import UML.Utils +import UML.XMINames + +-- |Constructs the UML model. Assumes that the the passed element is the root +-- of the xml model description +parseClassModel :: String -- ^ The prefix of used by the uml namespace + -> (Maybe String, Maybe String) -- ^ xmi version + -> Element -- ^ the xml element to parse + -> Model +parseClassModel prefix (xmiv, _) el = ClassModel CM { + cmName = fromMaybe "unnamed" (findAttr nameName el), + cmClasses = classes pack, + cmAssociations = associations pack, + cmInterfaces = interfaces pack, + cmPackageMerges = packageMerges pack, + cmSignals = signals pack, + cmAssociationClasses = packageAssociationClasses pack, + cmPackages = packagePackages pack, + cmEnums = packageEnums pack + } + where + pack = processPackage prefix xmiv allmap semap el + allmap = Map.union emap $ Map.union cmap acmap + cmap = Map.fromList $ ((map (\ (id1, x) -> (id1, CL x)) + (collectRec prefix xmiv (prefix ++ ":Class") + (processClass xmiv allmap) el)) ++ (map (\ (id1, x) -> (id1, DT x)) + (collectRec prefix xmiv (prefix ++ ":DataType") + (processDatatype xmiv allmap) el))) + emap = Map.fromList $ map (\ (id1, x) -> (id1, EN x)) + (collectRec prefix xmiv (prefix ++ ":Enumeration") + (processEnumeration xmiv) el) + acmap = Map.fromList $ (map (\ (id1, x) -> (id1, AC x)) + (collectRec prefix xmiv (prefix ++ ":AssociationClass") + (processAssociationClass xmiv + (Map.union cmap emap) semap) el)) + semapraw = collectSpecialEnds prefix xmiv allmap el + semap = (Map.fromList + [( id1, + [x | (id2, x) <- semapraw, id1 == id2]) + | id1 <- (Map.keys (Map.fromList semapraw))]) + +-- |Constructs the Package structure for an element that is an UML Package + +processPackage :: String -> Maybe String -> Map.Map Id ClassEntity + -> Map.Map Id [End] -> Element -> Package +processPackage prefix xmiv cmap semap el = Package { + packageName = fromMaybe "" (findAttr nameName el), + classes = Map.fromList $ map (\ (id1, CL x) -> (id1, x)) + (map ( (\ x -> (x, fromJust (Map.lookup x cmap))) + . (fromJust . (findAttr (attrIdName xmiv)))) + (getChildrenType xmiv (prefix ++ ":Class") el)), + associations = Map.fromList (parse xmiv (prefix ++ ":Association") + (processAssociation xmiv cmap semap) lis), + interfaces = Map.fromList (parse xmiv (prefix ++ ":Interface") + (processInterface xmiv) lis), + packageMerges = map (fromMaybe "" . findAttr + (sName "mergedPackage")) + (findChildren (sName "packageMerge") el), + packageAssociationClasses = Map.fromList + $ map (\ (id1, AC x) -> (id1, x)) + (map ((\ x -> (x, fromJust (Map.lookup x cmap))) . + (fromJust . (findAttr (attrIdName xmiv)))) + (findChildren (sName (prefix ++ ":AssociationClass")) el)), + packageEnums = Map.fromList + $ filterFromEntityMap xmiv cmap + (\ (EN x) -> x) + (getChildrenType xmiv (prefix ++ ":Enumeration") el), + signals = Map.fromList (parse xmiv (prefix ++ ":Signal") + (processSignal xmiv cmap) lis), + packagePackages = parse xmiv (prefix ++ ":Package") + (processPackage prefix xmiv cmap semap) lis + } + where lis = (findChildren packagedElementName el) + +-- | takes the ids of the passed element list, pairs them with the corresponding +-- class entities and applies the given function to ce. +filterFromEntityMap :: Maybe String + -> (Map.Map Id ClassEntity) -- ^ ce dictionary + -> (ClassEntity -> t) -- ^ a mapping ce -> t + -> [Element] + -> [(Id, t)] +filterFromEntityMap xmiv emap f lis = --map (\ (id1, x) -> (id1, f x)) + (map ((\ x -> (x, f $ fromJust (Map.lookup x emap))) . + (fromJust . (findAttr (attrIdName xmiv)))) lis) + +-- |Collects the children of all given elements that are UML Packages +findPackageElements :: String -> Maybe String -> Element -> [Element] +findPackageElements prefix xmiv el = filter (\ x -> findAttr (typeName xmiv) x == + Just (prefix ++ ":Package")) (findChildren packagedElementName el) + + +collectRec :: String -> Maybe String -> String -> (Element -> (s, t)) + -> Element -> [(s, t)] +collectRec prefix xmiv s f el = + (parse xmiv s f (findChildren packagedElementName el)) + ++ (foldl (++) [] (map (collectRec prefix xmiv s f) + (findPackageElements prefix xmiv el))) + + +collectSpecialEnds :: String -> Maybe String -> Map.Map Id ClassEntity + -> Element -> [(Id, End)] +collectSpecialEnds prefix xmiv cmap el = + (foldl (++) [] (map (classSETranslator cmap) cl)) + ++ (foldl (++) [] (map (collectSpecialEnds prefix xmiv cmap) + (findPackageElements prefix xmiv el))) + where cl = getChildrenType xmiv (prefix ++ ":Class") el + +getChildrenType :: Maybe String -> String -> Element -> [Element] +getChildrenType xmiv s el = + filter (\ x -> (findAttr (typeName xmiv) x) == Just s) + (findChildren packagedElementName el) + +classSETranslator :: Map.Map Id ClassEntity -> Element -> [(Id, End)] +classSETranslator cmap x = + map (agrTranslator cmap) (filter + (\ y -> not ((findAttr (sName "association") y) == Nothing)) + (findChildren attributeName x)) +--classSETranslator cmap x = map (agrTranslator cmap) (filter (\x -> not ((findAttr (sName "aggregation") x) == Nothing)) (findChildren attributeName x)) + +agrTranslator :: Map.Map Id ClassEntity -> Element -> (Id, End) +agrTranslator cmap el = (fromMaybe (error "Aggregation w/o association") (findAttr (sName "association") el), + End { endTarget = fromMaybe (error $ "aggregated class not found: " ++ (show el)) (Map.lookup + (fromMaybe (error "Element w/o type") (findAttr (sName "type") el)) cmap), + label = processLabel el, + endType = case findAttr (sName "aggregation") el of + Just "composite" -> Composition + Just "aggregate" -> Aggregation + Nothing -> Normal + Just t -> error $ "unknown aggregation type: " ++ t, + endName = findAttr nameName el + }) + +processAssociation :: Maybe String -> Map.Map Id ClassEntity + -> Map.Map Id [End] -> Element -> (Id, Association) +processAssociation xmiv cmap semap el = + (aid, + Association {ends = (map (processEnds xmiv cmap) + (findChildren (sName "ownedEnd") el)) ++ fromMaybe [] + (Map.lookup aid semap), + assoName = an}) + where an = case (findAttr nameName el) of + Nothing -> aid + Just n -> n + aid = fromMaybe (error "Association without id") $ findAttr (attrIdName xmiv) el + +processEnds :: Maybe String -> Map.Map Id ClassEntity -> Element -> End +processEnds xmiv emap el = + End {endTarget = + (case (Map.lookup (fromMaybe (error "Element w/o type") (findAttr (sName "type") el)) emap) of + Just t -> t + Nothing -> error $ "Key " + ++ show (findAttr (sName "type") el) + ++ " not found in " + ++ (show emap) + ), label = processLabel el, endType = Normal, + endName = Just $ fromMaybe (fromMaybe (error "Element w/o id") $ findAttr (attrIdName xmiv) el) + $ (findAttr nameName el)} + + +processLabel :: Element -> Label +processLabel el = Label {upperValue = + case findChildren (sName "upperValue") el of + [] -> lv + (x : _) -> fromMaybe "*" (findAttr (sName "value") x), + lowerValue = lv} + where + lv = case findChildren (sName "lowerValue") el of + [] -> "1" + (x : _) -> + fromMaybe "1" (findAttr (sName "value") x) + +processClass :: Maybe String -> (Map.Map Id ClassEntity) + -> Element -> (Id, Class) +processClass xmiv emap el = (fromMaybe "" (findAttr (attrIdName xmiv) el) + , Class { + super = map (processGeneralization emap) + (findChildren generalizationName el), + className = fromMaybe "" ( findAttr nameName el), + attr = map (processAttribute emap) + (findChildren attributeName el), + proc = map (processProcedure emap) + (findChildren procedureName el)}) + +processDatatype :: Maybe String -> (Map.Map Id ClassEntity) + -> Element -> (Id, UML.UML.DataType) +processDatatype xmiv emap el = (fromMaybe "" (findAttr (attrIdName xmiv) el) + , UML.UML.DataType { + dtsuper = map (processGeneralization emap) + (findChildren generalizationName el), + dtName = fromMaybe "" ( findAttr nameName el), + dtattr = map (processAttribute emap) + (findChildren attributeName el), + dtproc = map (processProcedure emap) + (findChildren procedureName el)}) + +processAssociationClass :: Maybe String -> Map.Map Id ClassEntity + -> Map.Map Id [End] -> Element + -> (Id, AssociationClass) +processAssociationClass xmiv emap semap el = + (fromMaybe "" (findAttr (attrIdName xmiv) el) + , AssociationClass {acClass = snd (processClass xmiv emap el), + acAsso = snd (processAssociation xmiv emap semap el)}) + +processEnumeration :: Maybe String -> Element -> (Id, UML.UML.Enum) +processEnumeration xmiv el = (fromJust (findAttr (attrIdName xmiv) el), en) + where en = Enum {enumName = fromJust (findAttr nameName el), + enumLiterals = map snd $ map (processLiteral xmiv en) + (findChildren (sName "ownedLiteral") el)} + +processLiteral :: Maybe String -> UML.UML.Enum -> Element -> (Id, Literal) +processLiteral xmiv en el = + (fromJust (findAttr (attrIdName xmiv) el), + Literal { literalName = fromJust (findAttr nameName el), + literalOwner = en}) + +processSignal :: Maybe String -> (Map.Map Id ClassEntity) + -> Element -> (Id, Signal) +processSignal xmiv _ el = (fromMaybe "" (findAttr (attrIdName xmiv) el), + Signal { + signalName = (case findAttr nameName el of + Nothing -> show el + Just t -> t)}) + +processProcedure :: (Map.Map Id ClassEntity) -> Element -> Procedure +processProcedure emap el = Procedure { + procName = (case findAttr nameName el of + Nothing -> show el + Just t -> t), + procPara = (map (processAttribute emap) (filter (not . isReturnParameter) + (findChildren procParaName el))), + procReturnType = (case (filter (isReturnParameter) + (findChildren procParaName el)) of + [] -> Nothing + (x : _) -> Just $ processType emap x ), + procElemImports = map (fromMaybe "" . (findAttr (sName "importedElement"))) + (findChildren (sName "elementImport") el), + procPackImports = map (fromMaybe "" . (findAttr (sName "importedPackage"))) + (findChildren (sName "packageImport") el), + procVisibility = case (findChildren (sName "eAnnotations") el) of + (x : _) -> fromMaybe "" ((findAttr (sName "value")) + (head (findChildren (sName "defaultValue") + (head (filter (hasAttribute nameName "Visibility") + (findChildren (sName "contents") x)))))) + [] -> "" +} + +isReturnParameter :: Element -> Bool +isReturnParameter el = (findAttr procDirName el) == Just "return" + +hasAttribute :: QName -> String -> Element -> Bool +hasAttribute n s el = case (findAttr n el) of + Nothing -> False + Just t -> (s == t) + +processParameter :: (Map.Map Id ClassEntity) -> Element -> (String, Type) +processParameter emap el = (case findAttr nameName el of + Nothing -> show el + Just t -> t, + processType emap el ) + +processAttribute :: (Map.Map Id ClassEntity) -> Element -> Attribute +processAttribute emap el = Attribute {attrName = (case findAttr nameName el of + Nothing -> show el + Just t -> t), + attrType = processType emap el, + attrUpperValue = case (findChildren (sName "upperValue") el ) of + [] -> "1" + (x : _) -> fromMaybe "" (findAttr (sName "value") x), + attrLowerValue = case (findChildren (sName "lowerValue") el) of + [] -> "1" + (x : _) -> fromMaybe "1" (findAttr (sName "value") x), + attrVisibility = case (findChildren (sName "eAnnotations") el) of + (x : _) -> fromMaybe "" ((findAttr (sName "value")) + (head (findChildren (sName "defaultValue") + (head (filter (hasAttribute nameName "Visibility") + (findChildren (sName "contents") x)))))) + [] -> ""} + +processType :: (Map.Map Id ClassEntity) -> Element -> Type +processType cmap el = Type {umltype = t, + typeUnique = not $ (findAttr (sName "isUnique") el) == Just "false", + typeOrdered = (findAttr (sName "isOrdered") el) == Just "true"} -- Defaults: Unique = True, Ordered = False + where + t = case stripPrefix + "pathmap://UML_LIBRARIES/UMLPrimitiveTypes.library.uml#" + typeString + of + Nothing -> case Map.lookup typeString cmap of + Nothing -> Other typeString + Just x -> CE x + Just "String" -> UMLString + Just "Integer" -> UMLInteger + Just "Bool" -> UMLBool + Just "Boolean" -> UMLBool + Just "UnlimitedNatural" -> UMLUnlimitedNatural + Just "Real" -> UMLReal + Just t1 -> error $ "unknown type: " ++ t1 + typeString = (case findAttr attrTypeName1 el of + Nothing -> foldr (++) "" + (map (fromMaybe "" . findAttr attrTypeName2) + (findChildren attrTypeName1 el)) + Just t1 -> t1) +{- processAttribute:: Attr -> Attribute +processAttribute at = Attribute{attrName = show at, + attrType = ""}--attrVal at} -} + +processGeneralization :: (Map.Map Id ClassEntity) -> Element -> ClassEntity +processGeneralization emap el = case findAttr attrGeneralName el of + Nothing -> error $ show el + Just t -> case Map.lookup t emap of + Just x -> x + Nothing -> error "Superclass not found" + +processInterface :: Maybe String -> Element -> (Id, Interface) +processInterface xmiv el = (fromMaybe "" (findAttr (attrIdName xmiv) el), + Interface {interfaceName = (fromMaybe "" (findAttr nameName el))}) + +extractElementId :: Element -> Id +extractElementId el = case findAttr nameName el of + Nothing -> show el + Just t -> t + + +{- +parseAssociations :: [Element] -> [Association] +parseAssociations [] = [] +parseAssociations (el:lis) = + case (findAttr typeName el) of + Nothing -> parseAssociations lis + Just "uml:Association" -> ((processAssociation el):(parseAssociations lis)) + Just _ -> parseAssociations lis + +parseInterfaces :: [Element] -> [(Id, Interface)] +parseInterfaces [] = [] +parseInterfaces (el:lis) = case (findAttr typeName el) of + Just "uml:Interface" -> ((processInterface el):(parseInterfaces lis)) + _ -> parseInterfaces lis + +parsePackages :: [Element] -> [Package] +parsePackages [] = [] +parsePackages (el:lis) = case (findAttr typeName el) of + Nothing -> parsePackages lis + Just "uml:Package" -> ((processPackage el):(parsePackages lis)) + Just _ -> parsePackages lis +-} + diff --git a/UML/Logic_UML.hs b/UML/Logic_UML.hs new file mode 100644 index 0000000000..e8ed9d05c8 --- /dev/null +++ b/UML/Logic_UML.hs @@ -0,0 +1,87 @@ +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE TypeSynonymInstances #-} +module UML.Logic_UML where + +import Logic.Logic +import UML.ATC_UML () +import UML.Morphism +import UML.Parser +import UML.Sign +import UML.StaticAna +import UML.UML as UML +--import Common.DocUtils +import UML.PrettyUML () + +import qualified Data.Map as Map +data UML = UML deriving Show + +--type Morphism = DefaultMorphism Sign + +instance Language UML where + description _ = "UML Language" + +instance Sentences UML + UML.Sign.Sen + Sign + Morphism + () + where + map_sen UML _ = return + +instance Monoid CM where + mempty = error "Not implemented!" + mappend _ _ = error "Not implemented!" + +instance Syntax UML + CM + () + () + () + where + parsersAndPrinters UML = + addSyntax "UML" (basicSpecCM, pretty) + $ makeDefault (basicSpecCM, pretty) + + +instance Logic UML + () -- Sublogics + CM -- basic_spec + UML.Sign.Sen -- sentence + () -- symb_items + () -- symb_map_items + UML.Sign.Sign -- sign + Morphism -- morphism + () -- symbol + () -- raw_symbol + () -- proof_tree + where + stability UML = Experimental + empty_proof_tree _ = () + + +instance StaticAnalysis UML + CM -- basic_spec + UML.Sign.Sen -- sentence + () -- symb_items + () -- symb_map_items + UML.Sign.Sign -- sign + Morphism -- morphism + () -- symbol + () -- raw_symbol + where + basic_analysis UML = Just basicAna + empty_signature UML = emptySign + --is_subsig UML _ _ = True + --subsig_inclusion UML = defaultInclusion + --induced_from_morphism _ _ sig = return $ MkMorphism sig sig + --signature_union CSMOF sign1 _ = return sign1 -- TODO + +instance Category Sign Morphism + where + ide = idMor + dom = source + cod = target + isInclusion mor = (Map.null $ classMap mor) && (Map.null $ attributeMap mor) && (Map.null $ operationMap mor) && (Map.null $ associationMap mor) && (Map.null $ compositionMap mor) + legal_mor = isLegalMorphism + composeMorphisms = composeMor diff --git a/UML/Morphism.hs b/UML/Morphism.hs new file mode 100644 index 0000000000..9e7803db46 --- /dev/null +++ b/UML/Morphism.hs @@ -0,0 +1,156 @@ +module UML.Morphism + ( Morphism (..) -- datatype for Morphisms + , pretty -- pretty printing + , idMor -- identity morphism + , isLegalMorphism -- check if morhpism is ok + , composeMor -- composition + , inclusionMap -- inclusion map + , mapSentence -- map of sentences +-- , mapSentenceH -- map of sentences, without Result type +-- , applyMap -- application function for maps +-- , applyMorphism -- application function for morphism +-- , morphismUnion + ) where + +import Common.Doc hiding (Label) +import Common.DocUtils +import Common.Result +import qualified Data.Map as Map +import Data.Maybe +import UML.Sign +import UML.UML + +import Control.Monad (unless) + +data Morphism = Morphism + { source :: Sign + , target :: Sign + , classMap :: ClassMap, + attributeMap :: AttributeMap, + operationMap :: OperationMap, + compositionMap :: CompositionMap, + associationMap :: AssociationMap + } deriving (Eq, Ord, Show) +type Mapping s = Map.Map s s +type ClassMap = Mapping ClassEntity +type AttributeMap = Mapping (Class, String, Type) +type OperationMap = Mapping (Class, String, [(String, Type)], Type) +type CompositionMap = Mapping ((String, ClassEntity), String, (String, Type)) +type AssociationMap = Mapping (String, [(String, Type)]) + +instance Pretty Morphism where + pretty _ = text "" + +idMor :: Sign -> Morphism +idMor sign = inclusionMap sign sign + +inclusionMap :: Sign -> Sign -> Morphism +inclusionMap sign1 sign2 = Morphism {source = sign1 + , target = sign2 + , classMap = Map.fromList [(c, c) | c <- fst $ signClassHier sign2], + attributeMap = Map.fromList [(c, c) | c <- signAttribute sign2], + operationMap = Map.fromList [(c, c) | c <- signOperations sign2], + compositionMap = Map.fromList [(c, c) | c <- signCompositions sign2], + associationMap = Map.fromList [(c, c) | c <- signAssociations sign2] +} + + +isLegalMorphism :: Morphism -> Result () +isLegalMorphism mor = let + cmap = classMap mor + sign = source mor + in unless ( (isValidMorph cmap (associationMap mor) isValidAssoMorph (signAssociations sign)) + && (isValidMorph cmap (compositionMap mor) isValidCompMorph (signCompositions sign)) + && (isValidMorph cmap (attributeMap mor) isValidAttrMorph (signAttribute sign)) + && (isValidMorph cmap (operationMap mor) isValidOperMorph (signOperations sign))) $ fail "illegal UML class diagram morphism" + + +isValidMorph :: Ord s => ClassMap -> (Mapping s) -> (ClassMap -> s -> s -> Bool) -> [s] -> Bool +isValidMorph cmap smap f slist = all (apply (f cmap)) [(x, fromJust $ Map.lookup x smap) | x <- slist, not (Map.lookup x smap == Nothing)] + where apply f (x, y) = f x y + +isValidAttrMorph :: ClassMap -> (Class, String, Type) -> (Class, String, Type) -> Bool +isValidAttrMorph cmap (c, s, t) (c', s', t') = ((Map.lookup (CL c) cmap) == Just (CL c')) && (typesMatch cmap (t, t')) + + +typesMatch :: ClassMap -> (Type, Type) -> Bool +typesMatch cmap (t, t') = (typeOrdered t == typeOrdered t') && (typeUnique t == typeUnique t') && (case (umltype t, umltype t') of + (CE ce, CE ce') -> (Map.lookup ce cmap) == Just ce' + (x, y) -> x == y) + +isValidOperMorph :: ClassMap -> (Class, String, [(String, Type)], Type) -> (Class, String, [(String, Type)], Type) -> Bool +isValidOperMorph cmap (c, s, paras, t) (c', s', paras', t') = ((Map.lookup (CL c) cmap) == Just (CL c')) && (typesMatch cmap (t, t')) && ((length paras) == (length paras')) && (all (typesMatch cmap) $ zip (map snd paras) (map snd paras')) + +isValidAssoMorph :: ClassMap -> (String, [(String, Type)]) -> (String, [(String, Type)]) -> Bool +isValidAssoMorph cmap (s, ends) (s', ends') = ((length ends) == (length ends')) && (all (typesMatch cmap) $ zip (map snd ends) (map snd ends')) + +isValidCompMorph :: ClassMap -> ((String, ClassEntity), String, (String, Type)) -> ((String, ClassEntity), String, (String, Type)) -> Bool +isValidCompMorph cmap ((_, c), _, (_, t)) ((_, c'), _, (_, t')) = ((Map.lookup c cmap) == Just c') && (typesMatch cmap (t, t')) + +composeMor :: Morphism -> Morphism -> Result Morphism +composeMor m1 m2 = return Morphism { + source = source m1, + target = target m2, + classMap = Map.fromList [(a, d) | (a, b) <- (Map.toList $ classMap m1), (c, d) <- (Map.toList $ classMap m2), b == c], + attributeMap = Map.fromList [(a, d) | (a, b) <- (Map.toList $ attributeMap m1), (c, d) <- (Map.toList $ attributeMap m2), b == c], + operationMap = Map.fromList [(a, d) | (a, b) <- (Map.toList $ operationMap m1), (c, d) <- (Map.toList $ operationMap m2), b == c], + compositionMap = Map.fromList [(a, d) | (a, b) <- (Map.toList $ compositionMap m1), (c, d) <- (Map.toList $ compositionMap m2), b == c], + associationMap = Map.fromList [(a, d) | (a, b) <- (Map.toList $ associationMap m1), (c, d) <- (Map.toList $ associationMap m2), b == c] +} + +mapSentence :: Morphism -> Sen -> Result Sen +mapSentence mor (NLeqF n f) = return $ NLeqF n (mapSen_fe mor f) +mapSentence mor (FLeqN f n) = return $ FLeqN (mapSen_fe mor f) n + + +mapSen_fe :: Morphism -> FunExpr -> FunExpr +mapSen_fe mor (NumComp mfc mfe) = (NumComp (comp2mfcomp ((sn2, ori2), n2, (tn2, tar2))) mfe) + where + ((sn1, ori1), n1, (tn1, tar1)) = (lookupByMF (comp2mfcomp) (Map.toList (compositionMap mor)) mfc) + ((sn2, ori2), n2, (tn2, tar2)) = fromJust $ Map.lookup ((sn1, ori1), n1, (tn1, tar1)) (compositionMap mor) + mfe2 = case sn1 of + mfe -> showClassEntityName ori2 + _ -> umlTypeString $ umltype tar2 +mapSen_fe mor (NumAss mfa mfe) = NumAss (asso2mfasso (n', ends')) mfe' + where + (n, ends) = lookupByMF asso2mfasso (Map.toList (associationMap mor)) mfa + (n', ends') = fromJust $ Map.lookup (n, ends) (associationMap mor) + mfe' = head [en' | ((en, et), (en', et')) <- (zip ends ends'), en == mfe] +mapSen_fe mor (NumAttr mfa) = NumAttr $ attr2mfattr $ fromJust $ Map.lookup (lookupByMF attr2mfattr (Map.toList (attributeMap mor)) mfa) (attributeMap mor) + + + +lookupByMF :: (Eq b, Show b) => (a -> b) -> [(a, a)] -> b -> a +lookupByMF tran [] mf = error $ "invalid classifier: " ++ (show mf) +lookupByMF tranAB ((el, _) : lis) mf = case tranAB el of + mf -> el + _ -> lookupByMF tranAB lis mf + + +{-lookupCEbyName :: [ClassEntity] -> String -> ClassEntity +lookupCEbyName [] s = error $ "invalid classifier: " ++ s +lookupCEbyName (ce:lis) s = case (showClassEntityName ce) of + s -> ce + _ -> lookupCEbyName lis s + +lookupCompbyName :: [Association] -> MFCOMPOSITION -> Association +lookupCompb1yName [] mf = error $ "invalid classifier: " ++ (show mf) +lookupCompbyName (ass:lis) (MFComposition n e1 t1 e2 t2) = + case (e1 == (showClassEntityName $ endTarget origin)) && (n == (assoName ass)) of + True -> ass + _ -> lookupCEbyName lis (MFComposition n e1 t1 e2 t2) + where (origin, target) = compositionEnds ass + +lookupAssobyMF :: [Association] -> MFASSOCIATION -> Association +lookupAssobyMF [] mf = error $ "invalid classifier: " ++ (show mf) +lookupAssobyMF (ass:lis) mfa = case asso2mfasso ass of + mfa -> ass + _ -> lookupAssobyMF lis mfa + +lookupAttrbyMF :: [Attribute] -> MFATTRIBUTE -> Attribute +lookupAttrbyMF [] mf = error $ "invalid classifier: " ++ (show mf) +lookupAttrbyMF +-- | Application funtion for morphisms +--applyMorphism :: Morphism -> Id -> Id +--applyMorphism mor idt = Map.findWithDefault idt idt $ propMap mor -} + diff --git a/UML/ParseUMLAsLibDefn.hs b/UML/ParseUMLAsLibDefn.hs new file mode 100644 index 0000000000..7670eafbbb --- /dev/null +++ b/UML/ParseUMLAsLibDefn.hs @@ -0,0 +1,35 @@ +module UML.ParseUMLAsLibDefn where + +import Common.AS_Annotation +import Common.Id +import Common.IRI +import Common.LibName +import Syntax.AS_Library +import Syntax.AS_Structured + +import UML.Logic_UML +import UML.Parser +import UML.UML + +import Logic.Grothendieck + +import System.IO +parseUMLCDasLibDefn :: FilePath -> IO LIB_DEFN +parseUMLCDasLibDefn fp = + do + handle <- openFile fp ReadMode + contents <- hGetContents handle + return $ convertToLibDefN fp $ parseUMLCDfromString contents + +convertToLibDefN :: FilePath -> CM -> LIB_DEFN +convertToLibDefN filename cm = Lib_defn + (emptyLibName $ convertFileToLibStr filename) + (makeLogicItem UML : [convertoItem cm]) + nullRange + [] + +convertoItem :: CM -> Annoted LIB_ITEM +convertoItem el = makeSpecItem (simpleIdToIRI $ mkSimpleId $ cmName el) $ createSpec el + +createSpec :: CM -> Annoted SPEC +createSpec el = makeSpec $ G_basic_spec UML el diff --git a/UML/Parser.hs b/UML/Parser.hs new file mode 100644 index 0000000000..987308332b --- /dev/null +++ b/UML/Parser.hs @@ -0,0 +1,114 @@ +module UML.Parser where + +import System.IO + +import UML.ClassDiagramParser +import UML.StateMachineParser +import UML.StateMachine +import UML.UML +import UML.XMINames + +import Data.Maybe +import Data.List.Split +import Common.GlobalAnnotations (PrefixMap) + +import Text.ParserCombinators.Parsec +import Text.XML.Light + + + +basicSpecCM :: PrefixMap -> GenParser Char st CM +basicSpecCM _ = do + s <- many anyChar + return $ parseUMLCDfromString s + +parseUMLCDfromString :: String -> CM +parseUMLCDfromString s = case parseXMLDoc s of + Nothing -> error "Not a proper xmi-file" + Just el -> case parseModel el of + ClassModel cma -> cma + x -> error $ "Modeltype unimplemented: " ++ (show x) + +parseUMLCDfromFile :: FilePath -> IO CM +parseUMLCDfromFile fp = + do + handle <- openFile fp ReadMode + contents <- hGetContents handle + return $ parseUMLCDfromString contents + + +basicSpecSM :: PrefixMap -> GenParser Char st StateMachine +basicSpecSM _ = do + s <- many anyChar + return $ parseUMLSMfromString s + +parseUMLSMfromString :: String -> StateMachine +parseUMLSMfromString s = case parseXMLDoc s of + Nothing -> error "Not a proper xmi-file" + Just el -> case parseModel el of + SM sm -> sm + _ -> error "unimplemented" + + +parseModel :: Element -> Model +parseModel el0 = case findChildren packagedElementName el of + (x:_) -> case Just smPrefix == (findAttr (typeName xmiv) x) of + True -> case findChildren packagedElementName el of + (y:_) -> SM (parseStateMachine xmiv y) + [] -> error "No packagedElement found" + False -> parseClassModel prefix (xmiv, umlv) el + + --[] -> "5.0.0" + --(dV:_) -> fromJust $ findAttr (sName "value") dV + _ -> error $ "No PackagedElement found: " ++ (show $ elChildren el) + where + el = fromMaybe (error "No ModelElement found") $ findModelElement el0 + xmiv = case filter (not . (Nothing ==) . qURI . attrKey) $ elAttribs el of + [] -> Nothing + (x:_) -> (qURI . attrKey) x + prefix = head (splitOn ":" $ fromMaybe "uml" $ findAttr (typeName xmiv) $ head $ findChildren packagedElementName el) + smPrefix = prefix ++ ":StateMachine" + umlv = qURI $ elName el --case filter ((Just "exporterVersion" ==).(findAttr nameName)) $ foldl (++) [] $ map (findChildren (sName "contents")) $ findChildren (sName "eAnnotations") el of +findModelElement :: Element -> Maybe Element +findModelElement el0 = case findChildren packagedElementName el0 of + [] -> case filter (not . isNothing) $ map findModelElement (elChildren el0) of + [] -> Nothing + [Just x] -> Just x + _ -> error "Multiple models in a single XMI are not supported" + _ -> Just el0 + +{-case ((qName $ elName el0) == "Model" && (qPrefix $ elName el0) == Just "uml") of -- || ((qName $ elName el0) == "XMI") of + True -> Just el0 + False -> case filter (not . isNothing) $ map findModelElement (elChildren el0) of + [] -> Nothing + (x : _) -> x-} + +isElem :: Maybe String -> String -> Element -> Bool +isElem xmiv s el = (findAttr (typeName xmiv) el) == Just s + + + +{- parseClassModel :: Element -> Model +parseClassModel el = ClassModel [Package{classes=(Map.fromList (parseClasses (findChildren packagedElementName el))), associations=(parseAssociations (findChildren packagedElementName el)), interfaces=(Map.fromList(parseInterfaces (findChildren packagedElementName el)))}] -} + + +{- parseXMItoUML :: IO() +parseXMItoUML = do + putStr "Start \n" + handle <- openFile "uml.xmi" ReadMode + contents <- hGetContents handle + case parseXMLDoc contents of + Nothing -> putStr "VACIO" + Just el -> let cm = ClassModel{ classes = Map.fromList ( parseClasses (findChildren packagedElementName el)), + assos = parseAssociations (findChildren packagedElementName el)} in putStr ((show (classes cm)) ++ "\n" ++ (show (assos cm))) -} + +-- starte machine + + +{- parseXMIToStateMachine = do + putStr "Start \n" + handle <- openFile "statemachine.xmi" ReadMode + contents <- hGetContents handle + case parseXMLDoc contents of + Nothing -> putStr "VACIO" + Just el -> let sm = Region{states = parseStates (findChildren smSubvertexName el), transitions=[show el]} in putStr ((show (states sm)) ++ "\n" ++ (show (transitions sm))) -} diff --git a/UML/PrettyUML.hs b/UML/PrettyUML.hs new file mode 100644 index 0000000000..2b4d72b70a --- /dev/null +++ b/UML/PrettyUML.hs @@ -0,0 +1,54 @@ +module UML.PrettyUML where + +import Common.Doc hiding (Label) +import Common.DocUtils +import qualified Data.Map as Map +import Data.Maybe +import UML.Sign +import UML.UML + +instance Pretty Model where + pretty (ClassModel cm) = pretty cm + pretty _ = error "unimplemented" + +instance Pretty CM where + pretty cm = (sep $ map pretty (Map.elems $ cmClasses cm)) + $+$ (vcat $ map pretty (Map.elems $ cmAssociations cm)) + $+$ (vcat $ map pretty (cmPackages cm)) + +instance Pretty Class where + pretty cl = (((text . className) cl) ) <> (parens $ foldl (<>) empty $ punctuate comma (map (text . showClassEntityName) (super cl))) + <+> ( sep $ map pretty $ attr cl) + <+> ( sep $ map pretty $ proc cl) + +instance Pretty Attribute where + pretty at = ((text . attrName) at) <> colon <> ((pretty . attrType) at) <> lbrack <> ((text . attrLowerValue) at) <> comma <+> ((text . attrUpperValue) at) <> rbrack + +instance Pretty Procedure where + pretty at = ((text . procName) at) <> parens (cat $ map pretty (procPara at)) <> colon <> ((pretty . procReturnType) at) + +instance Pretty Association where + pretty ass = case isComposition ass of + False -> (text $ assoName ass) + <+> (brackets $ sep $ punctuate comma $ map pretty $ ends ass) + True -> (text $ assoName ass) <> text "[Composition]" <> colon <+> (pretty $ head $ ends ass) <+> text "<>--" <+> (pretty $ head $ tail $ ends ass) +instance Pretty Package where + pretty pack = (sep $ map pretty (Map.elems $ classes pack)) + $+$ (vcat $ map pretty (Map.elems $ associations pack)) + $+$ (vcat $ map pretty (packagePackages pack)) + +instance Pretty End where + pretty end = ((text . (fromMaybe "") . endName) end) <> colon <> (text $ showClassEntityName $ endTarget end) <> lbrack <> ((text . lowerValue . label) end) <> comma <+> ((text . upperValue . label) end) <> rbrack + +instance Pretty UMLType where + pretty (CE en) = (text . showClassEntityName) en + pretty t = (text . show) t + +instance Pretty Type where + pretty t = (pretty . umltype) t + +instance Pretty UML.Sign.Sen where + pretty (NLeqF n f) = pretty $ (show n) ++ "<=" ++ (show f) + pretty (FLeqN f n) = pretty $ (show f) ++ "<=" ++ (show n) +instance Pretty Sign where + pretty _ = pretty $ "" diff --git a/UML/Sign.hs b/UML/Sign.hs new file mode 100644 index 0000000000..d454e01158 --- /dev/null +++ b/UML/Sign.hs @@ -0,0 +1,80 @@ +{-# LANGUAGE DeriveDataTypeable #-} +-- |This module implements an institution for UML Class Diagrams as described +-- in the DOL standard - at least the signature and the sentences +module UML.Sign where + +--import CommonLogic.Sign +import Data.List +import UML.UML +import UML.UML () +import Common.Id +import Data.Data(Data,Typeable) + +-- |The signature +data Sign = Sign { + signClassHier :: ([ClassEntity], [(ClassEntity, ClassEntity)]), + signAttribute :: [(Class, String, Type)], + signOperations :: [(Class, String, [(String, Type)], Type)], + signCompositions :: [((String, ClassEntity), String, (String, Type))], + signAssociations :: [(String, [(String, Type)])] + } deriving (Eq, Ord, Show) + +-- | checks whether an Signature is empty +emptySign :: Sign +emptySign = Sign { + signClassHier = ([], []), + signAttribute = [], + signOperations = [], + signCompositions = [], + signAssociations = [] + } + +-- | The multiplicity formulas as defined by the specified grammar (see DOL) +data Sen = NLeqF NumLit FunExpr + | FLeqN FunExpr NumLit deriving (Eq, Ord, Show, Typeable, Data) +data FunExpr = NumComp MFCOMPOSITION MFEnd + | NumAss MFASSOCIATION MFEnd + | NumAttr MFATTRIBUTE deriving (Eq, Ord, Show, Typeable, Data) +data MFATTRIBUTE = MFAttribute MFClassifier MFEnd MFTYPE deriving (Eq, Ord, Show, Typeable, Data) +data MFCOMPOSITION = MFComposition MFName MFEnd MFTYPE MFEnd MFTYPE deriving (Eq, Ord, Show, Typeable, Data) +data MFASSOCIATION = MFAssociation MFName [(MFEnd, MFTYPE)] deriving (Eq, Ord, Show, Typeable, Data) +type MFClassifier = MFName +type MFEnd = MFName +data MFTYPE = MFType Annot MFClassifier deriving (Eq, Ord, Show, Typeable, Data) +type NumLit = Integer +data Annot = OrderedSet | Set | Sequence | Bag deriving (Eq, Ord, Show, Typeable, Data) +type MFName = String + +instance GetRange Sen where + getRange _ = nullRange + rangeSpan _ = [] + + + +comp2mfcomp :: ((String, ClassEntity), String, (String, Type)) -> MFCOMPOSITION +comp2mfcomp ((on, ce), n, (tn, tart)) = MFComposition n on (MFType Set $ showClassEntityName ce) tn (type2mftype tart) + +-- |Converts a UMLType to a \tau expressions from DOL +type2mftype :: Type -> MFTYPE +type2mftype t = case (typeOrdered t, typeUnique t) of + (True, True) -> MFType OrderedSet (umlTypeString $ umltype t) + (True, False) -> MFType Sequence (umlTypeString $ umltype t) + (False, True) -> MFType Set (umlTypeString $ umltype t) + (False, False) -> MFType Bag (umlTypeString $ umltype t) + +-- |Constructs the multiplicity expression for a given association +asso2mfasso :: (String, [(String, Type)]) -> MFASSOCIATION +asso2mfasso (n, lis) = MFAssociation n (map end2mfend lis) + +-- |Returns the end expression and type of a given association end +end2mfend :: (String, Type) -> (MFEnd, MFTYPE) +end2mfend (n, t) = (n, type2mftype t) + +annotString :: Annot -> String +annotString = show + +-- |Constructs the multiplicity expression for a given attribute +attr2mfattr :: (Class, String, Type) -> MFATTRIBUTE +attr2mfattr (cs, s, t) = MFAttribute (className cs) s (type2mftype t) + + diff --git a/UML/StateMachine.hs b/UML/StateMachine.hs new file mode 100644 index 0000000000..d8f07e0e64 --- /dev/null +++ b/UML/StateMachine.hs @@ -0,0 +1,51 @@ +module UML.StateMachine where +import Data.Maybe + +data StateMachine = StateMachine { + regions :: [Region]} deriving Show{-smEntities :: [Entity], + smTransitions :: [Transition]-} + +data Region = Region { + states :: [Entity], + transitions :: [Transition]} deriving Show + +data PseudoState = PseudoState { + pseudoStateName :: String, + pseudoStateType :: String} deriving Show + +data EntityType = State [Region] | EntryState| ExitState | FinalState | InitialState | DeepHistory | ShallowHistory | Junction | Choice | Fork | Join deriving Show + +data Entity = Entity String String EntityType deriving Show +{-data State = State { + region :: [Region], + stateName :: String +} deriving Show-} + +getEntityId :: Entity -> String +getEntityId (Entity id _ _) = id + +getEntityName :: Entity -> String +getEntityName (Entity _ name _) = name + + +data Transition = Transition { + source :: String, + target :: String, + trigger :: Maybe Trigger, + guard :: Maybe Guard, + effect :: Maybe Event} + +instance Show Transition where + show tran = ((show $ source tran) ++ " --" ++ tr ++ gu ++ ev ++ "--> " ++ (show $ target tran)) + where + tr = fromMaybe "" (trigger tran) + gu = case guard tran of + Nothing -> "" + Just g -> "[" ++ g ++ "]" + ev = case effect tran of + Nothing -> "" + Just e -> "/" ++ e + +type Trigger = String +type Guard = String +type Event = String diff --git a/UML/StateMachineParser.hs b/UML/StateMachineParser.hs new file mode 100644 index 0000000000..892147f982 --- /dev/null +++ b/UML/StateMachineParser.hs @@ -0,0 +1,113 @@ +module UML.StateMachineParser where +import Data.Maybe +import Text.XML.Light +import UML.StateMachine +import UML.UML +import UML.XMINames + + + +processRegion :: Maybe String -> Element -> (Region, [(String, Entity)]) +processRegion xmiv el = (Region {states = ent, transitions = trans}, emap) + where (ent, trans, emap) = readEverything xmiv el + +--processRegionMap :: Element -> [(String, Entity)] +--processRegionMap el = readMap el + + +mergeEAnnotations :: Element -> Maybe String -> [Element] +mergeEAnnotations el st = case st of + Nothing -> foldl (++) [] (map elChildren annots) + Just s -> foldl (++) [] (map (\ x -> (findChildren (sName s) x)) annots) + where annots = (findChildren (sName "eAnnotations" ) el) + +processPseudoState :: Maybe String -> Element -> (Entity, [(String, Entity)]) +processPseudoState xmiv el = (ent, [(id1, ent)]) + where + ent = Entity id1 name et + id1 = fromMaybe "" (findAttr (attrIdName xmiv) el) + name = (fromMaybe "" (findAttr nameName el)) + et = case (findAttr (sName "kind") el) of + Just "exitPoint" -> ExitState + Just "fork" -> Fork + Just "join" -> Join + Just "choice" -> Choice + Just "junction" -> Junction + Just "deepHistory" -> DeepHistory + Just "shallowHistory" -> ShallowHistory + Nothing -> InitialState + Just x -> error ("State kind not known: " ++ (show x)) + +--processState :: Element -> Entity +--processState el = fromJust $ Map.lookup (fromJust(findAttr nameName el)) eMap +-- where regs = (map processRegion (findChildren smRegionName el)) +-- p = (fromMaybe "" (findAttr attrIdName el), State (fromMaybe "" ) regs) + +processState :: Maybe String -> Element -> (Entity, [(String, Entity)]) +processState xmiv el = (snd p, p : regMap) + where + regMap = foldl (++) [] (map (snd . (processRegion xmiv)) regNames) + id = fromJust (findAttr (attrIdName xmiv) el) + regNames = (findChildren smRegionName el) + p = (id,Entity id (fromMaybe "" (findAttr nameName el)) $ State (map (fst . (processRegion xmiv)) regNames)) + +processTransition :: Maybe String -> Element -> Transition +processTransition xmiv el = Transition {source = (fromJust (findAttr (sName "source") el)), target = (fromJust (findAttr (sName "target") el)), trigger = tr, guard = gu, effect = ef} + where + tr = case trCand of + [] -> Nothing + _ -> findAttr (sName "value") $ head (findChildren (sName "defaultValue") (head trCand)) + ef = case (findChildren (sName "effect") el) of + [] -> Nothing + efs -> findAttr (sName "redefinedBehavior") (head efs) + trCand = case (elChildren el) of + [] -> [] + _ -> (filter (\ x -> ((Just "ReceivedEvent") == (findAttr (sName "name") x))) (mergeEAnnotations el (Just "contents"))) + + gu = case (findAttr (sName "guard") el) of + Nothing -> Nothing -- (show el) + Just id1 -> case findChildren (sName "specification" ) rules of + [] -> Just $ show el + _ -> findAttr (sName "value") $ head (findChildren (sName "specification" ) rules) + where rules = (head (filter (\ x -> ((Just id1) == findAttr (attrIdName xmiv) x)) ruleCands)) + ruleCands = (findChildren (sName "ownedRule" ) el) --foldl (++) [] (map (\x -> (findChildren (sName "ownedRule" ) x)) annots) + --annots = (findChildren (sName "eAnnotations" ) el) + + + +parseTransitions :: Maybe String -> [Element] -> [Transition] +parseTransitions _ [] = [] +parseTransitions xmiv (el : lis) = ((processTransition xmiv el) : (parseTransitions xmiv lis)) + + +parseStates :: Maybe String -> [Element] -> ([Entity], [(String, Entity)]) +parseStates _ [] = ([], []) +parseStates xmiv (el : lis) = + case (findAttr (typeName xmiv) el) of + Nothing -> (ent, emap) + Just "uml:State" -> ((fst (processState xmiv el)) : ent, (snd (processState xmiv el)) ++ emap) + Just "uml:Pseudostate" -> ((fst (processPseudoState xmiv el)) : ent, (snd (processPseudoState xmiv el)) ++ emap) + Just "uml:FinalState" -> (fs : ent, (id,fs) : emap) + where id = fromJust (findAttr (attrIdName xmiv) el) + fs = Entity id (fromMaybe "" (findAttr nameName el)) FinalState + Just _ -> (ent, emap) + where (ent, emap) = (parseStates xmiv lis) + + +--readMap :: Element -> [(String, Entity)] +--readMap el = foldl (++) [] (map processStateMap (findChildren smSubvertexName el)) + +readEverything :: Maybe String -> Element -> ([Entity], [Transition], [(String, Entity)]) +readEverything xmiv el = (ent, trans, emap) + where + (ent, emap) = parseStates xmiv (findChildren smSubvertexName el) + trans = parseTransitions xmiv (findChildren (sName "transition") el) + +parseStateMachine :: Maybe String -> Element -> StateMachine +parseStateMachine xmiv el = case ent of + -- [] -> StateMachineR (fst ((processRegion xmiv (head (findChildren smRegionName el))))) + _ -> StateMachine{regions = regs } + where regs = case fst $ processState xmiv el of + Entity id name (State regs0) -> regs0 + _ -> [] + where (ent, trans, _) = readEverything xmiv el diff --git a/UML/StaticAna.hs b/UML/StaticAna.hs new file mode 100644 index 0000000000..fc437b91ed --- /dev/null +++ b/UML/StaticAna.hs @@ -0,0 +1,12 @@ +module UML.StaticAna where + +import Common.AS_Annotation +import Common.ExtSign +import Common.GlobalAnnotations +import Common.Result +import UML.Sign +import UML.UML +import UML.UML2CL + +basicAna :: (CM, Sign, GlobalAnnos) -> Result (CM, ExtSign Sign (), [Named Sen]) +basicAna (cm, _, _) = return (cm, mkExtSign (retrieveSign cm), map (makeNamed "") $ retrieveSen cm) diff --git a/UML/Sublogic.hs b/UML/Sublogic.hs new file mode 100644 index 0000000000..e69de29bb2 diff --git a/UML/Test_Parser.hs b/UML/Test_Parser.hs new file mode 100644 index 0000000000..bf255d97c8 --- /dev/null +++ b/UML/Test_Parser.hs @@ -0,0 +1,25 @@ +import Common.AnnoParser +import Common.DocUtils +import Common.Parsec +import qualified Data.Map as Map +import System.IO +import Text.ParserCombinators.Parsec +import Text.XML.Light +import UML.Parser +import UML.PrettyUML +import UML.UML +import System.Environment (getArgs) +import UML.UML2CL +main :: IO () +main = do + args <- getArgs + --handle <- openFile "UML/data/simplelibrary.xmi" ReadMode + handle <- openFile (args!!0) ReadMode + --handle <- openFile "data/uml.xmi" ReadMode + --handle <- openFile "data/statemachine.xmi" ReadMode + contents <- hGetContents handle + + putStr $ case parse (basicSpecCM Map.empty) "" contents of + Left err -> show err + Right cm -> (show $ pretty cm) ++ "\n ____ DONE ____ \n" {-++ + (show $ retrieveSen cm)-} diff --git a/UML/Test_UML2CL.hs b/UML/Test_UML2CL.hs new file mode 100644 index 0000000000..44a7abc0b4 --- /dev/null +++ b/UML/Test_UML2CL.hs @@ -0,0 +1,31 @@ +import System.IO +import Text.XML.Light +import UML.XMINames + +import CommonLogic.AS_CommonLogic +import Data.List.Split +import qualified Data.Map as Map +import Data.Maybe +import UML.ClassDiagramParser +import UML.StateMachineParser +import UML.UML +import UML.UML2CL +import UML.Utils + +main :: IO () +main = do + handle <- openFile "UML/data/statemachine_Till.xml" ReadMode + --handle <- openFile "data/uml.xmi" ReadMode + --handle <- openFile "data/statemachine.xmi" ReadMode + contents <- hGetContents handle + putStr $ show (printText (translateModel2Text (case parseXMLDoc contents of + Nothing -> error contents + Just el -> (parseModel el)))) + +parseModel :: Element -> Model +parseModel el0 = case findAttr typeName (head (findChildren packagedElementName el)) of + Just "uml:StateMachine" -> (parseStateMachine (head (findChildren packagedElementName el))) + _ -> parseClassModel el + where el = case (elName el0) == modelName of + True -> el0 + False -> fromJust $ findElement modelName el0 diff --git a/UML/UML.hs b/UML/UML.hs new file mode 100644 index 0000000000..22201b54dd --- /dev/null +++ b/UML/UML.hs @@ -0,0 +1,206 @@ +{- | +Description : Data structure for UML Class Diagrams +Copyright : (c) Martin Glauer + +Maintainer : glauer@iws.cs.ovgu.de +Stability : experimental + +Structure used by ClassDiagramParser.hs +-} + +-- |This module contains the general data structure for UML Class Diagrams. + +module UML.UML where +import qualified Common.Id +import qualified Data.Map as Map +import Data.Maybe +import Prelude hiding (Enum) +import Data.Data hiding (DataType) +import UML.StateMachine + +data Model = ClassModel CM + | SM StateMachine deriving Show + +-- |A UML Class Model +data CM = CM { + cmName :: String, + cmClasses :: (Map.Map Id Class), + cmAssociations :: (Map.Map Id Association), + cmInterfaces :: (Map.Map Id Interface), + cmPackageMerges :: [Id], + cmEnums :: Map.Map Id UML.UML.Enum, + cmAssociationClasses :: (Map.Map Id AssociationClass), + cmSignals :: (Map.Map Id Signal), + cmPackages :: [Package]} deriving Show + +-- ^These mappings are still necessary. You will need them, e.g. to get +-- super classes by their id. (subject to change - someday - maybe) + +instance Common.Id.GetRange CM where + getRange _ = Common.Id.nullRange + rangeSpan _ = [] + +data ClassEntity = CL Class + | AC AssociationClass + | EN UML.UML.Enum + | DT UML.UML.DataType deriving (Ord, Show) + +instance Eq ClassEntity where + (==) x1 x2 = (showClassEntityName x1) == (showClassEntityName x2) + +data Package = Package { + packageName :: String, + classes :: (Map.Map Id Class), + associations :: (Map.Map Id Association), + interfaces :: (Map.Map Id Interface), + packageMerges :: [Id], + packageEnums :: Map.Map Id UML.UML.Enum, + packageAssociationClasses :: (Map.Map Id AssociationClass), + signals :: (Map.Map Id Signal), + packagePackages :: [Package]} deriving (Eq, Ord, Show) + +-- These do not work very well, yet. +-- -> AssociationClasses can contain classes but not +-- other AssociationClass + +data AssociationClass = AssociationClass { + acClass :: Class, + acAsso :: Association} deriving (Eq, Ord, Show) + + +data Class = Class { + super :: [ClassEntity], + className :: String, + attr :: [Attribute], + proc :: [Procedure]} deriving (Eq, Ord, Show) + +data DataType = DataType { + dtsuper :: [ClassEntity], + dtName :: String, + dtattr :: [Attribute], + dtproc :: [Procedure] } deriving (Eq, Ord, Show) + +data Attribute = Attribute { + attrName :: String, + attrType :: Type, + attrUpperValue :: String, + attrLowerValue :: String, + attrVisibility :: String} deriving (Eq, Ord) + +instance Show Attribute where + show attri = (attrName attri) ++ ":" ++ ((show . attrType) attri) ++ "[" + ++ (attrLowerValue attri) ++ ", " + ++ (attrUpperValue attri) ++ "]" + +data Procedure = Procedure { + procName :: String, + procPara :: [Attribute], + procReturnType :: Maybe Type, + procPackImports :: [Id], + procElemImports :: [Id], + procVisibility :: String} deriving (Eq, Ord, Show) + + +data Enum = Enum { + enumName :: String, + enumLiterals :: [Literal]} deriving (Eq, Ord, Show) + +data Literal = Literal { literalName :: String, + literalOwner :: UML.UML.Enum} deriving (Eq, Ord) + +instance Show Literal where + show lit = literalName lit + + + +data Association = Association { + ends :: [End], + assoName :: String} deriving (Eq, Ord, Show) + +data EndType = Composition | Aggregation | Normal deriving (Eq, Ord, Show) + +-- The XMI-Standard ignores ends that are compositions or aggregations but adds +-- attributes to the corresponding class. Leads to edges having only one end, +-- which is quite inconvenient. +-- Thus in this DS above mentioned attributes are ignored and the corresponding +-- (special) edges recreated. These edges are marked by the non-normal EndTypes. + +data End = End { + endTarget :: ClassEntity, + label :: Label, + endName :: Maybe String, + endType :: EndType} deriving (Eq, Ord) + +showClassEntityName :: ClassEntity -> String +showClassEntityName (CL x) = className x +showClassEntityName (AC x) = className (acClass x) +showClassEntityName (EN x) = enumName x +showClassEntityName (DT x) = dtName x +instance Show End where + show end = case endTarget end of + CL cl -> "End " ++ (fromMaybe "" (endName end)) ++ "(" + ++ ((show . endType) end) ++ "): " ++ (className cl) + ++ (show (label end)) + AC ac -> "End " ++ (fromMaybe "" (endName end)) ++ "(" + ++ ((show . endType) end) ++ "): " + ++ (className (acClass ac)) + ++ (show (label end)) + EN x -> "End " ++ (fromMaybe "" (endName end)) + ++ "(" ++ ((show . endType) end) ++ "): " + ++ (show x) ++ (show (label end)) + +data Interface = Interface { + interfaceName :: String} deriving (Eq, Ord, Show) + +data Label = Label { + upperValue :: String, + lowerValue :: String} deriving (Eq, Ord) + +instance Show Label where + show l = "[" ++ (lowerValue l) ++ ", " ++ (upperValue l) ++ "]" + +data Signal = Signal { + signalName :: String} deriving (Eq, Ord, Show) + +type Id = String +data UMLType = CE ClassEntity | UMLString | UMLInteger | UMLBool + | UMLUnlimitedNatural | UMLReal | UMLSequence Type + | UMLSet Type | UMLOrderedSet Type | UMLBag Type + | Other String deriving (Show, Eq, Ord) + -- The "Other" types are somewhat cryptic in XMI. + -- They are left as-is - who knows who needs this. + -- Note that they might contain class ids + +data Type = Type { + umltype :: UMLType, + typeUnique :: Bool, + typeOrdered :: Bool} deriving (Eq, Ord) + +instance Show Type where + show t = show (umltype t) + +compositionEnds :: Association -> (End, End) +compositionEnds ass = (corigin, ctarget) + where + corigin = head $ filter isComposedEnd $ ends ass + ctarget = case (filter (not . (corigin ==)) (ends ass)) of + (x : _) -> x + [] -> error $ show $ ends ass + +isComposedEnd :: End -> Bool +isComposedEnd en = (endType en) == Composition + +isComposition :: Association -> Bool +isComposition as = any isComposedEnd (ends as) + +umlTypeString :: UMLType -> String +umlTypeString (CE c) = showClassEntityName c +umlTypeString (UMLString) = "buml:String" +umlTypeString (UMLInteger) = "buml:Integer" +umlTypeString (UMLBool) = "buml:Bool" +umlTypeString (UMLUnlimitedNatural) = "buml:NaturalNumber" +umlTypeString (UMLReal) = "buml:Real" +umlTypeString _ = "" + +defaultType :: ClassEntity -> Type +defaultType ce = Type {umltype = CE ce, typeOrdered = False, typeUnique = True} diff --git a/UML/UML2CL.hs b/UML/UML2CL.hs new file mode 100644 index 0000000000..87c8822709 --- /dev/null +++ b/UML/UML2CL.hs @@ -0,0 +1,512 @@ +module UML.UML2CL where +import qualified Data.Map as Map +import UML.UML +import UML.UML2CL_preamble + + +import CommonLogic.AS_CommonLogic + +import Common.Id as Id + +import Data.Char +import Data.List +import Data.Maybe +import UML.Sign +import UML.Utils + + + + +{- +translateModel2Text :: Model -> TEXT +translateModel2Text m = Text (translateModel2Phrases m) nullRange + +translateModel2Phrases :: Model -> [PHRASE] +translateModel2Phrases (ClassModel cm) = preamble ++ (translateClasses (cmClasses cm)) + ++ (map translateEnumPreamble $ ((Map.elems).cmEnums) cm) + ++ (foldl (++) [] $ (map translateComposition compositions)) + ++ (map translateComPair (pairs compositions)) + ++ (map translateAssociation (Map.elems $ cmAssociations cm)) + ++ (foldl (++) [] (map translatePackage (cmPackages cm))) + ++ postamble + where + compositions = filter isComposition $ Map.elems $ cmAssociations cm-} + +translateSign2Phrases :: UML.Sign.Sign -> [TEXT_META] +translateSign2Phrases sign = (( foldl (++) [] (map (map phrases2TM) preambleSens)) + ++ (map translateEnumPreamble $ filterEnums $ fst $ signClassHier sign) + ++ (map translateInherit (snd $ signClassHier sign)) + ++ (foldl (++) [] $ map translateAttribute (signAttribute sign)) + ++ (foldl (++) [] $ map translateProcedure (signOperations sign)) + ++ (foldl (++) [] $ map translateComposition (signCompositions sign)) + ++ (map translateComPair (pairs $ signCompositions sign)) + ++ (foldl (++) [] $ map translateAssociation (signAssociations sign)) + ++ (foldl (++) [] $ map translateBinAsso $ filter ((2 ==) . length . snd) (signAssociations sign))) + +phrases2TM :: [PHRASE] -> TEXT_META +phrases2TM p = Text_meta { getText = Text p nullRange + , textIri = Nothing + , nondiscourseNames = Nothing + , prefix_map = [] } + +phrase2TM :: PHRASE -> TEXT_META +phrase2TM p = phrases2TM [p] + +filterEnums :: [ClassEntity] -> [UML.UML.Enum] +filterEnums [] = [] +filterEnums ((EN en) : lis) = en : (filterEnums lis) +filterEnums (_ : lis) = filterEnums lis +{- + (foldl (++) [] $ (map translateCompLabel compositions)) + ++ (foldl (++) [] $ (map translateAssoLabel (filter (not.isComposition) (Map.elems $ cmAssociations cm)))) + compositions = filter isComposition $ Map.elems $ cmAssociations cm +-} +translateBinAsso :: (String, [(String, Type)]) -> [TEXT_META] +translateBinAsso (n, [(en1, et1), (en2, et2)]) = map fromJust $ filter (not . isNothing) [translateEndCoin n 1 (en1, et1), translateEndCoin n 2 (en2, et2)] +translateBinAsso (_, _) = error "Not a binary association" + +translateEndCoin :: String -> Integer -> (String, Type) -> Maybe TEXT_META +translateEndCoin m i (n, et) = + case umltype et of + CE ce -> case ce of + CL cl -> translateEndCoinCE className attr i m n et cl + AC ac -> translateEndCoinCE className attr i m n et $ acClass ac + EN _ -> Nothing + DT dt -> translateEndCoinCE dtName dtattr i m n et dt + _ -> Nothing + +translateEndCoinCE :: (a -> String) -> (a -> [Attribute]) -> Integer -> String -> String -> Type -> a -> Maybe TEXT_META +translateEndCoinCE namef attrf i m n et cl = + case filter ((n ==) . attrName) (attrf cl) of -- Translate class cl into TEXT_META + [] -> Nothing + (_ : _) -> Just $ phrases2TM [Sentence $ Quant_sent Universal [Name o, Name s] (ifSen + (typeFunction (mkSimpleId $ (namef cl) ++ "." ++ n) [o, s]) + (Atom_sent (Equation (Name_term s) (Funct_term ( Name_term $ mkSimpleId $ "form:seq2" ++ (map toLower $ translateTargetType et)) [Term_seq $ Funct_term (Name_term $ mkSimpleId $ "form:select" ++ (show i)) [Term_seq $ Name_term o, Term_seq $ Name_term $ mkSimpleId m] nullRange] nullRange)) nullRange)) nullRange] + where + o = mkSimpleId "o" + s = mkSimpleId "s" + +translateMF2TM :: [Sen] -> TEXT_META +translateMF2TM mfs = Text_meta { getText = Text (fmap Sentence (map translateMult2Sen mfs)) nullRange + , textIri = Nothing + , nondiscourseNames = Nothing + , prefix_map = [] } + +translateMult2Sen :: Sen -> SENTENCE +translateMult2Sen mf = case mf of + NLeqF l (NumAttr (MFAttribute c p (MFType t cp))) -> Quant_sent Universal [Name x, Name y, Name n] (ifSen (andSen [ typeFunction (mkSimpleId $ c ++ "." ++ p) [x, y], + (typeFunction (mkSimpleId $ "form:" ++ (map toLower $ show t) ++ "-size") [y, n])]) + (typeFunction (mkSimpleId "buml:leq") [mkSimpleId $ show l, n])) nullRange + where + [x, y, n] = map mkSimpleId $ generateNames [c, p, cp, annotString t] 3 + NLeqF l (NumAss (MFAssociation a endL) p1) -> Quant_sent Universal (map (\ p -> Name p) xs) + (ifSen (andSen $ (map (\ (x, c) -> typeFunction c [x]) (zip xs cs)) ++ + [Atom_sent (Atom (Name_term $ mkSimpleId "form:sequence-size") [Term_seq $ Funct_term (Name_term $ mkSimpleId "form:n-select") [Term_seq $ Name_term $ mkSimpleId a, Term_seq $ Name_term $ mkSimpleId $ show i, insertList xs, Term_seq $ Name_term n] nullRange]) nullRange]) + (typeFunction (mkSimpleId "buml:leq") [mkSimpleId $ show l, n])) nullRange + where + (n : xs) = map mkSimpleId $ generateNames ([show l, a, p1] ++ (map fst pcs)) $ (length pcs) + 1 + pcs = filter (\ (p, _) -> not $ p == p1) endL + cs = map (mkSimpleId . fst) pcs + i = snd $ head $ filter (\ ((p, _), _) -> p == p1) (zip endL [i0 | i0 <- [1 .. (length endL)]]) + + NLeqF l (NumComp (MFComposition m p1 (MFType t1 c1) p2 (MFType t2 c2)) p0) -> Quant_sent Universal [Name x] (ifSen (andSen [ (typeFunction (mkSimpleId c3mi) [x]), Atom_sent (Atom (Name_term $ mkSimpleId $ "form:" ++ (map toLower $ show t3mi) ++ "-size") [Term_seq $ Funct_term (Name_term $ mkSimpleId $ "form:select" ++ i) [Term_seq $ Name_term x, Term_seq $ Name_term $ mkSimpleId m] nullRange, Term_seq $ Name_term n] ) nullRange]) + (typeFunction (mkSimpleId "buml:leq") [mkSimpleId $ show l, n])) nullRange + where + [x, n] = map mkSimpleId $ generateNames [c1, p1, c2, p2, annotString t1, annotString t2, m] 2 + (c3mi, t3mi, i) = case p0 == p1 of + True -> (c2, t2, "1") + _ -> (c1, t1, "2") + --_ -> error $ "Error! unknown name: " ++ (show pi) + FLeqN (NumAttr (MFAttribute c p (MFType t cp))) l -> Quant_sent Universal [Name x, Name y, Name n] (ifSen (andSen [ typeFunction (mkSimpleId $ c ++ "." ++ p) [x, y], + (typeFunction (mkSimpleId $ "form:" ++ (map toLower $ show t) ++ "-size") [y, n])]) + (typeFunction (mkSimpleId "buml:leq") [n, mkSimpleId $ show l])) nullRange + where + [x, y, n] = map mkSimpleId $ generateNames [c, p, cp, annotString t] 3 + + + FLeqN (NumAss (MFAssociation a endL) p0) l -> Quant_sent Universal (map (\ p -> Name p) xs) + (ifSen (andSen $ (map (\ (x, c) -> typeFunction c [x]) (zip xs cs)) ++ + [Atom_sent (Atom (Name_term $ mkSimpleId "form:sequence-size") [Term_seq $ Funct_term (Name_term $ mkSimpleId "form:n-select") [Term_seq $ Name_term $ mkSimpleId a, Term_seq $ Name_term $ mkSimpleId $ show i, insertList xs, Term_seq $ Name_term n] nullRange]) nullRange]) + (typeFunction (mkSimpleId "buml:leq") [n, mkSimpleId $ show l])) nullRange + where + (n : xs) = map mkSimpleId $ generateNames ([show l, a, p0] ++ (map fst pcs)) $ (length pcs) + 1 + pcs = filter (\ (p, _) -> not $ p == p0) endL + cs = map (mkSimpleId . fst) pcs + i = snd $ head $ filter (\ ((p, _), _) -> p == p0) (zip endL [i0 | i0 <- [1 .. (length endL)]]) + + FLeqN (NumComp (MFComposition m p1 (MFType t1 c1) p2 (MFType t2 c2)) p0) l -> Quant_sent Universal [Name x] (ifSen (andSen [ (typeFunction (mkSimpleId c3mi) [x]), + Atom_sent (Atom (Name_term $ mkSimpleId $ "form:" ++ (map toLower $ show t3mi) ++ "-size") [Term_seq $ Funct_term (Name_term $ mkSimpleId $ "form:select" ++ i) [Term_seq $ Name_term x, Term_seq $ Name_term $ mkSimpleId m] nullRange, Term_seq $ Name_term n] ) nullRange]) + (typeFunction (mkSimpleId "buml:leq") [n, mkSimpleId $ show l])) nullRange + where + [x, n] = map mkSimpleId $ generateNames [c1, p1, c2, p2, annotString t1, annotString t2, m] 2 + (c3mi, t3mi, i) = case p0 == p1 of + True -> (c2, t2, "1") + _ -> (c1, t1, "2") + --_ -> error $ "Error! unknown name: " ++ (show pi) + + +insertList :: [Token] -> TERM_SEQ +insertList [] = Term_seq $ Name_term $ mkSimpleId "form:empty-sequence" +insertList (x : lis) = Term_seq $ Funct_term (Name_term $ mkSimpleId "form:sequence-insert") [Term_seq $ Name_term x, insertList lis] nullRange + +{-translatePackage :: Package -> [PHRASE] +translatePackage pack = (translateClasses (classes pack)) + ++ (map translateEnumPreamble $ ((Map.elems).packageEnums) pack) + ++ (foldl (++) [] $ (map translateComposition compositions)) + ++ (map translateComPair (pairs compositions)) + ++ (map translateAssociation (Map.elems $ associations pack)) + where compositions = filter isComposition $ Map.elems $ associations pack-} + +pairs :: [a] -> [(a, a)] +pairs [] = [] +pairs (x : lis) = [(x, y) | y <- (x : lis)] ++ (pairs lis) + + + +translateAssociation :: (String, [(String, Type)]) -> [TEXT_META] +translateAssociation (n, endL) = [phrases2TM [ Sentence $ typeFunction (mkSimpleId "form:Sequence") [mkSimpleId n], + Sentence $ Quant_sent Universal [Name t] (ifSen (typeFunction (mkSimpleId "form:sequence-member") [t, a]) (Quant_sent Existential (map (\ (x0, _) -> Name x0) endPairs) (andSen $ (map (\ (x0, c) -> typeFunction c [x0]) endPairs) ++ [(Atom_sent (Equation (Name_term t) (x2inserts $ map fst endPairs)) nullRange)]) nullRange)) nullRange]] + where + endPairs = zip names (map mkSimpleId endTypes) + endTypes = map (translateType . snd) endL --(map (translateType.defaultType.endTarget) $ ends as) + x = head $ filter (\ x0 -> not $ any (isPrefixOf x0) endTypes) allStrings + t = mkSimpleId "t" + a = mkSimpleId n + names = [mkSimpleId $ x ++ (show i) | i <- [1 .. (length $ endL)]] + allStrings = concatMap (\ s -> map (: s) $ ['a' .. 'z'] ++ ['0' .. '9']) $ "" : allStrings + x2inserts (x0 : (y : ls)) = Funct_term (Name_term $ mkSimpleId "form:sequence-insert") [Term_seq $ Name_term x0, Term_seq $ (x2inserts (y : ls))] nullRange + x2inserts [x0] = Funct_term (Name_term $ mkSimpleId "form:sequence-insert") [Term_seq $ Name_term x0, Term_seq $ Name_term $ mkSimpleId "form:empty-sequence"] nullRange + x2inserts [] = error "empty association" + +generateNames :: [String] -> Int -> [String] +generateNames lis n = [x ++ (show i) | i <- [1 .. n]] + where + x = head $ filter (\ x0 -> not $ any (isPrefixOf x0) lis) allStrings + allStrings = concatMap (\ s -> map (: s) $ ['a' .. 'z'] ++ ['0' .. '9']) $ "" : allStrings + +rlookup :: (Ord s) => Map.Map s t -> s -> Maybe t +rlookup m k = Map.lookup k m + +{-getCompoRelevants :: Association -> (Token, Token, Token) +getCompoRelevants ass = (mkSimpleId $ translateType $ defaultType (endTarget origin), + mkSimpleId $ assoName ass, + mkSimpleId $ translateType $ defaultType $ endTarget target) + where + origin = head $ filter isComposedEnd $ ends ass + target = case (filter (not.(origin==)) (ends ass)) of + (x:lis) -> x + [] -> error $ show $ ends ass + originToken = (translateType $ defaultType (endTarget origin))-} + +translateComPair :: (((String, ClassEntity), String, (String, Type)), ((String, ClassEntity), String, (String, Type))) -> TEXT_META +translateComPair ((_, n1, _), (_, n2, _)) = phrases2TM [Sentence $ Quant_sent Universal [Name o, Name op, Name i] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent ( Atom (Name_term $ mkSimpleId "form:sequence-member") [Term_seq $ Funct_term (Name_term $ mkSimpleId "form:pair") [Term_seq $ Name_term o, Term_seq $ Name_term i] nullRange, Term_seq $ Name_term $ m]) nullRange, Atom_sent ( Atom (Name_term $ mkSimpleId "form:sequence-member") [Term_seq $ Funct_term (Name_term $ mkSimpleId "form:pair") [Term_seq $ Name_term op, Term_seq $ Name_term i] nullRange, Term_seq $ Name_term mp]) nullRange] ) nullRange) (equalSen o op)) nullRange) nullRange] + where --(c1, m, c2) = getCompoRelevants a1 + --(c1p, mp, c2p) = getCompoRelevants a2 + o = mkSimpleId "o" + op = mkSimpleId "op" + i = mkSimpleId "i" + m = mkSimpleId n1 + mp = mkSimpleId n2 + + +equalSen :: Token -> Token -> SENTENCE +equalSen a b = (Atom_sent (Equation (Name_term a) (Name_term b)) nullRange) + + +ifSen :: SENTENCE -> SENTENCE -> SENTENCE +ifSen a b = Bool_sent (BinOp Implication a b) nullRange + +iffSen :: SENTENCE -> SENTENCE -> SENTENCE +iffSen a b = Bool_sent (BinOp Biconditional a b) nullRange + +andSen :: [SENTENCE] -> SENTENCE +andSen sens = Bool_sent (Junction Conjunction sens) nullRange + + +translateComposition :: ((String, ClassEntity), String, (String, Type)) -> [TEXT_META] +translateComposition ((on, ot), n, (tn, tt)) = (translateComposition2 (mkSimpleId $ showClassEntityName ot, mkSimpleId n, mkSimpleId $ translateType tt)) ++ (map fromJust $ filter (not . isNothing) [translateEndCoin n 1 (on, defaultType ot), translateEndCoin n 2 (tn, tt)]) + +translateComposition2 :: (Token, Token, Token) -> [TEXT_META] +translateComposition2 (c1, m, c2) = [phrases2TM [ + Sentence $ typeFunction (mkSimpleId "form:Sequence") [m], + Sentence $ Quant_sent Universal [Name p] (Bool_sent (BinOp Implication (typeFunction (mkSimpleId "form:sequence-member") [p, m]) (Bool_sent (Junction Conjunction [typeFunction (mkSimpleId "form:Pair") [p], Atom_sent ( Atom (Name_term c1) [Term_seq $ Funct_term (Name_term $ mkSimpleId "form:first") [Term_seq $ Name_term p] nullRange]) nullRange, Atom_sent ( Atom (Name_term c2) [Term_seq $ Funct_term (Name_term $ mkSimpleId "form:second") [Term_seq $ Name_term p] nullRange]) nullRange] ) nullRange)) nullRange) nullRange]] + where p = mkSimpleId "p" + + + +{-[ Sentence $ Quant_sent Universal [Name x] ( + Bool_sent (BinOp Implication (typeFunction origin [x]) (Quant_sent Existential [Name y] (Bool_sent(Junction Conjunction [ + typeFunction comp [x, y], + typeFunction target [y] + ]) nullRange) nullRange)) nullRange) nullRange, + + Sentence $ Quant_sent Universal [Name x, Name y] ( + Bool_sent (BinOp Implication (typeFunction comp [x, y]) (Bool_sent(Junction Conjunction [ + typeFunction origin [x], + typeFunction target [y] + ]) nullRange)) nullRange) nullRange, + + Sentence $ Quant_sent Universal [Name x, Name y, Name z] ( + Bool_sent (BinOp Implication (Bool_sent(Junction Conjunction [ + typeFunction comp [x, y], + typeFunction comp [x, z] + ]) nullRange) (typeFunction (mkSimpleId "=") [y, z] )) nullRange) nullRange] + where x = mkSimpleId "x" + y = mkSimpleId "y" + z = mkSimpleId "z"-} + +translateEnumPreamble :: UML.UML.Enum -> TEXT_META +translateEnumPreamble en = phrases2TM [Sentence $ typeFunction (mkSimpleId "enumeration") $ (mkSimpleId $ enumName en) : (map (mkSimpleId . literalName) (enumLiterals en))] + +{-translateClasses :: Map.Map UML.UML.Id UML.UML.Class -> [PHRASE] +translateClasses cmap = foldl (++) [] $ map translateClass (Map.elems cmap)-} + +{-translateClass :: ClassEntity -> [PHRASE] +translateClass cl = (translateInherit (CL cl) (super cl)) ++ (foldl (++) [] (map (translateAttribute cl) (attr cl))) ++ (foldl (++) [] (map (translateProcedure cl) (proc cl)))-} + + +translateInherit :: (ClassEntity, ClassEntity) -> TEXT_META +translateInherit (cl, superc) = phrases2TM [(Sentence (Quant_sent Universal [Name t] (Bool_sent (BinOp Implication + (typeFunction (mkSimpleId (showClassEntityName cl)) [t]) + (typeFunction (mkSimpleId (showClassEntityName superc)) [t])) nullRange) nullRange))] + where t = mkSimpleId "x" + + +typeFunction :: Token -> [Token] -> SENTENCE +typeFunction f l = Atom_sent (Atom (Name_term f) (map (\ t -> Term_seq $ Name_term t) l)) nullRange + +--typeFunction :: Token -> [Token] -> TERM +--typeFunction f l = (Funct_term (Name_term f) (map (\t -> Term_seq (Name_term t)) l) nullRange) + +typeFunctionSeq :: Token -> [NAME_OR_SEQMARK] -> SENTENCE +typeFunctionSeq f l = Atom_sent (Atom (Name_term f) (map termNOS l)) nullRange + +termNOS :: NAME_OR_SEQMARK -> TERM_SEQ +termNOS (Name n) = Term_seq $ Name_term n +termNOS (SeqMark s) = Seq_marks s + +translateProperty :: Token -> [(Token, Token)] -> SENTENCE -> PHRASE +translateProperty c l sen = Sentence (Quant_sent Universal (map (\ (_, b) -> Name b) l) (Bool_sent (BinOp Implication ((typeFunction c (map snd l))) (sen) ) nullRange) nullRange) + +translateAttribute :: (Class, String, Type) -> [TEXT_META] +translateAttribute (cl, n, t) = map phrase2TM $ mem ++ (map (translateProperty attrt l) sens) + where + x = mkSimpleId "x" + y = mkSimpleId "y" + l = [(c, x), (cp, y)] + sens = [typeFunction c [x], translateTau m (cp, cptar, y)] + attrt = mkSimpleId $ (className cl) ++ "." ++ n + c = mkSimpleId $ translateType $ defaultType $ CL cl + cp = mkSimpleId $ translateType t + cptar = mkSimpleId $ translateTargetType t + m = (mkSimpleId "m") + mem = [ --(memberRule attrt l (cp, y) ), + leftTotallityRule attrt l (cp, y), + rightUniqueRule attrt l (cp, y) (mkSimpleId "z")] + +translateTau :: Token -> (Token, Token, Token) -> SENTENCE +translateTau m (c, t, x) = andSen [typeFunction (mkSimpleId $ "form:" ++ (tokStr t)) [x], Quant_sent Universal [Name m] (ifSen (typeFunction (mkSimpleId $ "form:" ++ (map toLower $ tokStr t) ++ "-member") [m, x]) (typeFunction c [m])) nullRange] + +translateTuple :: (Token, Token) -> SENTENCE +translateTuple (c, x) = typeFunction c [x] + +{-memberRule :: Token -> [(Token, Token)] -> (Token, Token) -> Token -> PHRASE +memberRule c l (cy, y) m = Sentence (Quant_sent Universal (map (\(a, b) -> Name b) (l++[(m, m)])) (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [( (typeFunction c (map snd l))), (typeFunction (mkSimpleId "member") [m, y] )] ) nullRange ) ( (typeFunction cy [m])) ) nullRange) nullRange) -} + +translateProcedure :: (Class, String, [(String, Type)], Type) -> [TEXT_META] +translateProcedure (cl, n, paras, t) = map phrase2TM $ mem ++ (map (translateProperty proct l) sens) + where + x = mkSimpleId $ getStringNotInList "x" paraNames + y = mkSimpleId $ getStringNotInList "y" ((tokStr x) : paraNames) + sens = (map translateTuple ([(c, x)] ++ (map (translateParameter) paras))) ++ [translateTau m (mkSimpleId $ translateUMLType $ umltype t, mkSimpleId $ translateTargetType t, y)] + l = case Just t of + Nothing -> [(c, x)] ++ (map (translateParameter) paras) + Just ret -> [(c, x)] ++ (map (translateParameter) paras) ++ [(mkSimpleId (translateType ret), y)] + mem = case Just t of + Nothing -> [] + Just ret -> [ --(memberRule proct l (mkSimpleId (translateType ret), y) (mkSimpleId $ getStringNotInList "m" ([(tokStr x)++(tokStr y)]++paraNames))), + leftTotallityRule proct l (mkSimpleId (translateType ret), y), + rightUniqueRule proct l (mkSimpleId (translateType ret), y) (mkSimpleId $ getStringNotInList "z" ([(tokStr x) ++ (tokStr y)] ++ paraNames))] + paraNames = map fst paras + m = mkSimpleId "m" + proct = mkSimpleId $ (className cl) ++ "." ++ n + c = mkSimpleId $ translateType ctype + ctype = Type { umltype = CE $ CL cl, + typeOrdered = False, + typeUnique = True} + +leftTotallityRule :: Token -> [(Token, Token)] -> (Token, Token) -> PHRASE +leftTotallityRule c l (cz, z) = Sentence (Quant_sent Universal (map (\ (_, b) -> Name b) (delete (cz, z) l)) (Quant_sent Existential [Name z] (typeFunction c (map snd l)) nullRange) nullRange) + +{-translateCompLabel :: Association -> [PHRASE] +translateCompLabel ass = (foldl (++) [] $ map ((translateCompLabel1 (mkSimpleId $ assoName ass)).label) (ends ass)) + +translateCompLabel1 :: Token -> Label -> [PHRASE] +translateCompLabel1 r l = map (translateCompLabel2 r) $ case upperValue l of + "*" ->[(mkSimpleId "geq", mkSimpleId $ lowerValue l)] + _ -> [(mkSimpleId "geq", mkSimpleId $ lowerValue l), (mkSimpleId "leq", mkSimpleId $ upperValue l)] + +translateCompLabel2 :: Token -> (Token, Token) -> PHRASE +translateCompLabel2 r (f, l) = Sentence (Quant_sent Universal [Name x, Name y, Name n] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [ typeFunction r [x, y], typeFunction (mkSimpleId "form:sequence-length") [y, n]]) nullRange) (typeFunction f [l, n])) nullRange) nullRange) + where + x = mkSimpleId "x" + y = mkSimpleId "y" + n = mkSimpleId "n" + +translateAssoLabel :: Association -> [PHRASE] +translateAssoLabel ass = map (translateAssoLabel2 (mkSimpleId $ assoName ass) (zip endNames (map mkSimpleId classNames))) [(map (mkSimpleId.lowerValue.label) (ends ass), "min-card-tuple"), (map (mkSimpleId.upperValue.label) (ends ass), "max-card-tuple")] + where endNames = map mkSimpleId $ generateNames ((assoName ass):classNames) (length classNames) + classNames = (map (translateType.defaultType.endTarget) (ends ass)) + +translateAssoLabel2 :: Token -> [(Token, Token)] -> ([Token], String) -> PHRASE +translateAssoLabel2 a xcl (sels, f)= Sentence (Quant_sent Universal (map (\(x, c)-> Name x) xcl) (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction (map (\(x, c) -> typeFunction c [x]) xcl)) nullRange) (Atom_sent (Atom (Funct_term (Name_term $ mkSimpleId f) ((Term_seq $ Name_term a) : (map (\(x, c) -> Term_seq $ Name_term x) xcl)) nullRange) (map (\t -> Term_seq (Name_term $ t)) sels)) nullRange)) nullRange) nullRange)-} + +rightUniqueRule :: Token -> [(Token, Token)] -> (Token, Token) -> Token -> PHRASE +rightUniqueRule c l (_, y) z = Sentence (Quant_sent Universal ((map (\ (_, b) -> Name b) l) ++ [Name z]) (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [( (typeFunction c (map snd l))), ((typeFunction c (((delete y (map snd l)) ++ [z]))))]) nullRange) (Atom_sent (Equation (Name_term y) (Name_term z)) nullRange) ) nullRange) nullRange) + +memberRule :: Token -> [(Token, Token)] -> (Token, Token) -> Token -> PHRASE +memberRule c l (cy, y) m = Sentence (Quant_sent Universal (map (\ (_, b) -> Name b) (l ++ [(m, m)])) (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [( (typeFunction c (map snd l))), (typeFunction (mkSimpleId "member") [m, y] )] ) nullRange ) ( (typeFunction cy [m])) ) nullRange) nullRange) + +translateParameter :: (String, Type) -> (Token, Token) +translateParameter (s, t) = ( mkSimpleId (translateType $ t), mkSimpleId $ s) + + +translateType :: Type -> String +translateType t = translateUMLType $ umltype t + +translateTargetType :: Type -> String +translateTargetType t = listType -- ++ "[" ++ (translateUMLType $ umltype t) ++ "]" + where listType = case (typeOrdered t, typeUnique t) of + (True, True) -> "Ordered-Set" + (True, False) -> "Sequence" + (False, True) -> "Set" + (False, False) -> "Bag" + +translateUMLType :: UMLType -> String +translateUMLType UMLBool = "buml:Boolean" +translateUMLType UMLString = "buml:String" +translateUMLType UMLInteger = "buml:Integer" +translateUMLType UMLUnlimitedNatural = "form:NaturalNumber" +translateUMLType UMLReal = "buml:Real" +translateUMLType (CE x) = showClassEntityName x +translateUMLType t = error $ "TypeTranslation unimplemented:" ++ show t + + + +--Sign + + +retrieveSen :: CM -> [Sen] +retrieveSen m = foldl (++) [] ((map class2MFs $ fmap CL (Map.elems $ cmClasses m)) + ++ (map asso2MFs (filter (not . isComposition) $ Map.elems $ cmAssociations m)) + ++ (map comp2MFs (filter (isComposition) $ Map.elems $ cmAssociations m)) + ++ map retrieveSenPack (cmPackages m)) + +retrieveSenPack :: Package -> [Sen] +retrieveSenPack pack = foldl (++) [] ((map class2MFs $ fmap CL (Map.elems $ classes pack)) + ++ (map asso2MFs (filter (not . isComposition) $ Map.elems $ associations pack)) + ++ (map comp2MFs (filter (isComposition) $ Map.elems $ associations pack)) + ++ map retrieveSenPack (packagePackages pack)) + +class2MFs :: ClassEntity -> [Sen] +class2MFs (CL cl) = foldl (++) [] $ map (attr2MFs cl) (attr cl) +class2MFs (AC ac) = class2MFs (CL $ acClass ac) +class2MFs (EN _) = [] +class2MFs (DT _) = [] + +attr2MFs :: Class -> Attribute -> [Sen] +attr2MFs cl attri = bounds2MFs (attrLowerValue attri) (attrUpperValue attri) (NumAttr $ MFAttribute (className cl) (attrName attri) (type2mftype $ attrType attri) ) + +bounds2MFs :: String -> String -> FunExpr -> [Sen] +bounds2MFs low upp fe = (NLeqF (read low) fe) : + case upp of + "*" -> [] + _ -> [FLeqN fe (read upp)] + +end2StrMFT :: End -> (String, MFTYPE) +end2StrMFT end = (fromJust $ endName end, type2mftype $ defaultType $ endTarget end) + +asso2MFs :: Association -> [Sen] +asso2MFs ass = foldl (++) [] $ map (end2MFs (NumAss (MFAssociation (assoName ass) (map end2StrMFT (ends ass))))) (ends ass) + + +end2MFs :: (String -> FunExpr) -> End -> [Sen] +end2MFs an end = bounds2MFs (lowerValue $ label end) (upperValue $ label end) (an $ fromJust $ endName end) + +comp2MFs :: Association -> [Sen] +comp2MFs comp = foldl (++) [] $ map (end2MFs (NumComp $ MFComposition (assoName comp) (fromJust $ endName origin) (MFType Set (showClassEntityName $ endTarget origin)) (fromJust $ endName target) (type2mftype $ defaultType $ endTarget target) )) (ends comp) + where + origin = head $ filter isComposedEnd $ ends comp + target = case (filter (not . (origin ==)) (ends comp)) of + (x : _) -> x + [] -> error $ show $ ends comp + + +retrieveSign :: CM -> UML.Sign.Sign +retrieveSign cm = UML.Sign.Sign { + signClassHier = ((foldl (++) [] (map (fst . signClassHier) packSigs)) ++ (fmap EN enumLis) ++ (map (\ c -> CL c) classLis), (foldl (++) [] (map (snd . signClassHier) packSigs)) ++ (foldl (++) [] (map classToHier classLis))), + signAttribute = (foldl (++) [] (map signAttribute packSigs)) ++ attributes, + signOperations = (foldl (++) [] (map signOperations packSigs)) ++ procedures, + signCompositions = (foldl (++) [] (map signCompositions packSigs)) ++ compositions, + signAssociations = (foldl (++) [] (map signAssociations packSigs)) ++ associations0 + } + where + classLis = Map.elems (cmClasses cm) + enumLis = Map.elems (cmEnums cm) + --assoClasses = Map.elems (translateAssociationClasses (cmClasses cm)) + attributes = foldl (++) [] $ map (\ c -> map (signTranslateAttr c) (attr c)) classLis + compositions = map signTranslateComposition $ filter isComposition $ Map.elems $ cmAssociations cm + procedures = foldl (++) [] $ map (\ c -> map (signTranslateProc c) $ filter (isJust . procReturnType) (proc c)) classLis + associations0 = map signTranslateAsso $ filter (not . isComposition) $ Map.elems (cmAssociations cm) + packSigs = map retrieveSignPackage (cmPackages cm) + +retrieveSignPackage :: UML.UML.Package -> UML.Sign.Sign +retrieveSignPackage pack = UML.Sign.Sign { + signClassHier = ((foldl (++) [] (map (fst . signClassHier) packSigs)) ++ (fmap EN enumLis) ++ (map (\ c -> CL c) classLis), (foldl (++) [] (map (snd . signClassHier) packSigs)) ++ (foldl (++) [] (map classToHier classLis))), + signAttribute = (foldl (++) [] (map signAttribute packSigs)) ++ attributes, + signOperations = (foldl (++) [] (map signOperations packSigs)) ++ procedures, + signCompositions = (foldl (++) [] (map signCompositions packSigs)) ++ compositions, + signAssociations = (foldl (++) [] (map signAssociations packSigs)) ++ associations0 + } + where + classLis = Map.elems (classes pack) + enumLis = Map.elems (packageEnums pack) + --assoClasses = Map.elems (translateAssociationClasses (cmClasses cm)) + attributes = foldl (++) [] $ map (\ c -> map (signTranslateAttr c) (attr c)) classLis + compositions = map signTranslateComposition $ filter isComposition $ Map.elems $ associations pack + procedures = foldl (++) [] $ map (\ c -> map (signTranslateProc c) $ filter (isJust . procReturnType) (proc c)) classLis -- TODO: Add handling for empty return + associations0 = map signTranslateAsso $ filter (not . isComposition) $ Map.elems $ associations pack + packSigs = map retrieveSignPackage (packagePackages pack) + +extractClasses :: [ClassEntity] -> [Class] +extractClasses [] = [] +extractClasses ((CL c) : lis) = c : (extractClasses lis) +extractClasses (_ : lis) = (extractClasses lis) + +signTranslateAttr :: Class -> Attribute -> (Class, String, Type) +signTranslateAttr c a = (c, attrName a, attrType a) + + +signTranslateProc :: Class -> Procedure -> (Class, String, [(String, Type)], Type) +signTranslateProc c proce = (c, procName proce, map (\ attri -> (attrName attri, attrType attri)) (procPara proce), fromJust $ procReturnType proce) + +signTranslateComposition :: Association -> ((String, ClassEntity), String, (String, Type)) +signTranslateComposition comp = ((fromJust $ endName origin, endTarget origin), assoName comp, (fromJust $ endName target, defaultType $ endTarget target)) + where + origin = head $ filter isComposedEnd $ ends comp + target = case (filter (not . (origin ==)) (ends comp)) of + (x : _) -> x + [] -> error $ show $ ends comp +signTranslateAsso :: Association -> (String, [(String, Type)]) +signTranslateAsso ass = (assoName ass, map signTranslateEnd (ends ass)) + +signTranslateEnd :: End -> (String, Type) +signTranslateEnd e = (fromJust $ endName e, defaultType $ endTarget e) + +classToHier :: Class -> [(ClassEntity, ClassEntity)] +classToHier cl = zip [CL cl] (getAllSupers (CL cl)) + +getAllSupers :: ClassEntity -> [ClassEntity] +getAllSupers (CL cl) = (super cl) ++ (foldl (++) [] $ map getAllSupers (super cl)) +getAllSupers _ = [] + diff --git a/UML/UML2CL_preamble.hs b/UML/UML2CL_preamble.hs new file mode 100644 index 0000000000..eb42b6070a --- /dev/null +++ b/UML/UML2CL_preamble.hs @@ -0,0 +1,662 @@ +module UML.UML2CL_preamble where + +import Common.Id as Id +import CommonLogic.AS_CommonLogic +import qualified Data.Set as Set + +pairsdiscourseNames :: Set.Set Id +pairsdiscourseNames = Set.fromList [stringToId "form:Pair", stringToId "form:first", stringToId "form:pair", stringToId "form:second"] +pairsnondiscourseNames :: Set.Set Id +pairsnondiscourseNames = Set.fromList [] +pairssequenceMarkers :: Set.Set Id +pairssequenceMarkers = Set.fromList [] +pairsSens1 :: [PHRASE] +pairsSens1 = [Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "y")] (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:first")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:pair")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "y"))] nullRange)] nullRange) (Name_term (mkSimpleId "x"))) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "y")] (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:second")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:pair")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "y"))] nullRange)] nullRange) (Name_term (mkSimpleId "y"))) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "y")] (Atom_sent (Atom (Name_term (mkSimpleId "form:Pair")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:pair")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "y"))] nullRange)]) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "p")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Pair")) [Term_seq (Name_term (mkSimpleId "p"))]) nullRange) (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:pair")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:first")) [Term_seq (Name_term (mkSimpleId "p"))] nullRange), Term_seq (Funct_term (Name_term (mkSimpleId "form:second")) [Term_seq (Name_term (mkSimpleId "p"))] nullRange)] nullRange) (Name_term (mkSimpleId "p"))) nullRange)) nullRange) nullRange)] +pairsSens :: [[PHRASE]] +pairsSens = [pairsSens1] + +uml_enumerationsdiscourseNames :: Set.Set Id +uml_enumerationsdiscourseNames = Set.fromList [stringToId "c", stringToId "distinct", stringToId "enumeration", stringToId "exhaustive", stringToId "oneof", stringToId "x", stringToId "y"] +uml_enumerationsnondiscourseNames :: Set.Set Id +uml_enumerationsnondiscourseNames = Set.fromList [] +uml_enumerationssequenceMarkers :: Set.Set Id +uml_enumerationssequenceMarkers = Set.fromList [stringToId "..."] +uml_enumerationsSens1 :: [PHRASE] +uml_enumerationsSens1 = [Sentence (Atom_sent (Atom (Name_term (mkSimpleId "distinct")) []) nullRange), + Sentence (Atom_sent (Atom (Name_term (mkSimpleId "distinct")) [Term_seq (Name_term (mkSimpleId "x"))]) nullRange), + Sentence (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "distinct")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "y")), Seq_marks (mkSimpleId "...")]) nullRange) (Bool_sent (Junction Conjunction [Bool_sent (Negation (Atom_sent (Equation (Name_term (mkSimpleId "x")) (Name_term (mkSimpleId "y"))) nullRange)) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "distinct")) [Term_seq (Name_term (mkSimpleId "x")), Seq_marks (mkSimpleId "...")]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "distinct")) [Term_seq (Name_term (mkSimpleId "y")), Seq_marks (mkSimpleId "...")]) nullRange]) nullRange)) nullRange), + Sentence (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "exhaustive")) [Term_seq (Name_term (mkSimpleId "c")), Seq_marks (mkSimpleId "...")]) nullRange) (Quant_sent Universal [Name (mkSimpleId "x")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "c")) [Term_seq (Name_term (mkSimpleId "x"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "oneof")) [Term_seq (Name_term (mkSimpleId "x")), Seq_marks (mkSimpleId "...")]) nullRange)) nullRange) nullRange)) nullRange), + Sentence (Bool_sent (Negation (Atom_sent (Atom (Name_term (mkSimpleId "oneof")) [Term_seq (Name_term (mkSimpleId "x"))]) nullRange)) nullRange), + Sentence (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "oneof")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "y")), Seq_marks (mkSimpleId "...")]) nullRange) (Bool_sent (Junction Disjunction [Atom_sent (Equation (Name_term (mkSimpleId "x")) (Name_term (mkSimpleId "y"))) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "oneof")) [Term_seq (Name_term (mkSimpleId "x")), Seq_marks (mkSimpleId "...")]) nullRange]) nullRange)) nullRange), + Sentence (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "enumeration")) [Term_seq (Name_term (mkSimpleId "c")), Seq_marks (mkSimpleId "...")]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "exhaustive")) [Term_seq (Name_term (mkSimpleId "c")), Seq_marks (mkSimpleId "...")]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "distinct")) [Seq_marks (mkSimpleId "...")]) nullRange]) nullRange)) nullRange)] +uml_enumerationsSens :: [[PHRASE]] +uml_enumerationsSens = [uml_enumerationsSens1] + +bagsdiscourseNames :: Set.Set Id +bagsdiscourseNames = Set.fromList [stringToId "buml:UnlimitedNatural", stringToId "form:0", stringToId "form:Bag", stringToId "form:add-one", stringToId "form:bag-insert", stringToId "form:bag-member", stringToId "form:bag-member-count", stringToId "form:bag-size", stringToId "form:empty-bag", stringToId "form:same-bag"] +bagsnondiscourseNames :: Set.Set Id +bagsnondiscourseNames = Set.fromList [] +bagssequenceMarkers :: Set.Set Id +bagssequenceMarkers = Set.fromList [] +bagsSens1 :: [PHRASE] +bagsSens1 = [Sentence (Quant_sent Universal [Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:empty-bag")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:Bag")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Bag")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:empty-bag")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "x")] (Atom_sent (Atom (Name_term (mkSimpleId "form:bag-member")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))]) nullRange) nullRange)) nullRange)) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "n")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:bag-size")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "n"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Bag")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "buml:UnlimitedNatural")) [Term_seq (Name_term (mkSimpleId "n"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:bag-size")) [Term_seq (Name_term (mkSimpleId "form:empty-bag"))] nullRange) (Name_term (mkSimpleId "form:0"))) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "s")] (Quant_sent Existential [Name (mkSimpleId "n")] (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:add-one")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:bag-size")) [Term_seq (Name_term (mkSimpleId "s"))] nullRange), Term_seq (Name_term (mkSimpleId "n"))]) nullRange, Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:bag-size")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:bag-insert")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange) (Name_term (mkSimpleId "n"))) nullRange]) nullRange) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s1"), Name (mkSimpleId "s2")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:same-bag")) [Term_seq (Name_term (mkSimpleId "s1")), Term_seq (Name_term (mkSimpleId "s2"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Bag")) [Term_seq (Name_term (mkSimpleId "s1"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:Bag")) [Term_seq (Name_term (mkSimpleId "s2"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s1"), Name (mkSimpleId "s2")] (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:same-bag")) [Term_seq (Name_term (mkSimpleId "s1")), Term_seq (Name_term (mkSimpleId "s2"))]) nullRange) (Quant_sent Universal [Name (mkSimpleId "x")] (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:bag-member-count")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s1"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:bag-member-count")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s2"))]) nullRange)) nullRange) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Bag")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:Bag")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:bag-insert")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "y"), Name (mkSimpleId "s")] (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:bag-member")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Funct_term (Name_term (mkSimpleId "form:bag-insert")) [Term_seq (Name_term (mkSimpleId "y")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)]) nullRange) (Bool_sent (Junction Disjunction [Atom_sent (Equation (Name_term (mkSimpleId "x")) (Name_term (mkSimpleId "y"))) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:bag-member")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Bag")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "buml:UnlimitedNatural")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:bag-member-count")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)]) nullRange)) nullRange) nullRange), + Sentence (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:bag-member-count")) [Term_seq (Name_term (mkSimpleId "form:empty-bag"))] nullRange) (Name_term (mkSimpleId "form:0"))) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "s")] (Quant_sent Existential [Name (mkSimpleId "n")] (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:add-one")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:bag-member-count")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))] nullRange), Term_seq (Name_term (mkSimpleId "n"))]) nullRange, Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:bag-member-count")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Funct_term (Name_term (mkSimpleId "form:bag-insert")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange) (Name_term (mkSimpleId "n"))) nullRange]) nullRange) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "y"), Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Bool_sent (Negation (Atom_sent (Equation (Name_term (mkSimpleId "x")) (Name_term (mkSimpleId "y"))) nullRange)) nullRange) (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:bag-member-count")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Funct_term (Name_term (mkSimpleId "form:bag-insert")) [Term_seq (Name_term (mkSimpleId "y")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange) (Funct_term (Name_term (mkSimpleId "form:bag-member-count")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)) nullRange)) nullRange) nullRange)] +bagsSens :: [[PHRASE]] +bagsSens = [bagsSens1] + +booleandiscourseNames :: Set.Set Id +booleandiscourseNames = Set.fromList [stringToId "buml:Boolean", stringToId "form:and", stringToId "form:false", stringToId "form:not", stringToId "form:true"] +booleannondiscourseNames :: Set.Set Id +booleannondiscourseNames = Set.fromList [] +booleansequenceMarkers :: Set.Set Id +booleansequenceMarkers = Set.fromList [] +booleanSens1 :: [PHRASE] +booleanSens1 = [Sentence (Quant_sent Universal [Name (mkSimpleId "x")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "buml:Boolean")) [Term_seq (Name_term (mkSimpleId "x"))]) nullRange) (Bool_sent (Junction Disjunction [Atom_sent (Equation (Name_term (mkSimpleId "x")) (Name_term (mkSimpleId "form:true"))) nullRange, Atom_sent (Equation (Name_term (mkSimpleId "x")) (Name_term (mkSimpleId "form:false"))) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Bool_sent (Negation (Atom_sent (Equation (Name_term (mkSimpleId "form:true")) (Name_term (mkSimpleId "form:false"))) nullRange)) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "y")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:not")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "y"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "buml:Boolean")) [Term_seq (Name_term (mkSimpleId "x"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "buml:Boolean")) [Term_seq (Name_term (mkSimpleId "y"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "y")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:not")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "y"))]) nullRange) (Bool_sent (Negation (Atom_sent (Equation (Name_term (mkSimpleId "x")) (Name_term (mkSimpleId "y"))) nullRange)) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "y"), Name (mkSimpleId "z")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:and")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "y")), Term_seq (Name_term (mkSimpleId "z"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "buml:Boolean")) [Term_seq (Name_term (mkSimpleId "x"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "buml:Boolean")) [Term_seq (Name_term (mkSimpleId "y"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "buml:Boolean")) [Term_seq (Name_term (mkSimpleId "z"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "y"), Name (mkSimpleId "z")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:and")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "y")), Term_seq (Name_term (mkSimpleId "z"))]) nullRange) (Bool_sent (Junction Conjunction [Bool_sent (BinOp Biconditional (Atom_sent (Equation (Name_term (mkSimpleId "z")) (Name_term (mkSimpleId "form:false"))) nullRange) (Bool_sent (Junction Disjunction [Atom_sent (Equation (Name_term (mkSimpleId "x")) (Name_term (mkSimpleId "form:false"))) nullRange, Atom_sent (Equation (Name_term (mkSimpleId "y")) (Name_term (mkSimpleId "form:false"))) nullRange]) nullRange)) nullRange, Bool_sent (BinOp Biconditional (Atom_sent (Equation (Name_term (mkSimpleId "z")) (Name_term (mkSimpleId "form:true"))) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Equation (Name_term (mkSimpleId "x")) (Name_term (mkSimpleId "form:true"))) nullRange, Atom_sent (Equation (Name_term (mkSimpleId "y")) (Name_term (mkSimpleId "form:true"))) nullRange]) nullRange)) nullRange]) nullRange)) nullRange) nullRange)] +booleanSens :: [[PHRASE]] +booleanSens = [booleanSens1] + +clsequencesdiscourseNames :: Set.Set Id +clsequencesdiscourseNames = Set.fromList [stringToId "buml:Sequence", stringToId "buml:UnlimtedNatural", stringToId "form:0", stringToId "form:1", stringToId "form:NaturalNumber", stringToId "form:Position", stringToId "form:Sequence", stringToId "form:add-one", stringToId "form:before-in-sequence", stringToId "form:empty-sequence", stringToId "form:in-position", stringToId "form:in-position-count", stringToId "form:in-sequence", stringToId "form:position-count", stringToId "form:same-sequence", stringToId "form:sequence-length"] +clsequencesnondiscourseNames :: Set.Set Id +clsequencesnondiscourseNames = Set.fromList [] +clsequencessequenceMarkers :: Set.Set Id +clsequencessequenceMarkers = Set.fromList [] +clsequencesSens1 :: [PHRASE] +clsequencesSens1 = [Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:Position")) [Term_seq (Name_term (mkSimpleId "pt"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s1"), Name (mkSimpleId "s2"), Name (mkSimpleId "pt")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:in-sequence")) [Term_seq (Name_term (mkSimpleId "s1")), Term_seq (Name_term (mkSimpleId "pt"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:in-sequence")) [Term_seq (Name_term (mkSimpleId "s2")), Term_seq (Name_term (mkSimpleId "pt"))]) nullRange]) nullRange) (Atom_sent (Equation (Name_term (mkSimpleId "s1")) (Name_term (mkSimpleId "s2"))) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "pt")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Position")) [Term_seq (Name_term (mkSimpleId "pt"))]) nullRange) (Quant_sent Existential [Name (mkSimpleId "s")] (Atom_sent (Atom (Name_term (mkSimpleId "form:in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt"))]) nullRange) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt1"), Name (mkSimpleId "pt2")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "buml:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:Position")) [Term_seq (Name_term (mkSimpleId "pt1"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:Position")) [Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt1"), Name (mkSimpleId "pt2")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "s"), Name (mkSimpleId "pt1"), Name (mkSimpleId "pt2")] (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt2")), Term_seq (Name_term (mkSimpleId "pt1"))]) nullRange]) nullRange) nullRange)) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt1"), Name (mkSimpleId "pt2"), Name (mkSimpleId "pt11"), Name (mkSimpleId "pt22")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt11")), Term_seq (Name_term (mkSimpleId "pt22"))]) nullRange]) nullRange) (Bool_sent (BinOp Biconditional (Atom_sent (Equation (Name_term (mkSimpleId "pt1")) (Name_term (mkSimpleId "pt11"))) nullRange) (Atom_sent (Equation (Name_term (mkSimpleId "pt2")) (Name_term (mkSimpleId "pt22"))) nullRange)) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Bool_sent (BinOp Implication (Quant_sent Existential [Name (mkSimpleId "pt")] (Atom_sent (Atom (Name_term (mkSimpleId "form:in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt"))]) nullRange) nullRange) (Bool_sent (Junction Conjunction [Quant_sent Existential [Name (mkSimpleId "pt1")] (Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt2")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) nullRange)) nullRange) nullRange, Quant_sent Existential [Name (mkSimpleId "pt2")] (Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt1")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) nullRange)) nullRange) nullRange]) nullRange)) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt1"), Name (mkSimpleId "pt11")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt2")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) nullRange)) nullRange, Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt2")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt11")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) nullRange)) nullRange]) nullRange) (Atom_sent (Equation (Name_term (mkSimpleId "pt1")) (Name_term (mkSimpleId "pt11"))) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Quant_sent Existential [Name (mkSimpleId "pt2")] (Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt1")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) nullRange)) nullRange) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt2"), Name (mkSimpleId "pt22")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt1")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) nullRange)) nullRange, Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt1")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt22"))]) nullRange) nullRange)) nullRange]) nullRange) (Atom_sent (Equation (Name_term (mkSimpleId "pt2")) (Name_term (mkSimpleId "pt22"))) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:empty-sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:empty-sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt")] (Atom_sent (Atom (Name_term (mkSimpleId "form:in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt"))]) nullRange) nullRange)) nullRange)) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt"), Name (mkSimpleId "n")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "n"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:Position")) [Term_seq (Name_term (mkSimpleId "pt"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "buml:UnlimtedNatural")) [Term_seq (Name_term (mkSimpleId "n"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt"), Name (mkSimpleId "n1"), Name (mkSimpleId "n2")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "n1"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "n2"))]) nullRange]) nullRange) (Atom_sent (Equation (Name_term (mkSimpleId "n1")) (Name_term (mkSimpleId "n2"))) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt"))]) nullRange) (Quant_sent Existential [Name (mkSimpleId "n")] (Atom_sent (Atom (Name_term (mkSimpleId "form:position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "n"))]) nullRange) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt2")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt1")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) nullRange)) nullRange]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt2")), Term_seq (Name_term (mkSimpleId "form:1"))]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt1"), Name (mkSimpleId "n1"), Name (mkSimpleId "pt2"), Name (mkSimpleId "n2")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "n1"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt2")), Term_seq (Name_term (mkSimpleId "n2"))]) nullRange]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:add-one")) [Term_seq (Name_term (mkSimpleId "n1")), Term_seq (Name_term (mkSimpleId "n2"))]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "n")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:sequence-length")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "n"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "buml:UnlimtedNatural")) [Term_seq (Name_term (mkSimpleId "n"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "n")] (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:sequence-length")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "n"))]) nullRange) (Bool_sent (Junction Disjunction [Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:empty-sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Atom_sent (Equation (Name_term (mkSimpleId "n")) (Name_term (mkSimpleId "form:0"))) nullRange]) nullRange, Quant_sent Existential [Name (mkSimpleId "pt1")] (Bool_sent (Junction Conjunction [Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt2")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) nullRange)) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "n"))]) nullRange]) nullRange) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "pt"), Name (mkSimpleId "x")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:in-position")) [Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:Position")) [Term_seq (Name_term (mkSimpleId "pt"))]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "pt"), Name (mkSimpleId "x1"), Name (mkSimpleId "x2")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:in-position")) [Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "x1"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:in-position")) [Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "x2"))]) nullRange]) nullRange) (Atom_sent (Equation (Name_term (mkSimpleId "x1")) (Name_term (mkSimpleId "x2"))) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "pt")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Position")) [Term_seq (Name_term (mkSimpleId "pt"))]) nullRange) (Quant_sent Existential [Name (mkSimpleId "x")] (Atom_sent (Atom (Name_term (mkSimpleId "form:in-position")) [Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "n"), Name (mkSimpleId "x")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:in-position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "n")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "buml:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:NaturalNumber")) [Term_seq (Name_term (mkSimpleId "n"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "n"), Name (mkSimpleId "x")] (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:in-position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "n")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange) (Quant_sent Existential [Name (mkSimpleId "pt")] (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:in-position")) [Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "n"))]) nullRange]) nullRange) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s1"), Name (mkSimpleId "s2")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:same-sequence")) [Term_seq (Name_term (mkSimpleId "s1")), Term_seq (Name_term (mkSimpleId "s2"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s1"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s2"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s1"), Name (mkSimpleId "s2")] (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:same-sequence")) [Term_seq (Name_term (mkSimpleId "s1")), Term_seq (Name_term (mkSimpleId "s2"))]) nullRange) (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "n")] (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:in-position-count")) [Term_seq (Name_term (mkSimpleId "s1")), Term_seq (Name_term (mkSimpleId "n")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:in-position-count")) [Term_seq (Name_term (mkSimpleId "s2")), Term_seq (Name_term (mkSimpleId "n")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange)) nullRange) nullRange)) nullRange) nullRange)] +clsequencesSens :: [[PHRASE]] +clsequencesSens = [clsequencesSens1] + +setsdiscourseNames :: Set.Set Id +setsdiscourseNames = Set.fromList [stringToId "buml:UnlimitedNatural", stringToId "form:0", stringToId "form:Set", stringToId "form:add-one", stringToId "form:empty-set", stringToId "form:same-set", stringToId "form:set-insert", stringToId "form:set-member", stringToId "form:set-size"] +setsnondiscourseNames :: Set.Set Id +setsnondiscourseNames = Set.fromList [] +setssequenceMarkers :: Set.Set Id +setssequenceMarkers = Set.fromList [] +setsSens1 :: [PHRASE] +setsSens1 = [Sentence (Quant_sent Universal [Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:empty-set")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:Set")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Set")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:empty-set")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "x")] (Atom_sent (Atom (Name_term (mkSimpleId "form:set-member")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))]) nullRange) nullRange)) nullRange)) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "n")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:set-size")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "n"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Set")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "buml:UnlimitedNatural")) [Term_seq (Name_term (mkSimpleId "n"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:set-size")) [Term_seq (Name_term (mkSimpleId "form:empty-set"))] nullRange) (Name_term (mkSimpleId "form:0"))) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Bool_sent (Negation (Atom_sent (Atom (Name_term (mkSimpleId "form:set-member")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))]) nullRange)) nullRange) (Quant_sent Existential [Name (mkSimpleId "n")] (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:add-one")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:set-size")) [Term_seq (Name_term (mkSimpleId "s"))] nullRange), Term_seq (Name_term (mkSimpleId "n"))]) nullRange, Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:set-size")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:set-insert")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange) (Name_term (mkSimpleId "n"))) nullRange]) nullRange) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s1"), Name (mkSimpleId "s2")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:same-set")) [Term_seq (Name_term (mkSimpleId "s1")), Term_seq (Name_term (mkSimpleId "s2"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Set")) [Term_seq (Name_term (mkSimpleId "s1"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:Set")) [Term_seq (Name_term (mkSimpleId "s2"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s1"), Name (mkSimpleId "s2")] (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:same-set")) [Term_seq (Name_term (mkSimpleId "s1")), Term_seq (Name_term (mkSimpleId "s2"))]) nullRange) (Quant_sent Universal [Name (mkSimpleId "x")] (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:set-member")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s1"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:set-member")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s2"))]) nullRange)) nullRange) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Set")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:Set")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:set-insert")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "y"), Name (mkSimpleId "s")] (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:set-member")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Funct_term (Name_term (mkSimpleId "form:set-insert")) [Term_seq (Name_term (mkSimpleId "y")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)]) nullRange) (Bool_sent (Junction Disjunction [Atom_sent (Equation (Name_term (mkSimpleId "x")) (Name_term (mkSimpleId "y"))) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:set-member")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))]) nullRange]) nullRange)) nullRange) nullRange)] +setsSens :: [[PHRASE]] +setsSens = [setsSens1] + +uml_cd_preliminariesdiscourseNames :: Set.Set Id +uml_cd_preliminariesdiscourseNames = Set.fromList [stringToId "buml:Sequence", stringToId "buml:UnlimitedNatural", stringToId "buml:UnlimtedNatural", stringToId "buml:leq", stringToId "buml:less-than", stringToId "c", stringToId "distinct", stringToId "enumeration", stringToId "exhaustive", stringToId "form:0", stringToId "form:1", stringToId "form:Bag", stringToId "form:NaturalNumber", stringToId "form:Ordered-Set", stringToId "form:Ordererd-Set", stringToId "form:Pair", stringToId "form:Position", stringToId "form:Sequence", stringToId "form:Set", stringToId "form:add-one", stringToId "form:bag-insert", stringToId "form:bag-member", stringToId "form:bag-member-count", stringToId "form:bag-size", stringToId "form:bag2set", stringToId "form:before-in-ordered-set", stringToId "form:before-in-sequence", stringToId "form:empty-bag", stringToId "form:empty-ordered-set", stringToId "form:empty-sequence", stringToId "form:empty-set", stringToId "form:first", stringToId "form:in-ordered-set", stringToId "form:in-ordered-set-position-count", stringToId "form:in-position", stringToId "form:in-position-count", stringToId "form:in-sequence", stringToId "form:n-select", stringToId "form:ordered-set-insert", stringToId "form:ordered-set-member", stringToId "form:ordered-set-position-count", stringToId "form:ordered-set-size", stringToId "form:ordset2set", stringToId "form:pair", stringToId "form:position-count", stringToId "form:same-bag", stringToId "form:same-ordered-set", stringToId "form:same-sequence", stringToId "form:same-set", stringToId "form:second", stringToId "form:select1", stringToId "form:select2", stringToId "form:seq2bag", stringToId "form:seq2ordset", stringToId "form:seq2set", stringToId "form:sequence-insert", stringToId "form:sequence-length", stringToId "form:sequence-member", stringToId "form:sequence-size", stringToId "form:set-insert", stringToId "form:set-member", stringToId "form:set-size", stringToId "from:ordered-set-member", stringToId "insert-i", stringToId "oneof", stringToId "s", stringToId "s1", stringToId "x", stringToId "y"] +uml_cd_preliminariesnondiscourseNames :: Set.Set Id +uml_cd_preliminariesnondiscourseNames = Set.fromList [] +uml_cd_preliminariessequenceMarkers :: Set.Set Id +uml_cd_preliminariessequenceMarkers = Set.fromList [stringToId "..."] +uml_cd_preliminariesSens1 :: [PHRASE] +uml_cd_preliminariesSens1 = [Sentence (Atom_sent (Atom (Name_term (mkSimpleId "distinct")) []) nullRange), + Sentence (Atom_sent (Atom (Name_term (mkSimpleId "distinct")) [Term_seq (Name_term (mkSimpleId "x"))]) nullRange), + Sentence (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "distinct")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "y")), Seq_marks (mkSimpleId "...")]) nullRange) (Bool_sent (Junction Conjunction [Bool_sent (Negation (Atom_sent (Equation (Name_term (mkSimpleId "x")) (Name_term (mkSimpleId "y"))) nullRange)) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "distinct")) [Term_seq (Name_term (mkSimpleId "x")), Seq_marks (mkSimpleId "...")]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "distinct")) [Term_seq (Name_term (mkSimpleId "y")), Seq_marks (mkSimpleId "...")]) nullRange]) nullRange)) nullRange), + Sentence (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "exhaustive")) [Term_seq (Name_term (mkSimpleId "c")), Seq_marks (mkSimpleId "...")]) nullRange) (Quant_sent Universal [Name (mkSimpleId "x")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "c")) [Term_seq (Name_term (mkSimpleId "x"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "oneof")) [Term_seq (Name_term (mkSimpleId "x")), Seq_marks (mkSimpleId "...")]) nullRange)) nullRange) nullRange)) nullRange), + Sentence (Bool_sent (Negation (Atom_sent (Atom (Name_term (mkSimpleId "oneof")) [Term_seq (Name_term (mkSimpleId "x"))]) nullRange)) nullRange), + Sentence (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "oneof")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "y")), Seq_marks (mkSimpleId "...")]) nullRange) (Bool_sent (Junction Disjunction [Atom_sent (Equation (Name_term (mkSimpleId "x")) (Name_term (mkSimpleId "y"))) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "oneof")) [Term_seq (Name_term (mkSimpleId "x")), Seq_marks (mkSimpleId "...")]) nullRange]) nullRange)) nullRange), + Sentence (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "enumeration")) [Term_seq (Name_term (mkSimpleId "c")), Seq_marks (mkSimpleId "...")]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "exhaustive")) [Term_seq (Name_term (mkSimpleId "c")), Seq_marks (mkSimpleId "...")]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "distinct")) [Seq_marks (mkSimpleId "...")]) nullRange]) nullRange)) nullRange)] +uml_cd_preliminariesSens2 :: [PHRASE] +uml_cd_preliminariesSens2 = [Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "y")] (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:first")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:pair")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "y"))] nullRange)] nullRange) (Name_term (mkSimpleId "x"))) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "y")] (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:second")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:pair")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "y"))] nullRange)] nullRange) (Name_term (mkSimpleId "y"))) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "y")] (Atom_sent (Atom (Name_term (mkSimpleId "form:Pair")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:pair")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "y"))] nullRange)]) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "p")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Pair")) [Term_seq (Name_term (mkSimpleId "p"))]) nullRange) (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:pair")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:first")) [Term_seq (Name_term (mkSimpleId "p"))] nullRange), Term_seq (Funct_term (Name_term (mkSimpleId "form:second")) [Term_seq (Name_term (mkSimpleId "p"))] nullRange)] nullRange) (Name_term (mkSimpleId "p"))) nullRange)) nullRange) nullRange)] +uml_cd_preliminariesSens3 :: [PHRASE] +uml_cd_preliminariesSens3 = [Sentence (Quant_sent Universal [Name (mkSimpleId "b")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Bag")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:Set")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:bag2set")) [Term_seq (Name_term (mkSimpleId "b"))] nullRange)]) nullRange)) nullRange) nullRange), + Sentence (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:bag2set")) [Term_seq (Name_term (mkSimpleId "form:empty-bag"))] nullRange) (Name_term (mkSimpleId "form:empty-set"))) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "b")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Bag")) [Term_seq (Name_term (mkSimpleId "b"))]) nullRange) (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:bag2set")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:set-insert")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "b"))] nullRange)] nullRange) (Funct_term (Name_term (mkSimpleId "form:bag-insert")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Funct_term (Name_term (mkSimpleId "form:bag2set")) [Term_seq (Name_term (mkSimpleId "b"))] nullRange)] nullRange)) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:Ordered-Set")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:seq2ordset")) [Term_seq (Name_term (mkSimpleId "s"))] nullRange)]) nullRange)) nullRange) nullRange), + Sentence (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:seq2ordset")) [Term_seq (Name_term (mkSimpleId "form:empty-sequence"))] nullRange) (Name_term (mkSimpleId "form:empty-ordered-set"))) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:seq2ordset")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange) (Funct_term (Name_term (mkSimpleId "form:ordered-set-insert")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Funct_term (Name_term (mkSimpleId "form:seq2ordset")) [Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange)) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:Bag")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:seq2bag")) [Term_seq (Name_term (mkSimpleId "s"))] nullRange)]) nullRange)) nullRange) nullRange), + Sentence (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:seq2bag")) [Term_seq (Name_term (mkSimpleId "form:empty-sequence"))] nullRange) (Name_term (mkSimpleId "form:empty-bag"))) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:seq2bag")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange) (Funct_term (Name_term (mkSimpleId "form:bag-insert")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Funct_term (Name_term (mkSimpleId "form:seq2bag")) [Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange)) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "b")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Ordered-Set")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:Set")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:ordset2set")) [Term_seq (Name_term (mkSimpleId "b"))] nullRange)]) nullRange)) nullRange) nullRange), + Sentence (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:ordset2set")) [Term_seq (Name_term (mkSimpleId "form:empty-ordered-set"))] nullRange) (Name_term (mkSimpleId "form:empty-set"))) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "b")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Ordered-Set")) [Term_seq (Name_term (mkSimpleId "b"))]) nullRange) (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:ordset2set")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:set-insert")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "b"))] nullRange)] nullRange) (Funct_term (Name_term (mkSimpleId "form:ordered-set-insert")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Funct_term (Name_term (mkSimpleId "form:ordset2set")) [Term_seq (Name_term (mkSimpleId "b"))] nullRange)] nullRange)) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:Set")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:seq2set")) [Term_seq (Name_term (mkSimpleId "s"))] nullRange)]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s")] (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:seq2set")) [Term_seq (Name_term (mkSimpleId "s"))] nullRange) (Funct_term (Name_term (mkSimpleId "form:ordset2set")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:seq2ordset")) [Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "y")] (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "buml:leq")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "y"))]) nullRange) (Bool_sent (Junction Disjunction [Atom_sent (Equation (Name_term (mkSimpleId "x")) (Name_term (mkSimpleId "y"))) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "buml:less-than")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "y"))]) nullRange]) nullRange)) nullRange) nullRange)] +uml_cd_preliminariesSens4 :: [PHRASE] +uml_cd_preliminariesSens4 = [Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "s1"), Name (mkSimpleId "s2")] (Bool_sent (BinOp Implication (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s1"))] nullRange) (Name_term (mkSimpleId "s2"))) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s1"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s2"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:in-position-count")) [Term_seq (Name_term (mkSimpleId "s2")), Term_seq (Name_term (mkSimpleId "form:1")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange, Quant_sent Universal [Name (mkSimpleId "n1"), Name (mkSimpleId "n2"), Name (mkSimpleId "y")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:add-one")) [Term_seq (Name_term (mkSimpleId "n1")), Term_seq (Name_term (mkSimpleId "n2"))]) nullRange) (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:in-position-count")) [Term_seq (Name_term (mkSimpleId "s1")), Term_seq (Name_term (mkSimpleId "n1")), Term_seq (Name_term (mkSimpleId "y"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:in-position-count")) [Term_seq (Name_term (mkSimpleId "s2")), Term_seq (Name_term (mkSimpleId "n2")), Term_seq (Name_term (mkSimpleId "y"))]) nullRange)) nullRange)) nullRange) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s")] (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:sequence-length")) [Term_seq (Name_term (mkSimpleId "s"))] nullRange) (Funct_term (Name_term (mkSimpleId "form:sequence-size")) [Term_seq (Name_term (mkSimpleId "s"))] nullRange)) nullRange) nullRange)] +uml_cd_preliminariesSens5 :: [PHRASE] +uml_cd_preliminariesSens5 = [Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:sequence-member")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "s")] (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:sequence-member")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Quant_sent Existential [Name (mkSimpleId "pt")] (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:in-position")) [Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange]) nullRange) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "o")] (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:select1")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Name_term (mkSimpleId "form:empty-sequence"))] nullRange) (Name_term (mkSimpleId "form:empty-sequence"))) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "o"), Name (mkSimpleId "y"), Name (mkSimpleId "s")] (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:select1")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:pair")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Name_term (mkSimpleId "y"))] nullRange), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange) (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Name_term (mkSimpleId "y")), Term_seq (Funct_term (Name_term (mkSimpleId "form:select1")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "o"), Name (mkSimpleId "x"), Name (mkSimpleId "y"), Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Bool_sent (Negation (Atom_sent (Equation (Name_term (mkSimpleId "x")) (Name_term (mkSimpleId "o"))) nullRange)) nullRange) (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:select1")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:pair")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "y"))] nullRange), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange) (Funct_term (Name_term (mkSimpleId "form:select1")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "o")] (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:select2")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Name_term (mkSimpleId "form:empty-sequence"))] nullRange) (Name_term (mkSimpleId "form:empty-sequence"))) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "o"), Name (mkSimpleId "x"), Name (mkSimpleId "s")] (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:select2")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:pair")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "o"))] nullRange), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange) (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Funct_term (Name_term (mkSimpleId "form:select2")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "o"), Name (mkSimpleId "x"), Name (mkSimpleId "y"), Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Bool_sent (Negation (Atom_sent (Equation (Name_term (mkSimpleId "y")) (Name_term (mkSimpleId "o"))) nullRange)) nullRange) (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:select2")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:pair")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "y"))] nullRange), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange) (Funct_term (Name_term (mkSimpleId "form:select2")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "i"), Name (mkSimpleId "s")] (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:n-select")) [Term_seq (Name_term (mkSimpleId "form:empty-sequence")), Term_seq (Name_term (mkSimpleId "i")), Term_seq (Name_term (mkSimpleId "s"))] nullRange) (Name_term (mkSimpleId "form:empty-sequence"))) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "a"), Name (mkSimpleId "i"), Name (mkSimpleId "s"), Name (mkSimpleId "t"), Name (mkSimpleId "x")] (Bool_sent (BinOp Implication (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "insert-i")) [Term_seq (Name_term (mkSimpleId "i")), Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "t"))] nullRange) (Name_term (mkSimpleId "s"))) nullRange) (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:n-select")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "a"))] nullRange), Term_seq (Name_term (mkSimpleId "i")), Term_seq (Name_term (mkSimpleId "t"))] nullRange) (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Funct_term (Name_term (mkSimpleId "form:n-select")) [Term_seq (Name_term (mkSimpleId "a")), Term_seq (Name_term (mkSimpleId "i")), Term_seq (Name_term (mkSimpleId "t"))] nullRange)] nullRange)) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "a"), Name (mkSimpleId "i"), Name (mkSimpleId "s"), Name (mkSimpleId "t")] (Bool_sent (BinOp Implication (Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "x")] (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "insert-i")) [Term_seq (Name_term (mkSimpleId "i")), Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "t"))] nullRange) (Name_term (mkSimpleId "s"))) nullRange) nullRange)) nullRange) (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:n-select")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "a"))] nullRange), Term_seq (Name_term (mkSimpleId "i")), Term_seq (Name_term (mkSimpleId "t"))] nullRange) (Funct_term (Name_term (mkSimpleId "form:n-select")) [Term_seq (Name_term (mkSimpleId "a")), Term_seq (Name_term (mkSimpleId "i")), Term_seq (Name_term (mkSimpleId "t"))] nullRange)) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "s")] (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "insert-i")) [Term_seq (Name_term (mkSimpleId "form:0")), Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))] nullRange) (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "i"), Name (mkSimpleId "j"), Name (mkSimpleId "x"), Name (mkSimpleId "y"), Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:add-one")) [Term_seq (Name_term (mkSimpleId "i")), Term_seq (Name_term (mkSimpleId "j"))]) nullRange) (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "insert-i")) [Term_seq (Name_term (mkSimpleId "j")), Term_seq (Name_term (mkSimpleId "x")), Term_seq (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Name_term (mkSimpleId "y")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange) (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Name_term (mkSimpleId "y")), Term_seq (Funct_term (Name_term (mkSimpleId "insert-i")) [Term_seq (Name_term (mkSimpleId "i")), Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange)) nullRange)) nullRange) nullRange)] +uml_cd_preliminariesSens6 :: [PHRASE] +uml_cd_preliminariesSens6 = [Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:Position")) [Term_seq (Name_term (mkSimpleId "pt"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s1"), Name (mkSimpleId "s2"), Name (mkSimpleId "pt")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:in-sequence")) [Term_seq (Name_term (mkSimpleId "s1")), Term_seq (Name_term (mkSimpleId "pt"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:in-sequence")) [Term_seq (Name_term (mkSimpleId "s2")), Term_seq (Name_term (mkSimpleId "pt"))]) nullRange]) nullRange) (Atom_sent (Equation (Name_term (mkSimpleId "s1")) (Name_term (mkSimpleId "s2"))) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "pt")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Position")) [Term_seq (Name_term (mkSimpleId "pt"))]) nullRange) (Quant_sent Existential [Name (mkSimpleId "s")] (Atom_sent (Atom (Name_term (mkSimpleId "form:in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt"))]) nullRange) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt1"), Name (mkSimpleId "pt2")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "buml:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:Position")) [Term_seq (Name_term (mkSimpleId "pt1"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:Position")) [Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt1"), Name (mkSimpleId "pt2")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "s"), Name (mkSimpleId "pt1"), Name (mkSimpleId "pt2")] (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt2")), Term_seq (Name_term (mkSimpleId "pt1"))]) nullRange]) nullRange) nullRange)) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt1"), Name (mkSimpleId "pt2"), Name (mkSimpleId "pt11"), Name (mkSimpleId "pt22")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt11")), Term_seq (Name_term (mkSimpleId "pt22"))]) nullRange]) nullRange) (Bool_sent (BinOp Biconditional (Atom_sent (Equation (Name_term (mkSimpleId "pt1")) (Name_term (mkSimpleId "pt11"))) nullRange) (Atom_sent (Equation (Name_term (mkSimpleId "pt2")) (Name_term (mkSimpleId "pt22"))) nullRange)) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Bool_sent (BinOp Implication (Quant_sent Existential [Name (mkSimpleId "pt")] (Atom_sent (Atom (Name_term (mkSimpleId "form:in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt"))]) nullRange) nullRange) (Bool_sent (Junction Conjunction [Quant_sent Existential [Name (mkSimpleId "pt1")] (Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt2")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) nullRange)) nullRange) nullRange, Quant_sent Existential [Name (mkSimpleId "pt2")] (Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt1")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) nullRange)) nullRange) nullRange]) nullRange)) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt1"), Name (mkSimpleId "pt11")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt2")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) nullRange)) nullRange, Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt2")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt11")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) nullRange)) nullRange]) nullRange) (Atom_sent (Equation (Name_term (mkSimpleId "pt1")) (Name_term (mkSimpleId "pt11"))) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Quant_sent Existential [Name (mkSimpleId "pt2")] (Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt1")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) nullRange)) nullRange) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt2"), Name (mkSimpleId "pt22")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt1")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) nullRange)) nullRange, Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt1")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt22"))]) nullRange) nullRange)) nullRange]) nullRange) (Atom_sent (Equation (Name_term (mkSimpleId "pt2")) (Name_term (mkSimpleId "pt22"))) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:empty-sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:empty-sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt")] (Atom_sent (Atom (Name_term (mkSimpleId "form:in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt"))]) nullRange) nullRange)) nullRange)) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt"), Name (mkSimpleId "n")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "n"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:Position")) [Term_seq (Name_term (mkSimpleId "pt"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "buml:UnlimtedNatural")) [Term_seq (Name_term (mkSimpleId "n"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt"), Name (mkSimpleId "n1"), Name (mkSimpleId "n2")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "n1"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "n2"))]) nullRange]) nullRange) (Atom_sent (Equation (Name_term (mkSimpleId "n1")) (Name_term (mkSimpleId "n2"))) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt"))]) nullRange) (Quant_sent Existential [Name (mkSimpleId "n")] (Atom_sent (Atom (Name_term (mkSimpleId "form:position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "n"))]) nullRange) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt2")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt1")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) nullRange)) nullRange]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt2")), Term_seq (Name_term (mkSimpleId "form:1"))]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt1"), Name (mkSimpleId "n1"), Name (mkSimpleId "pt2"), Name (mkSimpleId "n2")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "n1"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt2")), Term_seq (Name_term (mkSimpleId "n2"))]) nullRange]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:add-one")) [Term_seq (Name_term (mkSimpleId "n1")), Term_seq (Name_term (mkSimpleId "n2"))]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "n")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:sequence-length")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "n"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "buml:UnlimtedNatural")) [Term_seq (Name_term (mkSimpleId "n"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "n")] (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:sequence-length")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "n"))]) nullRange) (Bool_sent (Junction Disjunction [Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:empty-sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Atom_sent (Equation (Name_term (mkSimpleId "n")) (Name_term (mkSimpleId "form:0"))) nullRange]) nullRange, Quant_sent Existential [Name (mkSimpleId "pt1")] (Bool_sent (Junction Conjunction [Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt2")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) nullRange)) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "n"))]) nullRange]) nullRange) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "pt"), Name (mkSimpleId "x")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:in-position")) [Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:Position")) [Term_seq (Name_term (mkSimpleId "pt"))]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "pt"), Name (mkSimpleId "x1"), Name (mkSimpleId "x2")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:in-position")) [Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "x1"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:in-position")) [Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "x2"))]) nullRange]) nullRange) (Atom_sent (Equation (Name_term (mkSimpleId "x1")) (Name_term (mkSimpleId "x2"))) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "pt")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Position")) [Term_seq (Name_term (mkSimpleId "pt"))]) nullRange) (Quant_sent Existential [Name (mkSimpleId "x")] (Atom_sent (Atom (Name_term (mkSimpleId "form:in-position")) [Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "n"), Name (mkSimpleId "x")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:in-position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "n")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "buml:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:NaturalNumber")) [Term_seq (Name_term (mkSimpleId "n"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "n"), Name (mkSimpleId "x")] (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:in-position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "n")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange) (Quant_sent Existential [Name (mkSimpleId "pt")] (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:in-position")) [Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "n"))]) nullRange]) nullRange) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s1"), Name (mkSimpleId "s2")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:same-sequence")) [Term_seq (Name_term (mkSimpleId "s1")), Term_seq (Name_term (mkSimpleId "s2"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s1"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s2"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s1"), Name (mkSimpleId "s2")] (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:same-sequence")) [Term_seq (Name_term (mkSimpleId "s1")), Term_seq (Name_term (mkSimpleId "s2"))]) nullRange) (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "n")] (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:in-position-count")) [Term_seq (Name_term (mkSimpleId "s1")), Term_seq (Name_term (mkSimpleId "n")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:in-position-count")) [Term_seq (Name_term (mkSimpleId "s2")), Term_seq (Name_term (mkSimpleId "n")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange)) nullRange) nullRange)) nullRange) nullRange)] +uml_cd_preliminariesSens7 :: [PHRASE] +uml_cd_preliminariesSens7 = [Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "x1"), Name (mkSimpleId "x2"), Name (mkSimpleId "n1"), Name (mkSimpleId "n2")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:in-ordered-set-position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "n1")), Term_seq (Name_term (mkSimpleId "x1"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:in-ordered-set-position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "n2")), Term_seq (Name_term (mkSimpleId "x2"))]) nullRange, Atom_sent (Equation (Name_term (mkSimpleId "x1")) (Name_term (mkSimpleId "x2"))) nullRange]) nullRange) (Atom_sent (Equation (Name_term (mkSimpleId "n1")) (Name_term (mkSimpleId "n2"))) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "s1"), Name (mkSimpleId "s2")] (Bool_sent (BinOp Implication (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:ordered-set-insert")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s1"))] nullRange) (Name_term (mkSimpleId "s2"))) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Ordererd-Set")) [Term_seq (Name_term (mkSimpleId "s1"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:Ordererd-Set")) [Term_seq (Name_term (mkSimpleId "s2"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "from:ordered-set-member")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:ordered-set-insert")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))] nullRange) (Name_term (mkSimpleId "s"))) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Bool_sent (Negation (Atom_sent (Atom (Name_term (mkSimpleId "from:ordered-set-member")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s1"))]) nullRange)) nullRange) (Quant_sent Existential [Name (mkSimpleId "s2")] (Bool_sent (Junction Conjunction [Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:ordered-set-insert")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s1"))] nullRange) (Name_term (mkSimpleId "s2"))) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:in-ordered-set-position-count")) [Term_seq (Name_term (mkSimpleId "s2")), Term_seq (Name_term (mkSimpleId "form:1")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange, Quant_sent Universal [Name (mkSimpleId "n1"), Name (mkSimpleId "n2"), Name (mkSimpleId "y")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:add-one")) [Term_seq (Name_term (mkSimpleId "n1")), Term_seq (Name_term (mkSimpleId "n2"))]) nullRange) (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:in-ordered-set-position-count")) [Term_seq (Name_term (mkSimpleId "s1")), Term_seq (Name_term (mkSimpleId "n1")), Term_seq (Name_term (mkSimpleId "y"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:in-ordered-set-position-count")) [Term_seq (Name_term (mkSimpleId "s2")), Term_seq (Name_term (mkSimpleId "n2")), Term_seq (Name_term (mkSimpleId "y"))]) nullRange)) nullRange)) nullRange) nullRange]) nullRange) nullRange)) nullRange) nullRange)] +uml_cd_preliminariesSens8 :: [PHRASE] +uml_cd_preliminariesSens8 = [Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:ordered-set-member")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:Ordered-Set")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "s")] (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:ordered-set-member")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Quant_sent Existential [Name (mkSimpleId "pt")] (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:in-position")) [Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange]) nullRange) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "o")] (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:select1")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Name_term (mkSimpleId "form:empty-ordered-set"))] nullRange) (Name_term (mkSimpleId "form:empty-ordered-set"))) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "o"), Name (mkSimpleId "y"), Name (mkSimpleId "s")] (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:select1")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:pair")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Name_term (mkSimpleId "y"))] nullRange), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange) (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Name_term (mkSimpleId "y")), Term_seq (Funct_term (Name_term (mkSimpleId "form:select1")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "o"), Name (mkSimpleId "x"), Name (mkSimpleId "y"), Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Bool_sent (Negation (Atom_sent (Equation (Name_term (mkSimpleId "x")) (Name_term (mkSimpleId "o"))) nullRange)) nullRange) (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:select1")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:pair")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "y"))] nullRange), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange) (Funct_term (Name_term (mkSimpleId "form:select1")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "o")] (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:select2")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Name_term (mkSimpleId "form:empty-ordered-set"))] nullRange) (Name_term (mkSimpleId "form:empty-ordered-set"))) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "o"), Name (mkSimpleId "x"), Name (mkSimpleId "s")] (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:select2")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:pair")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "o"))] nullRange), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange) (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Funct_term (Name_term (mkSimpleId "form:select2")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "o"), Name (mkSimpleId "x"), Name (mkSimpleId "y"), Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Bool_sent (Negation (Atom_sent (Equation (Name_term (mkSimpleId "y")) (Name_term (mkSimpleId "o"))) nullRange)) nullRange) (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:select2")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:pair")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "y"))] nullRange), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange) (Funct_term (Name_term (mkSimpleId "form:select2")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "i"), Name (mkSimpleId "s")] (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:n-select")) [Term_seq (Name_term (mkSimpleId "form:empty-ordered-set")), Term_seq (Name_term (mkSimpleId "i")), Term_seq (Name_term (mkSimpleId "s"))] nullRange) (Name_term (mkSimpleId "form:empty-ordered-set"))) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "a"), Name (mkSimpleId "i"), Name (mkSimpleId "s"), Name (mkSimpleId "t"), Name (mkSimpleId "x")] (Bool_sent (BinOp Implication (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "insert-i")) [Term_seq (Name_term (mkSimpleId "i")), Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "t"))] nullRange) (Name_term (mkSimpleId "s"))) nullRange) (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:n-select")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "a"))] nullRange), Term_seq (Name_term (mkSimpleId "i")), Term_seq (Name_term (mkSimpleId "t"))] nullRange) (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Funct_term (Name_term (mkSimpleId "form:n-select")) [Term_seq (Name_term (mkSimpleId "a")), Term_seq (Name_term (mkSimpleId "i")), Term_seq (Name_term (mkSimpleId "t"))] nullRange)] nullRange)) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "a"), Name (mkSimpleId "i"), Name (mkSimpleId "s"), Name (mkSimpleId "t")] (Bool_sent (BinOp Implication (Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "x")] (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "insert-i")) [Term_seq (Name_term (mkSimpleId "i")), Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "t"))] nullRange) (Name_term (mkSimpleId "s"))) nullRange) nullRange)) nullRange) (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:n-select")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "a"))] nullRange), Term_seq (Name_term (mkSimpleId "i")), Term_seq (Name_term (mkSimpleId "t"))] nullRange) (Funct_term (Name_term (mkSimpleId "form:n-select")) [Term_seq (Name_term (mkSimpleId "a")), Term_seq (Name_term (mkSimpleId "i")), Term_seq (Name_term (mkSimpleId "t"))] nullRange)) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "s")] (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "insert-i")) [Term_seq (Name_term (mkSimpleId "form:0")), Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))] nullRange) (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "i"), Name (mkSimpleId "j"), Name (mkSimpleId "x"), Name (mkSimpleId "y"), Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:add-one")) [Term_seq (Name_term (mkSimpleId "i")), Term_seq (Name_term (mkSimpleId "j"))]) nullRange) (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "insert-i")) [Term_seq (Name_term (mkSimpleId "j")), Term_seq (Name_term (mkSimpleId "x")), Term_seq (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Name_term (mkSimpleId "y")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange) (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Name_term (mkSimpleId "y")), Term_seq (Funct_term (Name_term (mkSimpleId "insert-i")) [Term_seq (Name_term (mkSimpleId "i")), Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange)) nullRange)) nullRange) nullRange)] +uml_cd_preliminariesSens9 :: [PHRASE] +uml_cd_preliminariesSens9 = [Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Ordered-Set")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:Position")) [Term_seq (Name_term (mkSimpleId "pt"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s1"), Name (mkSimpleId "s2"), Name (mkSimpleId "pt")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s1")), Term_seq (Name_term (mkSimpleId "pt"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s2")), Term_seq (Name_term (mkSimpleId "pt"))]) nullRange]) nullRange) (Atom_sent (Equation (Name_term (mkSimpleId "s1")) (Name_term (mkSimpleId "s2"))) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "pt")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Position")) [Term_seq (Name_term (mkSimpleId "pt"))]) nullRange) (Quant_sent Existential [Name (mkSimpleId "s")] (Atom_sent (Atom (Name_term (mkSimpleId "form:in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt"))]) nullRange) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt1"), Name (mkSimpleId "pt2")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "buml:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:Position")) [Term_seq (Name_term (mkSimpleId "pt1"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:Position")) [Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt1"), Name (mkSimpleId "pt2")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "s"), Name (mkSimpleId "pt1"), Name (mkSimpleId "pt2")] (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt2")), Term_seq (Name_term (mkSimpleId "pt1"))]) nullRange]) nullRange) nullRange)) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt1"), Name (mkSimpleId "pt2"), Name (mkSimpleId "pt11"), Name (mkSimpleId "pt22")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt11")), Term_seq (Name_term (mkSimpleId "pt22"))]) nullRange]) nullRange) (Bool_sent (BinOp Biconditional (Atom_sent (Equation (Name_term (mkSimpleId "pt1")) (Name_term (mkSimpleId "pt11"))) nullRange) (Atom_sent (Equation (Name_term (mkSimpleId "pt2")) (Name_term (mkSimpleId "pt22"))) nullRange)) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Ordered-Set")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Bool_sent (BinOp Implication (Quant_sent Existential [Name (mkSimpleId "pt")] (Atom_sent (Atom (Name_term (mkSimpleId "form:in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt"))]) nullRange) nullRange) (Bool_sent (Junction Conjunction [Quant_sent Existential [Name (mkSimpleId "pt1")] (Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt2")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) nullRange)) nullRange) nullRange, Quant_sent Existential [Name (mkSimpleId "pt2")] (Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt1")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) nullRange)) nullRange) nullRange]) nullRange)) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt1"), Name (mkSimpleId "pt11")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Ordered-Set")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt2")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) nullRange)) nullRange, Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt2")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt11")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) nullRange)) nullRange]) nullRange) (Atom_sent (Equation (Name_term (mkSimpleId "pt1")) (Name_term (mkSimpleId "pt11"))) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Ordered-Set")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Quant_sent Existential [Name (mkSimpleId "pt2")] (Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt1")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) nullRange)) nullRange) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt2"), Name (mkSimpleId "pt22")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Ordered-Set")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt1")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) nullRange)) nullRange, Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt1")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt22"))]) nullRange) nullRange)) nullRange]) nullRange) (Atom_sent (Equation (Name_term (mkSimpleId "pt2")) (Name_term (mkSimpleId "pt22"))) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:empty-ordered-set")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:Ordered-Set")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Ordered-Set")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:empty-ordered-set")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt")] (Atom_sent (Atom (Name_term (mkSimpleId "form:in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt"))]) nullRange) nullRange)) nullRange)) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt"), Name (mkSimpleId "n")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:ordered-set-position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "n"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Ordered-Set")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:Position")) [Term_seq (Name_term (mkSimpleId "pt"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "buml:UnlimtedNatural")) [Term_seq (Name_term (mkSimpleId "n"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt"), Name (mkSimpleId "n1"), Name (mkSimpleId "n2")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:ordered-set-position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "n1"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:ordered-set-position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "n2"))]) nullRange]) nullRange) (Atom_sent (Equation (Name_term (mkSimpleId "n1")) (Name_term (mkSimpleId "n2"))) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt"))]) nullRange) (Quant_sent Existential [Name (mkSimpleId "n")] (Atom_sent (Atom (Name_term (mkSimpleId "form:ordered-set-position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "n"))]) nullRange) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt2")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Ordered-Set")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt1")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) nullRange)) nullRange]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:ordered-set-position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt2")), Term_seq (Name_term (mkSimpleId "form:1"))]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt1"), Name (mkSimpleId "n1"), Name (mkSimpleId "pt2"), Name (mkSimpleId "n2")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:ordered-set-position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "n1"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:ordered-set-position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt2")), Term_seq (Name_term (mkSimpleId "n2"))]) nullRange]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:add-one")) [Term_seq (Name_term (mkSimpleId "n1")), Term_seq (Name_term (mkSimpleId "n2"))]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "n")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:ordered-set-size")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "n"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Ordered-Set")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "buml:UnlimtedNatural")) [Term_seq (Name_term (mkSimpleId "n"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "n")] (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:ordered-set-size")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "n"))]) nullRange) (Bool_sent (Junction Disjunction [Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:empty-ordered-set")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Atom_sent (Equation (Name_term (mkSimpleId "n")) (Name_term (mkSimpleId "form:0"))) nullRange]) nullRange, Quant_sent Existential [Name (mkSimpleId "pt1")] (Bool_sent (Junction Conjunction [Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt2")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) nullRange)) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:ordered-set-position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "n"))]) nullRange]) nullRange) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "pt"), Name (mkSimpleId "x")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:in-position")) [Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:Position")) [Term_seq (Name_term (mkSimpleId "pt"))]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "pt"), Name (mkSimpleId "x1"), Name (mkSimpleId "x2")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:in-position")) [Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "x1"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:in-position")) [Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "x2"))]) nullRange]) nullRange) (Atom_sent (Equation (Name_term (mkSimpleId "x1")) (Name_term (mkSimpleId "x2"))) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "pt")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Position")) [Term_seq (Name_term (mkSimpleId "pt"))]) nullRange) (Quant_sent Existential [Name (mkSimpleId "x")] (Atom_sent (Atom (Name_term (mkSimpleId "form:in-position")) [Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "n"), Name (mkSimpleId "x")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:in-ordered-set-position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "n")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "buml:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:NaturalNumber")) [Term_seq (Name_term (mkSimpleId "n"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "n"), Name (mkSimpleId "x")] (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:in-ordered-set-position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "n")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange) (Quant_sent Existential [Name (mkSimpleId "pt")] (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:in-position")) [Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:ordered-set-position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "n"))]) nullRange]) nullRange) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s1"), Name (mkSimpleId "s2")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:same-ordered-set")) [Term_seq (Name_term (mkSimpleId "s1")), Term_seq (Name_term (mkSimpleId "s2"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Ordered-Set")) [Term_seq (Name_term (mkSimpleId "s1"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:Ordered-Set")) [Term_seq (Name_term (mkSimpleId "s2"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s1"), Name (mkSimpleId "s2")] (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:same-ordered-set")) [Term_seq (Name_term (mkSimpleId "s1")), Term_seq (Name_term (mkSimpleId "s2"))]) nullRange) (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "n")] (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:in-ordered-set-position-count")) [Term_seq (Name_term (mkSimpleId "s1")), Term_seq (Name_term (mkSimpleId "n")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:in-ordered-set-position-count")) [Term_seq (Name_term (mkSimpleId "s2")), Term_seq (Name_term (mkSimpleId "n")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange)) nullRange) nullRange)) nullRange) nullRange)] +uml_cd_preliminariesSens10 :: [PHRASE] +uml_cd_preliminariesSens10 = [Sentence (Quant_sent Universal [Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:empty-set")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:Set")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Set")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:empty-set")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "x")] (Atom_sent (Atom (Name_term (mkSimpleId "form:set-member")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))]) nullRange) nullRange)) nullRange)) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "n")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:set-size")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "n"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Set")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "buml:UnlimitedNatural")) [Term_seq (Name_term (mkSimpleId "n"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:set-size")) [Term_seq (Name_term (mkSimpleId "form:empty-set"))] nullRange) (Name_term (mkSimpleId "form:0"))) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Bool_sent (Negation (Atom_sent (Atom (Name_term (mkSimpleId "form:set-member")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))]) nullRange)) nullRange) (Quant_sent Existential [Name (mkSimpleId "n")] (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:add-one")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:set-size")) [Term_seq (Name_term (mkSimpleId "s"))] nullRange), Term_seq (Name_term (mkSimpleId "n"))]) nullRange, Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:set-size")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:set-insert")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange) (Name_term (mkSimpleId "n"))) nullRange]) nullRange) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s1"), Name (mkSimpleId "s2")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:same-set")) [Term_seq (Name_term (mkSimpleId "s1")), Term_seq (Name_term (mkSimpleId "s2"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Set")) [Term_seq (Name_term (mkSimpleId "s1"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:Set")) [Term_seq (Name_term (mkSimpleId "s2"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s1"), Name (mkSimpleId "s2")] (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:same-set")) [Term_seq (Name_term (mkSimpleId "s1")), Term_seq (Name_term (mkSimpleId "s2"))]) nullRange) (Quant_sent Universal [Name (mkSimpleId "x")] (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:set-member")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s1"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:set-member")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s2"))]) nullRange)) nullRange) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Set")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:Set")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:set-insert")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "y"), Name (mkSimpleId "s")] (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:set-member")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Funct_term (Name_term (mkSimpleId "form:set-insert")) [Term_seq (Name_term (mkSimpleId "y")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)]) nullRange) (Bool_sent (Junction Disjunction [Atom_sent (Equation (Name_term (mkSimpleId "x")) (Name_term (mkSimpleId "y"))) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:set-member")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))]) nullRange]) nullRange)) nullRange) nullRange)] +uml_cd_preliminariesSens11 :: [PHRASE] +uml_cd_preliminariesSens11 = [Sentence (Quant_sent Universal [Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:empty-bag")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:Bag")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Bag")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:empty-bag")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "x")] (Atom_sent (Atom (Name_term (mkSimpleId "form:bag-member")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))]) nullRange) nullRange)) nullRange)) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "n")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:bag-size")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "n"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Bag")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "buml:UnlimitedNatural")) [Term_seq (Name_term (mkSimpleId "n"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:bag-size")) [Term_seq (Name_term (mkSimpleId "form:empty-bag"))] nullRange) (Name_term (mkSimpleId "form:0"))) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "s")] (Quant_sent Existential [Name (mkSimpleId "n")] (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:add-one")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:bag-size")) [Term_seq (Name_term (mkSimpleId "s"))] nullRange), Term_seq (Name_term (mkSimpleId "n"))]) nullRange, Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:bag-size")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:bag-insert")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange) (Name_term (mkSimpleId "n"))) nullRange]) nullRange) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s1"), Name (mkSimpleId "s2")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:same-bag")) [Term_seq (Name_term (mkSimpleId "s1")), Term_seq (Name_term (mkSimpleId "s2"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Bag")) [Term_seq (Name_term (mkSimpleId "s1"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:Bag")) [Term_seq (Name_term (mkSimpleId "s2"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s1"), Name (mkSimpleId "s2")] (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:same-bag")) [Term_seq (Name_term (mkSimpleId "s1")), Term_seq (Name_term (mkSimpleId "s2"))]) nullRange) (Quant_sent Universal [Name (mkSimpleId "x")] (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:bag-member-count")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s1"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:bag-member-count")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s2"))]) nullRange)) nullRange) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Bag")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:Bag")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:bag-insert")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "y"), Name (mkSimpleId "s")] (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:bag-member")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Funct_term (Name_term (mkSimpleId "form:bag-insert")) [Term_seq (Name_term (mkSimpleId "y")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)]) nullRange) (Bool_sent (Junction Disjunction [Atom_sent (Equation (Name_term (mkSimpleId "x")) (Name_term (mkSimpleId "y"))) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:bag-member")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Bag")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "buml:UnlimitedNatural")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:bag-member-count")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)]) nullRange)) nullRange) nullRange), + Sentence (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:bag-member-count")) [Term_seq (Name_term (mkSimpleId "form:empty-bag"))] nullRange) (Name_term (mkSimpleId "form:0"))) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "s")] (Quant_sent Existential [Name (mkSimpleId "n")] (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:add-one")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:bag-member-count")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))] nullRange), Term_seq (Name_term (mkSimpleId "n"))]) nullRange, Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:bag-member-count")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Funct_term (Name_term (mkSimpleId "form:bag-insert")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange) (Name_term (mkSimpleId "n"))) nullRange]) nullRange) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "y"), Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Bool_sent (Negation (Atom_sent (Equation (Name_term (mkSimpleId "x")) (Name_term (mkSimpleId "y"))) nullRange)) nullRange) (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:bag-member-count")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Funct_term (Name_term (mkSimpleId "form:bag-insert")) [Term_seq (Name_term (mkSimpleId "y")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange) (Funct_term (Name_term (mkSimpleId "form:bag-member-count")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)) nullRange)) nullRange) nullRange)] +uml_cd_preliminariesSens :: [[PHRASE]] +uml_cd_preliminariesSens = [uml_cd_preliminariesSens1, uml_cd_preliminariesSens2, uml_cd_preliminariesSens3, uml_cd_preliminariesSens4, uml_cd_preliminariesSens5, uml_cd_preliminariesSens6, uml_cd_preliminariesSens7, uml_cd_preliminariesSens8, uml_cd_preliminariesSens9, uml_cd_preliminariesSens10, uml_cd_preliminariesSens11] + +sequences_insertdiscourseNames :: Set.Set Id +sequences_insertdiscourseNames = Set.fromList [stringToId "buml:Sequence", stringToId "buml:UnlimtedNatural", stringToId "form:0", stringToId "form:1", stringToId "form:NaturalNumber", stringToId "form:Pair", stringToId "form:Position", stringToId "form:Sequence", stringToId "form:add-one", stringToId "form:before-in-sequence", stringToId "form:empty-sequence", stringToId "form:first", stringToId "form:in-position", stringToId "form:in-position-count", stringToId "form:in-sequence", stringToId "form:n-select", stringToId "form:pair", stringToId "form:position-count", stringToId "form:same-sequence", stringToId "form:second", stringToId "form:select1", stringToId "form:select2", stringToId "form:sequence-insert", stringToId "form:sequence-length", stringToId "form:sequence-member", stringToId "form:sequence-size", stringToId "insert-i"] +sequences_insertnondiscourseNames :: Set.Set Id +sequences_insertnondiscourseNames = Set.fromList [] +sequences_insertsequenceMarkers :: Set.Set Id +sequences_insertsequenceMarkers = Set.fromList [] +sequences_insertSens1 :: [PHRASE] +sequences_insertSens1 = [Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "s1"), Name (mkSimpleId "s2")] (Bool_sent (BinOp Implication (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s1"))] nullRange) (Name_term (mkSimpleId "s2"))) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s1"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s2"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:in-position-count")) [Term_seq (Name_term (mkSimpleId "s2")), Term_seq (Name_term (mkSimpleId "form:1")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange, Quant_sent Universal [Name (mkSimpleId "n1"), Name (mkSimpleId "n2"), Name (mkSimpleId "y")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:add-one")) [Term_seq (Name_term (mkSimpleId "n1")), Term_seq (Name_term (mkSimpleId "n2"))]) nullRange) (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:in-position-count")) [Term_seq (Name_term (mkSimpleId "s1")), Term_seq (Name_term (mkSimpleId "n1")), Term_seq (Name_term (mkSimpleId "y"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:in-position-count")) [Term_seq (Name_term (mkSimpleId "s2")), Term_seq (Name_term (mkSimpleId "n2")), Term_seq (Name_term (mkSimpleId "y"))]) nullRange)) nullRange)) nullRange) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s")] (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:sequence-length")) [Term_seq (Name_term (mkSimpleId "s"))] nullRange) (Funct_term (Name_term (mkSimpleId "form:sequence-size")) [Term_seq (Name_term (mkSimpleId "s"))] nullRange)) nullRange) nullRange)] +sequences_insertSens2 :: [PHRASE] +sequences_insertSens2 = [Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:sequence-member")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "s")] (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:sequence-member")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Quant_sent Existential [Name (mkSimpleId "pt")] (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:in-position")) [Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange]) nullRange) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "o")] (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:select1")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Name_term (mkSimpleId "form:empty-sequence"))] nullRange) (Name_term (mkSimpleId "form:empty-sequence"))) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "o"), Name (mkSimpleId "y"), Name (mkSimpleId "s")] (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:select1")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:pair")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Name_term (mkSimpleId "y"))] nullRange), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange) (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Name_term (mkSimpleId "y")), Term_seq (Funct_term (Name_term (mkSimpleId "form:select1")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "o"), Name (mkSimpleId "x"), Name (mkSimpleId "y"), Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Bool_sent (Negation (Atom_sent (Equation (Name_term (mkSimpleId "x")) (Name_term (mkSimpleId "o"))) nullRange)) nullRange) (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:select1")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:pair")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "y"))] nullRange), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange) (Funct_term (Name_term (mkSimpleId "form:select1")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "o")] (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:select2")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Name_term (mkSimpleId "form:empty-sequence"))] nullRange) (Name_term (mkSimpleId "form:empty-sequence"))) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "o"), Name (mkSimpleId "x"), Name (mkSimpleId "s")] (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:select2")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:pair")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "o"))] nullRange), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange) (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Funct_term (Name_term (mkSimpleId "form:select2")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "o"), Name (mkSimpleId "x"), Name (mkSimpleId "y"), Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Bool_sent (Negation (Atom_sent (Equation (Name_term (mkSimpleId "y")) (Name_term (mkSimpleId "o"))) nullRange)) nullRange) (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:select2")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:pair")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "y"))] nullRange), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange) (Funct_term (Name_term (mkSimpleId "form:select2")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "i"), Name (mkSimpleId "s")] (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:n-select")) [Term_seq (Name_term (mkSimpleId "form:empty-sequence")), Term_seq (Name_term (mkSimpleId "i")), Term_seq (Name_term (mkSimpleId "s"))] nullRange) (Name_term (mkSimpleId "form:empty-sequence"))) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "a"), Name (mkSimpleId "i"), Name (mkSimpleId "s"), Name (mkSimpleId "t"), Name (mkSimpleId "x")] (Bool_sent (BinOp Implication (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "insert-i")) [Term_seq (Name_term (mkSimpleId "i")), Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "t"))] nullRange) (Name_term (mkSimpleId "s"))) nullRange) (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:n-select")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "a"))] nullRange), Term_seq (Name_term (mkSimpleId "i")), Term_seq (Name_term (mkSimpleId "t"))] nullRange) (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Funct_term (Name_term (mkSimpleId "form:n-select")) [Term_seq (Name_term (mkSimpleId "a")), Term_seq (Name_term (mkSimpleId "i")), Term_seq (Name_term (mkSimpleId "t"))] nullRange)] nullRange)) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "a"), Name (mkSimpleId "i"), Name (mkSimpleId "s"), Name (mkSimpleId "t")] (Bool_sent (BinOp Implication (Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "x")] (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "insert-i")) [Term_seq (Name_term (mkSimpleId "i")), Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "t"))] nullRange) (Name_term (mkSimpleId "s"))) nullRange) nullRange)) nullRange) (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:n-select")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "a"))] nullRange), Term_seq (Name_term (mkSimpleId "i")), Term_seq (Name_term (mkSimpleId "t"))] nullRange) (Funct_term (Name_term (mkSimpleId "form:n-select")) [Term_seq (Name_term (mkSimpleId "a")), Term_seq (Name_term (mkSimpleId "i")), Term_seq (Name_term (mkSimpleId "t"))] nullRange)) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "s")] (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "insert-i")) [Term_seq (Name_term (mkSimpleId "form:0")), Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))] nullRange) (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "i"), Name (mkSimpleId "j"), Name (mkSimpleId "x"), Name (mkSimpleId "y"), Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:add-one")) [Term_seq (Name_term (mkSimpleId "i")), Term_seq (Name_term (mkSimpleId "j"))]) nullRange) (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "insert-i")) [Term_seq (Name_term (mkSimpleId "j")), Term_seq (Name_term (mkSimpleId "x")), Term_seq (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Name_term (mkSimpleId "y")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange) (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Name_term (mkSimpleId "y")), Term_seq (Funct_term (Name_term (mkSimpleId "insert-i")) [Term_seq (Name_term (mkSimpleId "i")), Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange)) nullRange)) nullRange) nullRange)] +sequences_insertSens3 :: [PHRASE] +sequences_insertSens3 = [Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "y")] (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:first")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:pair")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "y"))] nullRange)] nullRange) (Name_term (mkSimpleId "x"))) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "y")] (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:second")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:pair")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "y"))] nullRange)] nullRange) (Name_term (mkSimpleId "y"))) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "y")] (Atom_sent (Atom (Name_term (mkSimpleId "form:Pair")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:pair")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "y"))] nullRange)]) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "p")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Pair")) [Term_seq (Name_term (mkSimpleId "p"))]) nullRange) (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:pair")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:first")) [Term_seq (Name_term (mkSimpleId "p"))] nullRange), Term_seq (Funct_term (Name_term (mkSimpleId "form:second")) [Term_seq (Name_term (mkSimpleId "p"))] nullRange)] nullRange) (Name_term (mkSimpleId "p"))) nullRange)) nullRange) nullRange)] +sequences_insertSens4 :: [PHRASE] +sequences_insertSens4 = [Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:Position")) [Term_seq (Name_term (mkSimpleId "pt"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s1"), Name (mkSimpleId "s2"), Name (mkSimpleId "pt")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:in-sequence")) [Term_seq (Name_term (mkSimpleId "s1")), Term_seq (Name_term (mkSimpleId "pt"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:in-sequence")) [Term_seq (Name_term (mkSimpleId "s2")), Term_seq (Name_term (mkSimpleId "pt"))]) nullRange]) nullRange) (Atom_sent (Equation (Name_term (mkSimpleId "s1")) (Name_term (mkSimpleId "s2"))) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "pt")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Position")) [Term_seq (Name_term (mkSimpleId "pt"))]) nullRange) (Quant_sent Existential [Name (mkSimpleId "s")] (Atom_sent (Atom (Name_term (mkSimpleId "form:in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt"))]) nullRange) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt1"), Name (mkSimpleId "pt2")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "buml:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:Position")) [Term_seq (Name_term (mkSimpleId "pt1"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:Position")) [Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt1"), Name (mkSimpleId "pt2")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "s"), Name (mkSimpleId "pt1"), Name (mkSimpleId "pt2")] (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt2")), Term_seq (Name_term (mkSimpleId "pt1"))]) nullRange]) nullRange) nullRange)) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt1"), Name (mkSimpleId "pt2"), Name (mkSimpleId "pt11"), Name (mkSimpleId "pt22")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt11")), Term_seq (Name_term (mkSimpleId "pt22"))]) nullRange]) nullRange) (Bool_sent (BinOp Biconditional (Atom_sent (Equation (Name_term (mkSimpleId "pt1")) (Name_term (mkSimpleId "pt11"))) nullRange) (Atom_sent (Equation (Name_term (mkSimpleId "pt2")) (Name_term (mkSimpleId "pt22"))) nullRange)) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Bool_sent (BinOp Implication (Quant_sent Existential [Name (mkSimpleId "pt")] (Atom_sent (Atom (Name_term (mkSimpleId "form:in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt"))]) nullRange) nullRange) (Bool_sent (Junction Conjunction [Quant_sent Existential [Name (mkSimpleId "pt1")] (Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt2")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) nullRange)) nullRange) nullRange, Quant_sent Existential [Name (mkSimpleId "pt2")] (Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt1")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) nullRange)) nullRange) nullRange]) nullRange)) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt1"), Name (mkSimpleId "pt11")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt2")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) nullRange)) nullRange, Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt2")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt11")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) nullRange)) nullRange]) nullRange) (Atom_sent (Equation (Name_term (mkSimpleId "pt1")) (Name_term (mkSimpleId "pt11"))) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Quant_sent Existential [Name (mkSimpleId "pt2")] (Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt1")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) nullRange)) nullRange) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt2"), Name (mkSimpleId "pt22")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt1")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) nullRange)) nullRange, Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt1")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt22"))]) nullRange) nullRange)) nullRange]) nullRange) (Atom_sent (Equation (Name_term (mkSimpleId "pt2")) (Name_term (mkSimpleId "pt22"))) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:empty-sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:empty-sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt")] (Atom_sent (Atom (Name_term (mkSimpleId "form:in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt"))]) nullRange) nullRange)) nullRange)) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt"), Name (mkSimpleId "n")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "n"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:Position")) [Term_seq (Name_term (mkSimpleId "pt"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "buml:UnlimtedNatural")) [Term_seq (Name_term (mkSimpleId "n"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt"), Name (mkSimpleId "n1"), Name (mkSimpleId "n2")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "n1"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "n2"))]) nullRange]) nullRange) (Atom_sent (Equation (Name_term (mkSimpleId "n1")) (Name_term (mkSimpleId "n2"))) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt"))]) nullRange) (Quant_sent Existential [Name (mkSimpleId "n")] (Atom_sent (Atom (Name_term (mkSimpleId "form:position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "n"))]) nullRange) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt2")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt1")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) nullRange)) nullRange]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt2")), Term_seq (Name_term (mkSimpleId "form:1"))]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt1"), Name (mkSimpleId "n1"), Name (mkSimpleId "pt2"), Name (mkSimpleId "n2")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "n1"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt2")), Term_seq (Name_term (mkSimpleId "n2"))]) nullRange]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:add-one")) [Term_seq (Name_term (mkSimpleId "n1")), Term_seq (Name_term (mkSimpleId "n2"))]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "n")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:sequence-length")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "n"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "buml:UnlimtedNatural")) [Term_seq (Name_term (mkSimpleId "n"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "n")] (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:sequence-length")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "n"))]) nullRange) (Bool_sent (Junction Disjunction [Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:empty-sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Atom_sent (Equation (Name_term (mkSimpleId "n")) (Name_term (mkSimpleId "form:0"))) nullRange]) nullRange, Quant_sent Existential [Name (mkSimpleId "pt1")] (Bool_sent (Junction Conjunction [Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt2")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) nullRange)) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "n"))]) nullRange]) nullRange) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "pt"), Name (mkSimpleId "x")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:in-position")) [Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:Position")) [Term_seq (Name_term (mkSimpleId "pt"))]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "pt"), Name (mkSimpleId "x1"), Name (mkSimpleId "x2")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:in-position")) [Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "x1"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:in-position")) [Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "x2"))]) nullRange]) nullRange) (Atom_sent (Equation (Name_term (mkSimpleId "x1")) (Name_term (mkSimpleId "x2"))) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "pt")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Position")) [Term_seq (Name_term (mkSimpleId "pt"))]) nullRange) (Quant_sent Existential [Name (mkSimpleId "x")] (Atom_sent (Atom (Name_term (mkSimpleId "form:in-position")) [Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "n"), Name (mkSimpleId "x")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:in-position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "n")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "buml:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:NaturalNumber")) [Term_seq (Name_term (mkSimpleId "n"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "n"), Name (mkSimpleId "x")] (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:in-position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "n")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange) (Quant_sent Existential [Name (mkSimpleId "pt")] (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:in-position")) [Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "n"))]) nullRange]) nullRange) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s1"), Name (mkSimpleId "s2")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:same-sequence")) [Term_seq (Name_term (mkSimpleId "s1")), Term_seq (Name_term (mkSimpleId "s2"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s1"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s2"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s1"), Name (mkSimpleId "s2")] (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:same-sequence")) [Term_seq (Name_term (mkSimpleId "s1")), Term_seq (Name_term (mkSimpleId "s2"))]) nullRange) (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "n")] (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:in-position-count")) [Term_seq (Name_term (mkSimpleId "s1")), Term_seq (Name_term (mkSimpleId "n")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:in-position-count")) [Term_seq (Name_term (mkSimpleId "s2")), Term_seq (Name_term (mkSimpleId "n")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange)) nullRange) nullRange)) nullRange) nullRange)] +sequences_insertSens :: [[PHRASE]] +sequences_insertSens = [sequences_insertSens1, sequences_insertSens2, sequences_insertSens3, sequences_insertSens4] + +stringsdiscourseNames :: Set.Set Id +stringsdiscourseNames = Set.fromList [stringToId "buml:String", stringToId "form:Character", stringToId "form:NaturalNumber", stringToId "form:Sequence", stringToId "form:WholeNumber", stringToId "form:in-position", stringToId "form:in-position-count", stringToId "form:in-sequence", stringToId "form:same-sequence", stringToId "form:same-string", stringToId "form:sequence-length", stringToId "form:string-index-char", stringToId "form:string-index-character", stringToId "form:string-length"] +stringsnondiscourseNames :: Set.Set Id +stringsnondiscourseNames = Set.fromList [] +stringssequenceMarkers :: Set.Set Id +stringssequenceMarkers = Set.fromList [] +stringsSens1 :: [PHRASE] +stringsSens1 = [Sentence (Quant_sent Universal [Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "buml:String")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt"), Name (mkSimpleId "x")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "buml:String")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:in-position")) [Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:Character")) [Term_seq (Name_term (mkSimpleId "x"))]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "n"), Name (mkSimpleId "ch")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:string-index-character")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "n")), Term_seq (Name_term (mkSimpleId "ch"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "buml:String")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:WholeNumber")) [Term_seq (Name_term (mkSimpleId "n"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:Character")) [Term_seq (Name_term (mkSimpleId "ch"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "n"), Name (mkSimpleId "ch")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "buml:String")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:string-index-char")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "n")), Term_seq (Name_term (mkSimpleId "ch"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:in-position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "n")), Term_seq (Name_term (mkSimpleId "ch"))]) nullRange)) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "n")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:string-length")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "n"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "buml:String")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:NaturalNumber")) [Term_seq (Name_term (mkSimpleId "n"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "buml:String")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Quant_sent Universal [Name (mkSimpleId "n")] (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:string-length")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "n"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:sequence-length")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "n"))]) nullRange)) nullRange) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s1"), Name (mkSimpleId "s2")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:same-string")) [Term_seq (Name_term (mkSimpleId "s1")), Term_seq (Name_term (mkSimpleId "s2"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "buml:String")) [Term_seq (Name_term (mkSimpleId "s1"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "buml:String")) [Term_seq (Name_term (mkSimpleId "s2"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s1"), Name (mkSimpleId "s2")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "buml:String")) [Term_seq (Name_term (mkSimpleId "s1"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "buml:String")) [Term_seq (Name_term (mkSimpleId "s2"))]) nullRange]) nullRange) (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:same-string")) [Term_seq (Name_term (mkSimpleId "s1")), Term_seq (Name_term (mkSimpleId "s2"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:same-sequence")) [Term_seq (Name_term (mkSimpleId "s1")), Term_seq (Name_term (mkSimpleId "s2"))]) nullRange)) nullRange)) nullRange) nullRange)] +stringsSens :: [[PHRASE]] +stringsSens = [stringsSens1] + +collection_typesdiscourseNames :: Set.Set Id +collection_typesdiscourseNames = Set.fromList [stringToId "buml:Sequence", stringToId "buml:UnlimitedNatural", stringToId "buml:UnlimtedNatural", stringToId "buml:leq", stringToId "buml:less-than", stringToId "form:0", stringToId "form:1", stringToId "form:Bag", stringToId "form:NaturalNumber", stringToId "form:Ordered-Set", stringToId "form:Ordererd-Set", stringToId "form:Pair", stringToId "form:Position", stringToId "form:Sequence", stringToId "form:Set", stringToId "form:add-one", stringToId "form:bag-insert", stringToId "form:bag-member", stringToId "form:bag-member-count", stringToId "form:bag-size", stringToId "form:bag2set", stringToId "form:before-in-ordered-set", stringToId "form:before-in-sequence", stringToId "form:empty-bag", stringToId "form:empty-ordered-set", stringToId "form:empty-sequence", stringToId "form:empty-set", stringToId "form:first", stringToId "form:in-ordered-set", stringToId "form:in-ordered-set-position-count", stringToId "form:in-position", stringToId "form:in-position-count", stringToId "form:in-sequence", stringToId "form:n-select", stringToId "form:ordered-set-insert", stringToId "form:ordered-set-member", stringToId "form:ordered-set-position-count", stringToId "form:ordered-set-size", stringToId "form:ordset2set", stringToId "form:pair", stringToId "form:position-count", stringToId "form:same-bag", stringToId "form:same-ordered-set", stringToId "form:same-sequence", stringToId "form:same-set", stringToId "form:second", stringToId "form:select1", stringToId "form:select2", stringToId "form:seq2bag", stringToId "form:seq2ordset", stringToId "form:seq2set", stringToId "form:sequence-insert", stringToId "form:sequence-length", stringToId "form:sequence-member", stringToId "form:sequence-size", stringToId "form:set-insert", stringToId "form:set-member", stringToId "form:set-size", stringToId "from:ordered-set-member", stringToId "insert-i", stringToId "s", stringToId "s1"] +collection_typesnondiscourseNames :: Set.Set Id +collection_typesnondiscourseNames = Set.fromList [] +collection_typessequenceMarkers :: Set.Set Id +collection_typessequenceMarkers = Set.fromList [] +collection_typesSens1 :: [PHRASE] +collection_typesSens1 = [Sentence (Quant_sent Universal [Name (mkSimpleId "b")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Bag")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:Set")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:bag2set")) [Term_seq (Name_term (mkSimpleId "b"))] nullRange)]) nullRange)) nullRange) nullRange), + Sentence (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:bag2set")) [Term_seq (Name_term (mkSimpleId "form:empty-bag"))] nullRange) (Name_term (mkSimpleId "form:empty-set"))) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "b")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Bag")) [Term_seq (Name_term (mkSimpleId "b"))]) nullRange) (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:bag2set")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:set-insert")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "b"))] nullRange)] nullRange) (Funct_term (Name_term (mkSimpleId "form:bag-insert")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Funct_term (Name_term (mkSimpleId "form:bag2set")) [Term_seq (Name_term (mkSimpleId "b"))] nullRange)] nullRange)) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:Ordered-Set")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:seq2ordset")) [Term_seq (Name_term (mkSimpleId "s"))] nullRange)]) nullRange)) nullRange) nullRange), + Sentence (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:seq2ordset")) [Term_seq (Name_term (mkSimpleId "form:empty-sequence"))] nullRange) (Name_term (mkSimpleId "form:empty-ordered-set"))) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:seq2ordset")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange) (Funct_term (Name_term (mkSimpleId "form:ordered-set-insert")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Funct_term (Name_term (mkSimpleId "form:seq2ordset")) [Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange)) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:Bag")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:seq2bag")) [Term_seq (Name_term (mkSimpleId "s"))] nullRange)]) nullRange)) nullRange) nullRange), + Sentence (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:seq2bag")) [Term_seq (Name_term (mkSimpleId "form:empty-sequence"))] nullRange) (Name_term (mkSimpleId "form:empty-bag"))) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:seq2bag")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange) (Funct_term (Name_term (mkSimpleId "form:bag-insert")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Funct_term (Name_term (mkSimpleId "form:seq2bag")) [Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange)) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "b")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Ordered-Set")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:Set")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:ordset2set")) [Term_seq (Name_term (mkSimpleId "b"))] nullRange)]) nullRange)) nullRange) nullRange), + Sentence (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:ordset2set")) [Term_seq (Name_term (mkSimpleId "form:empty-ordered-set"))] nullRange) (Name_term (mkSimpleId "form:empty-set"))) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "b")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Ordered-Set")) [Term_seq (Name_term (mkSimpleId "b"))]) nullRange) (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:ordset2set")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:set-insert")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "b"))] nullRange)] nullRange) (Funct_term (Name_term (mkSimpleId "form:ordered-set-insert")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Funct_term (Name_term (mkSimpleId "form:ordset2set")) [Term_seq (Name_term (mkSimpleId "b"))] nullRange)] nullRange)) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:Set")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:seq2set")) [Term_seq (Name_term (mkSimpleId "s"))] nullRange)]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s")] (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:seq2set")) [Term_seq (Name_term (mkSimpleId "s"))] nullRange) (Funct_term (Name_term (mkSimpleId "form:ordset2set")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:seq2ordset")) [Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "y")] (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "buml:leq")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "y"))]) nullRange) (Bool_sent (Junction Disjunction [Atom_sent (Equation (Name_term (mkSimpleId "x")) (Name_term (mkSimpleId "y"))) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "buml:less-than")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "y"))]) nullRange]) nullRange)) nullRange) nullRange)] +collection_typesSens2 :: [PHRASE] +collection_typesSens2 = [Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "s1"), Name (mkSimpleId "s2")] (Bool_sent (BinOp Implication (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s1"))] nullRange) (Name_term (mkSimpleId "s2"))) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s1"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s2"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:in-position-count")) [Term_seq (Name_term (mkSimpleId "s2")), Term_seq (Name_term (mkSimpleId "form:1")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange, Quant_sent Universal [Name (mkSimpleId "n1"), Name (mkSimpleId "n2"), Name (mkSimpleId "y")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:add-one")) [Term_seq (Name_term (mkSimpleId "n1")), Term_seq (Name_term (mkSimpleId "n2"))]) nullRange) (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:in-position-count")) [Term_seq (Name_term (mkSimpleId "s1")), Term_seq (Name_term (mkSimpleId "n1")), Term_seq (Name_term (mkSimpleId "y"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:in-position-count")) [Term_seq (Name_term (mkSimpleId "s2")), Term_seq (Name_term (mkSimpleId "n2")), Term_seq (Name_term (mkSimpleId "y"))]) nullRange)) nullRange)) nullRange) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s")] (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:sequence-length")) [Term_seq (Name_term (mkSimpleId "s"))] nullRange) (Funct_term (Name_term (mkSimpleId "form:sequence-size")) [Term_seq (Name_term (mkSimpleId "s"))] nullRange)) nullRange) nullRange)] +collection_typesSens3 :: [PHRASE] +collection_typesSens3 = [Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:sequence-member")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "s")] (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:sequence-member")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Quant_sent Existential [Name (mkSimpleId "pt")] (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:in-position")) [Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange]) nullRange) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "o")] (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:select1")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Name_term (mkSimpleId "form:empty-sequence"))] nullRange) (Name_term (mkSimpleId "form:empty-sequence"))) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "o"), Name (mkSimpleId "y"), Name (mkSimpleId "s")] (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:select1")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:pair")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Name_term (mkSimpleId "y"))] nullRange), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange) (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Name_term (mkSimpleId "y")), Term_seq (Funct_term (Name_term (mkSimpleId "form:select1")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "o"), Name (mkSimpleId "x"), Name (mkSimpleId "y"), Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Bool_sent (Negation (Atom_sent (Equation (Name_term (mkSimpleId "x")) (Name_term (mkSimpleId "o"))) nullRange)) nullRange) (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:select1")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:pair")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "y"))] nullRange), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange) (Funct_term (Name_term (mkSimpleId "form:select1")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "o")] (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:select2")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Name_term (mkSimpleId "form:empty-sequence"))] nullRange) (Name_term (mkSimpleId "form:empty-sequence"))) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "o"), Name (mkSimpleId "x"), Name (mkSimpleId "s")] (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:select2")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:pair")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "o"))] nullRange), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange) (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Funct_term (Name_term (mkSimpleId "form:select2")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "o"), Name (mkSimpleId "x"), Name (mkSimpleId "y"), Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Bool_sent (Negation (Atom_sent (Equation (Name_term (mkSimpleId "y")) (Name_term (mkSimpleId "o"))) nullRange)) nullRange) (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:select2")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:pair")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "y"))] nullRange), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange) (Funct_term (Name_term (mkSimpleId "form:select2")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "i"), Name (mkSimpleId "s")] (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:n-select")) [Term_seq (Name_term (mkSimpleId "form:empty-sequence")), Term_seq (Name_term (mkSimpleId "i")), Term_seq (Name_term (mkSimpleId "s"))] nullRange) (Name_term (mkSimpleId "form:empty-sequence"))) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "a"), Name (mkSimpleId "i"), Name (mkSimpleId "s"), Name (mkSimpleId "t"), Name (mkSimpleId "x")] (Bool_sent (BinOp Implication (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "insert-i")) [Term_seq (Name_term (mkSimpleId "i")), Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "t"))] nullRange) (Name_term (mkSimpleId "s"))) nullRange) (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:n-select")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "a"))] nullRange), Term_seq (Name_term (mkSimpleId "i")), Term_seq (Name_term (mkSimpleId "t"))] nullRange) (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Funct_term (Name_term (mkSimpleId "form:n-select")) [Term_seq (Name_term (mkSimpleId "a")), Term_seq (Name_term (mkSimpleId "i")), Term_seq (Name_term (mkSimpleId "t"))] nullRange)] nullRange)) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "a"), Name (mkSimpleId "i"), Name (mkSimpleId "s"), Name (mkSimpleId "t")] (Bool_sent (BinOp Implication (Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "x")] (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "insert-i")) [Term_seq (Name_term (mkSimpleId "i")), Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "t"))] nullRange) (Name_term (mkSimpleId "s"))) nullRange) nullRange)) nullRange) (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:n-select")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "a"))] nullRange), Term_seq (Name_term (mkSimpleId "i")), Term_seq (Name_term (mkSimpleId "t"))] nullRange) (Funct_term (Name_term (mkSimpleId "form:n-select")) [Term_seq (Name_term (mkSimpleId "a")), Term_seq (Name_term (mkSimpleId "i")), Term_seq (Name_term (mkSimpleId "t"))] nullRange)) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "s")] (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "insert-i")) [Term_seq (Name_term (mkSimpleId "form:0")), Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))] nullRange) (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "i"), Name (mkSimpleId "j"), Name (mkSimpleId "x"), Name (mkSimpleId "y"), Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:add-one")) [Term_seq (Name_term (mkSimpleId "i")), Term_seq (Name_term (mkSimpleId "j"))]) nullRange) (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "insert-i")) [Term_seq (Name_term (mkSimpleId "j")), Term_seq (Name_term (mkSimpleId "x")), Term_seq (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Name_term (mkSimpleId "y")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange) (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Name_term (mkSimpleId "y")), Term_seq (Funct_term (Name_term (mkSimpleId "insert-i")) [Term_seq (Name_term (mkSimpleId "i")), Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange)) nullRange)) nullRange) nullRange)] +collection_typesSens4 :: [PHRASE] +collection_typesSens4 = [Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "y")] (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:first")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:pair")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "y"))] nullRange)] nullRange) (Name_term (mkSimpleId "x"))) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "y")] (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:second")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:pair")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "y"))] nullRange)] nullRange) (Name_term (mkSimpleId "y"))) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "y")] (Atom_sent (Atom (Name_term (mkSimpleId "form:Pair")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:pair")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "y"))] nullRange)]) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "p")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Pair")) [Term_seq (Name_term (mkSimpleId "p"))]) nullRange) (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:pair")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:first")) [Term_seq (Name_term (mkSimpleId "p"))] nullRange), Term_seq (Funct_term (Name_term (mkSimpleId "form:second")) [Term_seq (Name_term (mkSimpleId "p"))] nullRange)] nullRange) (Name_term (mkSimpleId "p"))) nullRange)) nullRange) nullRange)] +collection_typesSens5 :: [PHRASE] +collection_typesSens5 = [Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:Position")) [Term_seq (Name_term (mkSimpleId "pt"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s1"), Name (mkSimpleId "s2"), Name (mkSimpleId "pt")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:in-sequence")) [Term_seq (Name_term (mkSimpleId "s1")), Term_seq (Name_term (mkSimpleId "pt"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:in-sequence")) [Term_seq (Name_term (mkSimpleId "s2")), Term_seq (Name_term (mkSimpleId "pt"))]) nullRange]) nullRange) (Atom_sent (Equation (Name_term (mkSimpleId "s1")) (Name_term (mkSimpleId "s2"))) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "pt")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Position")) [Term_seq (Name_term (mkSimpleId "pt"))]) nullRange) (Quant_sent Existential [Name (mkSimpleId "s")] (Atom_sent (Atom (Name_term (mkSimpleId "form:in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt"))]) nullRange) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt1"), Name (mkSimpleId "pt2")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "buml:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:Position")) [Term_seq (Name_term (mkSimpleId "pt1"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:Position")) [Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt1"), Name (mkSimpleId "pt2")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "s"), Name (mkSimpleId "pt1"), Name (mkSimpleId "pt2")] (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt2")), Term_seq (Name_term (mkSimpleId "pt1"))]) nullRange]) nullRange) nullRange)) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt1"), Name (mkSimpleId "pt2"), Name (mkSimpleId "pt11"), Name (mkSimpleId "pt22")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt11")), Term_seq (Name_term (mkSimpleId "pt22"))]) nullRange]) nullRange) (Bool_sent (BinOp Biconditional (Atom_sent (Equation (Name_term (mkSimpleId "pt1")) (Name_term (mkSimpleId "pt11"))) nullRange) (Atom_sent (Equation (Name_term (mkSimpleId "pt2")) (Name_term (mkSimpleId "pt22"))) nullRange)) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Bool_sent (BinOp Implication (Quant_sent Existential [Name (mkSimpleId "pt")] (Atom_sent (Atom (Name_term (mkSimpleId "form:in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt"))]) nullRange) nullRange) (Bool_sent (Junction Conjunction [Quant_sent Existential [Name (mkSimpleId "pt1")] (Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt2")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) nullRange)) nullRange) nullRange, Quant_sent Existential [Name (mkSimpleId "pt2")] (Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt1")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) nullRange)) nullRange) nullRange]) nullRange)) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt1"), Name (mkSimpleId "pt11")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt2")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) nullRange)) nullRange, Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt2")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt11")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) nullRange)) nullRange]) nullRange) (Atom_sent (Equation (Name_term (mkSimpleId "pt1")) (Name_term (mkSimpleId "pt11"))) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Quant_sent Existential [Name (mkSimpleId "pt2")] (Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt1")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) nullRange)) nullRange) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt2"), Name (mkSimpleId "pt22")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt1")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) nullRange)) nullRange, Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt1")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt22"))]) nullRange) nullRange)) nullRange]) nullRange) (Atom_sent (Equation (Name_term (mkSimpleId "pt2")) (Name_term (mkSimpleId "pt22"))) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:empty-sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:empty-sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt")] (Atom_sent (Atom (Name_term (mkSimpleId "form:in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt"))]) nullRange) nullRange)) nullRange)) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt"), Name (mkSimpleId "n")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "n"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:Position")) [Term_seq (Name_term (mkSimpleId "pt"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "buml:UnlimtedNatural")) [Term_seq (Name_term (mkSimpleId "n"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt"), Name (mkSimpleId "n1"), Name (mkSimpleId "n2")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "n1"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "n2"))]) nullRange]) nullRange) (Atom_sent (Equation (Name_term (mkSimpleId "n1")) (Name_term (mkSimpleId "n2"))) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt"))]) nullRange) (Quant_sent Existential [Name (mkSimpleId "n")] (Atom_sent (Atom (Name_term (mkSimpleId "form:position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "n"))]) nullRange) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt2")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt1")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) nullRange)) nullRange]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt2")), Term_seq (Name_term (mkSimpleId "form:1"))]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt1"), Name (mkSimpleId "n1"), Name (mkSimpleId "pt2"), Name (mkSimpleId "n2")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "n1"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt2")), Term_seq (Name_term (mkSimpleId "n2"))]) nullRange]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:add-one")) [Term_seq (Name_term (mkSimpleId "n1")), Term_seq (Name_term (mkSimpleId "n2"))]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "n")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:sequence-length")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "n"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "buml:UnlimtedNatural")) [Term_seq (Name_term (mkSimpleId "n"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "n")] (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:sequence-length")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "n"))]) nullRange) (Bool_sent (Junction Disjunction [Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:empty-sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Atom_sent (Equation (Name_term (mkSimpleId "n")) (Name_term (mkSimpleId "form:0"))) nullRange]) nullRange, Quant_sent Existential [Name (mkSimpleId "pt1")] (Bool_sent (Junction Conjunction [Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt2")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) nullRange)) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "n"))]) nullRange]) nullRange) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "pt"), Name (mkSimpleId "x")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:in-position")) [Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:Position")) [Term_seq (Name_term (mkSimpleId "pt"))]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "pt"), Name (mkSimpleId "x1"), Name (mkSimpleId "x2")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:in-position")) [Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "x1"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:in-position")) [Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "x2"))]) nullRange]) nullRange) (Atom_sent (Equation (Name_term (mkSimpleId "x1")) (Name_term (mkSimpleId "x2"))) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "pt")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Position")) [Term_seq (Name_term (mkSimpleId "pt"))]) nullRange) (Quant_sent Existential [Name (mkSimpleId "x")] (Atom_sent (Atom (Name_term (mkSimpleId "form:in-position")) [Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "n"), Name (mkSimpleId "x")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:in-position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "n")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "buml:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:NaturalNumber")) [Term_seq (Name_term (mkSimpleId "n"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "n"), Name (mkSimpleId "x")] (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:in-position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "n")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange) (Quant_sent Existential [Name (mkSimpleId "pt")] (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:in-position")) [Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "n"))]) nullRange]) nullRange) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s1"), Name (mkSimpleId "s2")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:same-sequence")) [Term_seq (Name_term (mkSimpleId "s1")), Term_seq (Name_term (mkSimpleId "s2"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s1"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s2"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s1"), Name (mkSimpleId "s2")] (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:same-sequence")) [Term_seq (Name_term (mkSimpleId "s1")), Term_seq (Name_term (mkSimpleId "s2"))]) nullRange) (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "n")] (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:in-position-count")) [Term_seq (Name_term (mkSimpleId "s1")), Term_seq (Name_term (mkSimpleId "n")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:in-position-count")) [Term_seq (Name_term (mkSimpleId "s2")), Term_seq (Name_term (mkSimpleId "n")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange)) nullRange) nullRange)) nullRange) nullRange)] +collection_typesSens6 :: [PHRASE] +collection_typesSens6 = [Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "x1"), Name (mkSimpleId "x2"), Name (mkSimpleId "n1"), Name (mkSimpleId "n2")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:in-ordered-set-position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "n1")), Term_seq (Name_term (mkSimpleId "x1"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:in-ordered-set-position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "n2")), Term_seq (Name_term (mkSimpleId "x2"))]) nullRange, Atom_sent (Equation (Name_term (mkSimpleId "x1")) (Name_term (mkSimpleId "x2"))) nullRange]) nullRange) (Atom_sent (Equation (Name_term (mkSimpleId "n1")) (Name_term (mkSimpleId "n2"))) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "s1"), Name (mkSimpleId "s2")] (Bool_sent (BinOp Implication (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:ordered-set-insert")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s1"))] nullRange) (Name_term (mkSimpleId "s2"))) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Ordererd-Set")) [Term_seq (Name_term (mkSimpleId "s1"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:Ordererd-Set")) [Term_seq (Name_term (mkSimpleId "s2"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "from:ordered-set-member")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:ordered-set-insert")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))] nullRange) (Name_term (mkSimpleId "s"))) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Bool_sent (Negation (Atom_sent (Atom (Name_term (mkSimpleId "from:ordered-set-member")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s1"))]) nullRange)) nullRange) (Quant_sent Existential [Name (mkSimpleId "s2")] (Bool_sent (Junction Conjunction [Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:ordered-set-insert")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s1"))] nullRange) (Name_term (mkSimpleId "s2"))) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:in-ordered-set-position-count")) [Term_seq (Name_term (mkSimpleId "s2")), Term_seq (Name_term (mkSimpleId "form:1")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange, Quant_sent Universal [Name (mkSimpleId "n1"), Name (mkSimpleId "n2"), Name (mkSimpleId "y")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:add-one")) [Term_seq (Name_term (mkSimpleId "n1")), Term_seq (Name_term (mkSimpleId "n2"))]) nullRange) (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:in-ordered-set-position-count")) [Term_seq (Name_term (mkSimpleId "s1")), Term_seq (Name_term (mkSimpleId "n1")), Term_seq (Name_term (mkSimpleId "y"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:in-ordered-set-position-count")) [Term_seq (Name_term (mkSimpleId "s2")), Term_seq (Name_term (mkSimpleId "n2")), Term_seq (Name_term (mkSimpleId "y"))]) nullRange)) nullRange)) nullRange) nullRange]) nullRange) nullRange)) nullRange) nullRange)] +collection_typesSens7 :: [PHRASE] +collection_typesSens7 = [Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:ordered-set-member")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:Ordered-Set")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "s")] (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:ordered-set-member")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Quant_sent Existential [Name (mkSimpleId "pt")] (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:in-position")) [Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange]) nullRange) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "o")] (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:select1")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Name_term (mkSimpleId "form:empty-ordered-set"))] nullRange) (Name_term (mkSimpleId "form:empty-ordered-set"))) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "o"), Name (mkSimpleId "y"), Name (mkSimpleId "s")] (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:select1")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:pair")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Name_term (mkSimpleId "y"))] nullRange), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange) (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Name_term (mkSimpleId "y")), Term_seq (Funct_term (Name_term (mkSimpleId "form:select1")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "o"), Name (mkSimpleId "x"), Name (mkSimpleId "y"), Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Bool_sent (Negation (Atom_sent (Equation (Name_term (mkSimpleId "x")) (Name_term (mkSimpleId "o"))) nullRange)) nullRange) (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:select1")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:pair")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "y"))] nullRange), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange) (Funct_term (Name_term (mkSimpleId "form:select1")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "o")] (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:select2")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Name_term (mkSimpleId "form:empty-ordered-set"))] nullRange) (Name_term (mkSimpleId "form:empty-ordered-set"))) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "o"), Name (mkSimpleId "x"), Name (mkSimpleId "s")] (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:select2")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:pair")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "o"))] nullRange), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange) (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Funct_term (Name_term (mkSimpleId "form:select2")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "o"), Name (mkSimpleId "x"), Name (mkSimpleId "y"), Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Bool_sent (Negation (Atom_sent (Equation (Name_term (mkSimpleId "y")) (Name_term (mkSimpleId "o"))) nullRange)) nullRange) (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:select2")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:pair")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "y"))] nullRange), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange) (Funct_term (Name_term (mkSimpleId "form:select2")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "i"), Name (mkSimpleId "s")] (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:n-select")) [Term_seq (Name_term (mkSimpleId "form:empty-ordered-set")), Term_seq (Name_term (mkSimpleId "i")), Term_seq (Name_term (mkSimpleId "s"))] nullRange) (Name_term (mkSimpleId "form:empty-ordered-set"))) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "a"), Name (mkSimpleId "i"), Name (mkSimpleId "s"), Name (mkSimpleId "t"), Name (mkSimpleId "x")] (Bool_sent (BinOp Implication (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "insert-i")) [Term_seq (Name_term (mkSimpleId "i")), Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "t"))] nullRange) (Name_term (mkSimpleId "s"))) nullRange) (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:n-select")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "a"))] nullRange), Term_seq (Name_term (mkSimpleId "i")), Term_seq (Name_term (mkSimpleId "t"))] nullRange) (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Funct_term (Name_term (mkSimpleId "form:n-select")) [Term_seq (Name_term (mkSimpleId "a")), Term_seq (Name_term (mkSimpleId "i")), Term_seq (Name_term (mkSimpleId "t"))] nullRange)] nullRange)) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "a"), Name (mkSimpleId "i"), Name (mkSimpleId "s"), Name (mkSimpleId "t")] (Bool_sent (BinOp Implication (Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "x")] (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "insert-i")) [Term_seq (Name_term (mkSimpleId "i")), Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "t"))] nullRange) (Name_term (mkSimpleId "s"))) nullRange) nullRange)) nullRange) (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:n-select")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "a"))] nullRange), Term_seq (Name_term (mkSimpleId "i")), Term_seq (Name_term (mkSimpleId "t"))] nullRange) (Funct_term (Name_term (mkSimpleId "form:n-select")) [Term_seq (Name_term (mkSimpleId "a")), Term_seq (Name_term (mkSimpleId "i")), Term_seq (Name_term (mkSimpleId "t"))] nullRange)) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "s")] (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "insert-i")) [Term_seq (Name_term (mkSimpleId "form:0")), Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))] nullRange) (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "i"), Name (mkSimpleId "j"), Name (mkSimpleId "x"), Name (mkSimpleId "y"), Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:add-one")) [Term_seq (Name_term (mkSimpleId "i")), Term_seq (Name_term (mkSimpleId "j"))]) nullRange) (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "insert-i")) [Term_seq (Name_term (mkSimpleId "j")), Term_seq (Name_term (mkSimpleId "x")), Term_seq (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Name_term (mkSimpleId "y")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange) (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Name_term (mkSimpleId "y")), Term_seq (Funct_term (Name_term (mkSimpleId "insert-i")) [Term_seq (Name_term (mkSimpleId "i")), Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange)) nullRange)) nullRange) nullRange)] +collection_typesSens8 :: [PHRASE] +collection_typesSens8 = [Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Ordered-Set")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:Position")) [Term_seq (Name_term (mkSimpleId "pt"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s1"), Name (mkSimpleId "s2"), Name (mkSimpleId "pt")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s1")), Term_seq (Name_term (mkSimpleId "pt"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s2")), Term_seq (Name_term (mkSimpleId "pt"))]) nullRange]) nullRange) (Atom_sent (Equation (Name_term (mkSimpleId "s1")) (Name_term (mkSimpleId "s2"))) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "pt")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Position")) [Term_seq (Name_term (mkSimpleId "pt"))]) nullRange) (Quant_sent Existential [Name (mkSimpleId "s")] (Atom_sent (Atom (Name_term (mkSimpleId "form:in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt"))]) nullRange) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt1"), Name (mkSimpleId "pt2")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "buml:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:Position")) [Term_seq (Name_term (mkSimpleId "pt1"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:Position")) [Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt1"), Name (mkSimpleId "pt2")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "s"), Name (mkSimpleId "pt1"), Name (mkSimpleId "pt2")] (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt2")), Term_seq (Name_term (mkSimpleId "pt1"))]) nullRange]) nullRange) nullRange)) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt1"), Name (mkSimpleId "pt2"), Name (mkSimpleId "pt11"), Name (mkSimpleId "pt22")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt11")), Term_seq (Name_term (mkSimpleId "pt22"))]) nullRange]) nullRange) (Bool_sent (BinOp Biconditional (Atom_sent (Equation (Name_term (mkSimpleId "pt1")) (Name_term (mkSimpleId "pt11"))) nullRange) (Atom_sent (Equation (Name_term (mkSimpleId "pt2")) (Name_term (mkSimpleId "pt22"))) nullRange)) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Ordered-Set")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Bool_sent (BinOp Implication (Quant_sent Existential [Name (mkSimpleId "pt")] (Atom_sent (Atom (Name_term (mkSimpleId "form:in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt"))]) nullRange) nullRange) (Bool_sent (Junction Conjunction [Quant_sent Existential [Name (mkSimpleId "pt1")] (Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt2")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) nullRange)) nullRange) nullRange, Quant_sent Existential [Name (mkSimpleId "pt2")] (Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt1")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) nullRange)) nullRange) nullRange]) nullRange)) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt1"), Name (mkSimpleId "pt11")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Ordered-Set")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt2")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) nullRange)) nullRange, Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt2")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt11")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) nullRange)) nullRange]) nullRange) (Atom_sent (Equation (Name_term (mkSimpleId "pt1")) (Name_term (mkSimpleId "pt11"))) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Ordered-Set")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Quant_sent Existential [Name (mkSimpleId "pt2")] (Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt1")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) nullRange)) nullRange) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt2"), Name (mkSimpleId "pt22")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Ordered-Set")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt1")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) nullRange)) nullRange, Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt1")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt22"))]) nullRange) nullRange)) nullRange]) nullRange) (Atom_sent (Equation (Name_term (mkSimpleId "pt2")) (Name_term (mkSimpleId "pt22"))) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:empty-ordered-set")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:Ordered-Set")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Ordered-Set")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:empty-ordered-set")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt")] (Atom_sent (Atom (Name_term (mkSimpleId "form:in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt"))]) nullRange) nullRange)) nullRange)) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt"), Name (mkSimpleId "n")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:ordered-set-position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "n"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Ordered-Set")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:Position")) [Term_seq (Name_term (mkSimpleId "pt"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "buml:UnlimtedNatural")) [Term_seq (Name_term (mkSimpleId "n"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt"), Name (mkSimpleId "n1"), Name (mkSimpleId "n2")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:ordered-set-position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "n1"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:ordered-set-position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "n2"))]) nullRange]) nullRange) (Atom_sent (Equation (Name_term (mkSimpleId "n1")) (Name_term (mkSimpleId "n2"))) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt"))]) nullRange) (Quant_sent Existential [Name (mkSimpleId "n")] (Atom_sent (Atom (Name_term (mkSimpleId "form:ordered-set-position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "n"))]) nullRange) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt2")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Ordered-Set")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt1")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) nullRange)) nullRange]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:ordered-set-position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt2")), Term_seq (Name_term (mkSimpleId "form:1"))]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt1"), Name (mkSimpleId "n1"), Name (mkSimpleId "pt2"), Name (mkSimpleId "n2")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:ordered-set-position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "n1"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:ordered-set-position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt2")), Term_seq (Name_term (mkSimpleId "n2"))]) nullRange]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:add-one")) [Term_seq (Name_term (mkSimpleId "n1")), Term_seq (Name_term (mkSimpleId "n2"))]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "n")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:ordered-set-size")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "n"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Ordered-Set")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "buml:UnlimtedNatural")) [Term_seq (Name_term (mkSimpleId "n"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "n")] (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:ordered-set-size")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "n"))]) nullRange) (Bool_sent (Junction Disjunction [Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:empty-ordered-set")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Atom_sent (Equation (Name_term (mkSimpleId "n")) (Name_term (mkSimpleId "form:0"))) nullRange]) nullRange, Quant_sent Existential [Name (mkSimpleId "pt1")] (Bool_sent (Junction Conjunction [Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt2")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) nullRange)) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:ordered-set-position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "n"))]) nullRange]) nullRange) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "pt"), Name (mkSimpleId "x")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:in-position")) [Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:Position")) [Term_seq (Name_term (mkSimpleId "pt"))]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "pt"), Name (mkSimpleId "x1"), Name (mkSimpleId "x2")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:in-position")) [Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "x1"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:in-position")) [Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "x2"))]) nullRange]) nullRange) (Atom_sent (Equation (Name_term (mkSimpleId "x1")) (Name_term (mkSimpleId "x2"))) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "pt")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Position")) [Term_seq (Name_term (mkSimpleId "pt"))]) nullRange) (Quant_sent Existential [Name (mkSimpleId "x")] (Atom_sent (Atom (Name_term (mkSimpleId "form:in-position")) [Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "n"), Name (mkSimpleId "x")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:in-ordered-set-position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "n")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "buml:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:NaturalNumber")) [Term_seq (Name_term (mkSimpleId "n"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "n"), Name (mkSimpleId "x")] (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:in-ordered-set-position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "n")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange) (Quant_sent Existential [Name (mkSimpleId "pt")] (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:in-position")) [Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:ordered-set-position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "n"))]) nullRange]) nullRange) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s1"), Name (mkSimpleId "s2")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:same-ordered-set")) [Term_seq (Name_term (mkSimpleId "s1")), Term_seq (Name_term (mkSimpleId "s2"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Ordered-Set")) [Term_seq (Name_term (mkSimpleId "s1"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:Ordered-Set")) [Term_seq (Name_term (mkSimpleId "s2"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s1"), Name (mkSimpleId "s2")] (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:same-ordered-set")) [Term_seq (Name_term (mkSimpleId "s1")), Term_seq (Name_term (mkSimpleId "s2"))]) nullRange) (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "n")] (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:in-ordered-set-position-count")) [Term_seq (Name_term (mkSimpleId "s1")), Term_seq (Name_term (mkSimpleId "n")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:in-ordered-set-position-count")) [Term_seq (Name_term (mkSimpleId "s2")), Term_seq (Name_term (mkSimpleId "n")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange)) nullRange) nullRange)) nullRange) nullRange)] +collection_typesSens9 :: [PHRASE] +collection_typesSens9 = [Sentence (Quant_sent Universal [Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:empty-set")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:Set")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Set")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:empty-set")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "x")] (Atom_sent (Atom (Name_term (mkSimpleId "form:set-member")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))]) nullRange) nullRange)) nullRange)) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "n")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:set-size")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "n"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Set")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "buml:UnlimitedNatural")) [Term_seq (Name_term (mkSimpleId "n"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:set-size")) [Term_seq (Name_term (mkSimpleId "form:empty-set"))] nullRange) (Name_term (mkSimpleId "form:0"))) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Bool_sent (Negation (Atom_sent (Atom (Name_term (mkSimpleId "form:set-member")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))]) nullRange)) nullRange) (Quant_sent Existential [Name (mkSimpleId "n")] (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:add-one")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:set-size")) [Term_seq (Name_term (mkSimpleId "s"))] nullRange), Term_seq (Name_term (mkSimpleId "n"))]) nullRange, Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:set-size")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:set-insert")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange) (Name_term (mkSimpleId "n"))) nullRange]) nullRange) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s1"), Name (mkSimpleId "s2")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:same-set")) [Term_seq (Name_term (mkSimpleId "s1")), Term_seq (Name_term (mkSimpleId "s2"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Set")) [Term_seq (Name_term (mkSimpleId "s1"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:Set")) [Term_seq (Name_term (mkSimpleId "s2"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s1"), Name (mkSimpleId "s2")] (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:same-set")) [Term_seq (Name_term (mkSimpleId "s1")), Term_seq (Name_term (mkSimpleId "s2"))]) nullRange) (Quant_sent Universal [Name (mkSimpleId "x")] (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:set-member")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s1"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:set-member")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s2"))]) nullRange)) nullRange) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Set")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:Set")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:set-insert")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "y"), Name (mkSimpleId "s")] (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:set-member")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Funct_term (Name_term (mkSimpleId "form:set-insert")) [Term_seq (Name_term (mkSimpleId "y")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)]) nullRange) (Bool_sent (Junction Disjunction [Atom_sent (Equation (Name_term (mkSimpleId "x")) (Name_term (mkSimpleId "y"))) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:set-member")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))]) nullRange]) nullRange)) nullRange) nullRange)] +collection_typesSens10 :: [PHRASE] +collection_typesSens10 = [Sentence (Quant_sent Universal [Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:empty-bag")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:Bag")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Bag")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:empty-bag")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "x")] (Atom_sent (Atom (Name_term (mkSimpleId "form:bag-member")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))]) nullRange) nullRange)) nullRange)) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "n")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:bag-size")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "n"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Bag")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "buml:UnlimitedNatural")) [Term_seq (Name_term (mkSimpleId "n"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:bag-size")) [Term_seq (Name_term (mkSimpleId "form:empty-bag"))] nullRange) (Name_term (mkSimpleId "form:0"))) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "s")] (Quant_sent Existential [Name (mkSimpleId "n")] (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:add-one")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:bag-size")) [Term_seq (Name_term (mkSimpleId "s"))] nullRange), Term_seq (Name_term (mkSimpleId "n"))]) nullRange, Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:bag-size")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:bag-insert")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange) (Name_term (mkSimpleId "n"))) nullRange]) nullRange) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s1"), Name (mkSimpleId "s2")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:same-bag")) [Term_seq (Name_term (mkSimpleId "s1")), Term_seq (Name_term (mkSimpleId "s2"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Bag")) [Term_seq (Name_term (mkSimpleId "s1"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:Bag")) [Term_seq (Name_term (mkSimpleId "s2"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s1"), Name (mkSimpleId "s2")] (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:same-bag")) [Term_seq (Name_term (mkSimpleId "s1")), Term_seq (Name_term (mkSimpleId "s2"))]) nullRange) (Quant_sent Universal [Name (mkSimpleId "x")] (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:bag-member-count")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s1"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:bag-member-count")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s2"))]) nullRange)) nullRange) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Bag")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:Bag")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:bag-insert")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "y"), Name (mkSimpleId "s")] (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:bag-member")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Funct_term (Name_term (mkSimpleId "form:bag-insert")) [Term_seq (Name_term (mkSimpleId "y")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)]) nullRange) (Bool_sent (Junction Disjunction [Atom_sent (Equation (Name_term (mkSimpleId "x")) (Name_term (mkSimpleId "y"))) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:bag-member")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Bag")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "buml:UnlimitedNatural")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:bag-member-count")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)]) nullRange)) nullRange) nullRange), + Sentence (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:bag-member-count")) [Term_seq (Name_term (mkSimpleId "form:empty-bag"))] nullRange) (Name_term (mkSimpleId "form:0"))) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "s")] (Quant_sent Existential [Name (mkSimpleId "n")] (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:add-one")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:bag-member-count")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))] nullRange), Term_seq (Name_term (mkSimpleId "n"))]) nullRange, Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:bag-member-count")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Funct_term (Name_term (mkSimpleId "form:bag-insert")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange) (Name_term (mkSimpleId "n"))) nullRange]) nullRange) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "y"), Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Bool_sent (Negation (Atom_sent (Equation (Name_term (mkSimpleId "x")) (Name_term (mkSimpleId "y"))) nullRange)) nullRange) (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:bag-member-count")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Funct_term (Name_term (mkSimpleId "form:bag-insert")) [Term_seq (Name_term (mkSimpleId "y")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange) (Funct_term (Name_term (mkSimpleId "form:bag-member-count")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)) nullRange)) nullRange) nullRange)] +collection_typesSens :: [[PHRASE]] +collection_typesSens = [collection_typesSens1, collection_typesSens2, collection_typesSens3, collection_typesSens4, collection_typesSens5, collection_typesSens6, collection_typesSens7, collection_typesSens8, collection_typesSens9, collection_typesSens10] + +numbersdiscourseNames :: Set.Set Id +numbersdiscourseNames = Set.fromList [stringToId "buml:*", stringToId "buml:Integer", stringToId "buml:UnlimitedNatural", stringToId "form:-1", stringToId "form:0", stringToId "form:1", stringToId "form:NaturalNumber", stringToId "form:Number", stringToId "form:WholeNumber", stringToId "form:add", stringToId "form:add-one", stringToId "form:less-than", stringToId "form:negate"] +numbersnondiscourseNames :: Set.Set Id +numbersnondiscourseNames = Set.fromList [] +numberssequenceMarkers :: Set.Set Id +numberssequenceMarkers = Set.fromList [] +numbersSens1 :: [PHRASE] +numbersSens1 = [Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "y")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:add-one")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "y"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Number")) [Term_seq (Name_term (mkSimpleId "x"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:Number")) [Term_seq (Name_term (mkSimpleId "y"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "y1"), Name (mkSimpleId "y2")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:add-one")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "y1"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:add-one")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "y2"))]) nullRange]) nullRange) (Atom_sent (Equation (Name_term (mkSimpleId "y1")) (Name_term (mkSimpleId "y2"))) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Number")) [Term_seq (Name_term (mkSimpleId "x"))]) nullRange) (Quant_sent Existential [Name (mkSimpleId "y")] (Atom_sent (Atom (Name_term (mkSimpleId "form:add-one")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "y"))]) nullRange) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "y"), Name (mkSimpleId "z")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:add")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "y")), Term_seq (Name_term (mkSimpleId "z"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Number")) [Term_seq (Name_term (mkSimpleId "x"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:Number")) [Term_seq (Name_term (mkSimpleId "y"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:Number")) [Term_seq (Name_term (mkSimpleId "z"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "y"), Name (mkSimpleId "z1"), Name (mkSimpleId "z2")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:add")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "y")), Term_seq (Name_term (mkSimpleId "z1"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:add")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "y")), Term_seq (Name_term (mkSimpleId "z2"))]) nullRange]) nullRange) (Atom_sent (Equation (Name_term (mkSimpleId "z1")) (Name_term (mkSimpleId "z2"))) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "y")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Number")) [Term_seq (Name_term (mkSimpleId "x"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:Number")) [Term_seq (Name_term (mkSimpleId "y"))]) nullRange]) nullRange) (Quant_sent Existential [Name (mkSimpleId "z")] (Atom_sent (Atom (Name_term (mkSimpleId "form:add")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "y")), Term_seq (Name_term (mkSimpleId "z"))]) nullRange) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "y"), Name (mkSimpleId "y1"), Name (mkSimpleId "x"), Name (mkSimpleId "z1"), Name (mkSimpleId "z")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:add-one")) [Term_seq (Name_term (mkSimpleId "y")), Term_seq (Name_term (mkSimpleId "y1"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:add")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "y1")), Term_seq (Name_term (mkSimpleId "z1"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:add")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "y")), Term_seq (Name_term (mkSimpleId "z"))]) nullRange]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:add-one")) [Term_seq (Name_term (mkSimpleId "z")), Term_seq (Name_term (mkSimpleId "z1"))]) nullRange)) nullRange) nullRange), + Sentence (Atom_sent (Atom (Name_term (mkSimpleId "form:Number")) [Term_seq (Name_term (mkSimpleId "form:0"))]) nullRange), + Sentence (Atom_sent (Atom (Name_term (mkSimpleId "form:add-one")) [Term_seq (Name_term (mkSimpleId "form:0")), Term_seq (Name_term (mkSimpleId "form:1"))]) nullRange), + Sentence (Atom_sent (Atom (Name_term (mkSimpleId "form:add-one")) [Term_seq (Name_term (mkSimpleId "form:-1")), Term_seq (Name_term (mkSimpleId "form:0"))]) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "y")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:less-than")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "y"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Number")) [Term_seq (Name_term (mkSimpleId "x"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:Number")) [Term_seq (Name_term (mkSimpleId "y"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "y")] (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:less-than")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "y"))]) nullRange) (Quant_sent Existential [Name (mkSimpleId "z")] (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Number")) [Term_seq (Name_term (mkSimpleId "z"))]) nullRange, Bool_sent (Negation (Atom_sent (Equation (Name_term (mkSimpleId "z")) (Name_term (mkSimpleId "form:0"))) nullRange)) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:add")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "z")), Term_seq (Name_term (mkSimpleId "y"))]) nullRange]) nullRange) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x")] (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:WholeNumber")) [Term_seq (Name_term (mkSimpleId "x"))]) nullRange) (Bool_sent (Junction Disjunction [Atom_sent (Equation (Name_term (mkSimpleId "x")) (Name_term (mkSimpleId "form:1"))) nullRange, Quant_sent Existential [Name (mkSimpleId "y")] (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:WholeNumber")) [Term_seq (Name_term (mkSimpleId "y"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:add-one")) [Term_seq (Name_term (mkSimpleId "y")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange]) nullRange) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x")] (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:NaturalNumber")) [Term_seq (Name_term (mkSimpleId "x"))]) nullRange) (Bool_sent (Junction Disjunction [Atom_sent (Equation (Name_term (mkSimpleId "x")) (Name_term (mkSimpleId "form:0"))) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:WholeNumber")) [Term_seq (Name_term (mkSimpleId "x"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "buml:UnlimitedNatural")) [Term_seq (Name_term (mkSimpleId "x"))]) nullRange) (Bool_sent (Junction Disjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:NaturalNumber")) [Term_seq (Name_term (mkSimpleId "x"))]) nullRange, Atom_sent (Equation (Name_term (mkSimpleId "x")) (Name_term (mkSimpleId "buml:*"))) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:NaturalNumber")) [Term_seq (Name_term (mkSimpleId "x"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "buml:Integer")) [Term_seq (Name_term (mkSimpleId "x"))]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x")] (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "buml:Integer")) [Term_seq (Name_term (mkSimpleId "x"))]) nullRange) (Bool_sent (Junction Disjunction [Atom_sent (Equation (Name_term (mkSimpleId "x")) (Name_term (mkSimpleId "form:-1"))) nullRange, Quant_sent Existential [Name (mkSimpleId "y")] (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "buml:Integer")) [Term_seq (Name_term (mkSimpleId "y"))]) nullRange, Bool_sent (Junction Disjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:add-one")) [Term_seq (Name_term (mkSimpleId "y")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:add-one")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "y"))]) nullRange]) nullRange]) nullRange) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "y")] (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:negate")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "y"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:add")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "y")), Term_seq (Name_term (mkSimpleId "form:0"))]) nullRange)) nullRange) nullRange)] +numbersSens :: [[PHRASE]] +numbersSens = [numbersSens1] + +ordered_setsdiscourseNames :: Set.Set Id +ordered_setsdiscourseNames = Set.fromList [stringToId "buml:Sequence", stringToId "buml:UnlimtedNatural", stringToId "form:0", stringToId "form:1", stringToId "form:NaturalNumber", stringToId "form:Ordered-Set", stringToId "form:Ordererd-Set", stringToId "form:Pair", stringToId "form:Position", stringToId "form:add-one", stringToId "form:before-in-ordered-set", stringToId "form:empty-ordered-set", stringToId "form:first", stringToId "form:in-ordered-set", stringToId "form:in-ordered-set-position-count", stringToId "form:in-position", stringToId "form:n-select", stringToId "form:ordered-set-insert", stringToId "form:ordered-set-member", stringToId "form:ordered-set-position-count", stringToId "form:ordered-set-size", stringToId "form:pair", stringToId "form:same-ordered-set", stringToId "form:second", stringToId "form:select1", stringToId "form:select2", stringToId "form:sequence-insert", stringToId "from:ordered-set-member", stringToId "insert-i", stringToId "s1"] +ordered_setsnondiscourseNames :: Set.Set Id +ordered_setsnondiscourseNames = Set.fromList [] +ordered_setssequenceMarkers :: Set.Set Id +ordered_setssequenceMarkers = Set.fromList [] +ordered_setsSens1 :: [PHRASE] +ordered_setsSens1 = [Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "x1"), Name (mkSimpleId "x2"), Name (mkSimpleId "n1"), Name (mkSimpleId "n2")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:in-ordered-set-position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "n1")), Term_seq (Name_term (mkSimpleId "x1"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:in-ordered-set-position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "n2")), Term_seq (Name_term (mkSimpleId "x2"))]) nullRange, Atom_sent (Equation (Name_term (mkSimpleId "x1")) (Name_term (mkSimpleId "x2"))) nullRange]) nullRange) (Atom_sent (Equation (Name_term (mkSimpleId "n1")) (Name_term (mkSimpleId "n2"))) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "s1"), Name (mkSimpleId "s2")] (Bool_sent (BinOp Implication (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:ordered-set-insert")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s1"))] nullRange) (Name_term (mkSimpleId "s2"))) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Ordererd-Set")) [Term_seq (Name_term (mkSimpleId "s1"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:Ordererd-Set")) [Term_seq (Name_term (mkSimpleId "s2"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "from:ordered-set-member")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:ordered-set-insert")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))] nullRange) (Name_term (mkSimpleId "s"))) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Bool_sent (Negation (Atom_sent (Atom (Name_term (mkSimpleId "from:ordered-set-member")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s1"))]) nullRange)) nullRange) (Quant_sent Existential [Name (mkSimpleId "s2")] (Bool_sent (Junction Conjunction [Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:ordered-set-insert")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s1"))] nullRange) (Name_term (mkSimpleId "s2"))) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:in-ordered-set-position-count")) [Term_seq (Name_term (mkSimpleId "s2")), Term_seq (Name_term (mkSimpleId "form:1")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange, Quant_sent Universal [Name (mkSimpleId "n1"), Name (mkSimpleId "n2"), Name (mkSimpleId "y")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:add-one")) [Term_seq (Name_term (mkSimpleId "n1")), Term_seq (Name_term (mkSimpleId "n2"))]) nullRange) (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:in-ordered-set-position-count")) [Term_seq (Name_term (mkSimpleId "s1")), Term_seq (Name_term (mkSimpleId "n1")), Term_seq (Name_term (mkSimpleId "y"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:in-ordered-set-position-count")) [Term_seq (Name_term (mkSimpleId "s2")), Term_seq (Name_term (mkSimpleId "n2")), Term_seq (Name_term (mkSimpleId "y"))]) nullRange)) nullRange)) nullRange) nullRange]) nullRange) nullRange)) nullRange) nullRange)] +ordered_setsSens2 :: [PHRASE] +ordered_setsSens2 = [Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:ordered-set-member")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:Ordered-Set")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "s")] (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:ordered-set-member")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Quant_sent Existential [Name (mkSimpleId "pt")] (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:in-position")) [Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange]) nullRange) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "o")] (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:select1")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Name_term (mkSimpleId "form:empty-ordered-set"))] nullRange) (Name_term (mkSimpleId "form:empty-ordered-set"))) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "o"), Name (mkSimpleId "y"), Name (mkSimpleId "s")] (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:select1")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:pair")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Name_term (mkSimpleId "y"))] nullRange), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange) (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Name_term (mkSimpleId "y")), Term_seq (Funct_term (Name_term (mkSimpleId "form:select1")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "o"), Name (mkSimpleId "x"), Name (mkSimpleId "y"), Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Bool_sent (Negation (Atom_sent (Equation (Name_term (mkSimpleId "x")) (Name_term (mkSimpleId "o"))) nullRange)) nullRange) (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:select1")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:pair")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "y"))] nullRange), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange) (Funct_term (Name_term (mkSimpleId "form:select1")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "o")] (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:select2")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Name_term (mkSimpleId "form:empty-ordered-set"))] nullRange) (Name_term (mkSimpleId "form:empty-ordered-set"))) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "o"), Name (mkSimpleId "x"), Name (mkSimpleId "s")] (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:select2")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:pair")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "o"))] nullRange), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange) (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Funct_term (Name_term (mkSimpleId "form:select2")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "o"), Name (mkSimpleId "x"), Name (mkSimpleId "y"), Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Bool_sent (Negation (Atom_sent (Equation (Name_term (mkSimpleId "y")) (Name_term (mkSimpleId "o"))) nullRange)) nullRange) (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:select2")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:pair")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "y"))] nullRange), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange) (Funct_term (Name_term (mkSimpleId "form:select2")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "i"), Name (mkSimpleId "s")] (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:n-select")) [Term_seq (Name_term (mkSimpleId "form:empty-ordered-set")), Term_seq (Name_term (mkSimpleId "i")), Term_seq (Name_term (mkSimpleId "s"))] nullRange) (Name_term (mkSimpleId "form:empty-ordered-set"))) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "a"), Name (mkSimpleId "i"), Name (mkSimpleId "s"), Name (mkSimpleId "t"), Name (mkSimpleId "x")] (Bool_sent (BinOp Implication (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "insert-i")) [Term_seq (Name_term (mkSimpleId "i")), Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "t"))] nullRange) (Name_term (mkSimpleId "s"))) nullRange) (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:n-select")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "a"))] nullRange), Term_seq (Name_term (mkSimpleId "i")), Term_seq (Name_term (mkSimpleId "t"))] nullRange) (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Funct_term (Name_term (mkSimpleId "form:n-select")) [Term_seq (Name_term (mkSimpleId "a")), Term_seq (Name_term (mkSimpleId "i")), Term_seq (Name_term (mkSimpleId "t"))] nullRange)] nullRange)) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "a"), Name (mkSimpleId "i"), Name (mkSimpleId "s"), Name (mkSimpleId "t")] (Bool_sent (BinOp Implication (Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "x")] (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "insert-i")) [Term_seq (Name_term (mkSimpleId "i")), Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "t"))] nullRange) (Name_term (mkSimpleId "s"))) nullRange) nullRange)) nullRange) (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:n-select")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "a"))] nullRange), Term_seq (Name_term (mkSimpleId "i")), Term_seq (Name_term (mkSimpleId "t"))] nullRange) (Funct_term (Name_term (mkSimpleId "form:n-select")) [Term_seq (Name_term (mkSimpleId "a")), Term_seq (Name_term (mkSimpleId "i")), Term_seq (Name_term (mkSimpleId "t"))] nullRange)) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "s")] (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "insert-i")) [Term_seq (Name_term (mkSimpleId "form:0")), Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))] nullRange) (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "i"), Name (mkSimpleId "j"), Name (mkSimpleId "x"), Name (mkSimpleId "y"), Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:add-one")) [Term_seq (Name_term (mkSimpleId "i")), Term_seq (Name_term (mkSimpleId "j"))]) nullRange) (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "insert-i")) [Term_seq (Name_term (mkSimpleId "j")), Term_seq (Name_term (mkSimpleId "x")), Term_seq (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Name_term (mkSimpleId "y")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange) (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Name_term (mkSimpleId "y")), Term_seq (Funct_term (Name_term (mkSimpleId "insert-i")) [Term_seq (Name_term (mkSimpleId "i")), Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange)) nullRange)) nullRange) nullRange)] +ordered_setsSens3 :: [PHRASE] +ordered_setsSens3 = [Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "y")] (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:first")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:pair")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "y"))] nullRange)] nullRange) (Name_term (mkSimpleId "x"))) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "y")] (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:second")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:pair")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "y"))] nullRange)] nullRange) (Name_term (mkSimpleId "y"))) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "y")] (Atom_sent (Atom (Name_term (mkSimpleId "form:Pair")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:pair")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "y"))] nullRange)]) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "p")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Pair")) [Term_seq (Name_term (mkSimpleId "p"))]) nullRange) (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:pair")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:first")) [Term_seq (Name_term (mkSimpleId "p"))] nullRange), Term_seq (Funct_term (Name_term (mkSimpleId "form:second")) [Term_seq (Name_term (mkSimpleId "p"))] nullRange)] nullRange) (Name_term (mkSimpleId "p"))) nullRange)) nullRange) nullRange)] +ordered_setsSens4 :: [PHRASE] +ordered_setsSens4 = [Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Ordered-Set")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:Position")) [Term_seq (Name_term (mkSimpleId "pt"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s1"), Name (mkSimpleId "s2"), Name (mkSimpleId "pt")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s1")), Term_seq (Name_term (mkSimpleId "pt"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s2")), Term_seq (Name_term (mkSimpleId "pt"))]) nullRange]) nullRange) (Atom_sent (Equation (Name_term (mkSimpleId "s1")) (Name_term (mkSimpleId "s2"))) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "pt")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Position")) [Term_seq (Name_term (mkSimpleId "pt"))]) nullRange) (Quant_sent Existential [Name (mkSimpleId "s")] (Atom_sent (Atom (Name_term (mkSimpleId "form:in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt"))]) nullRange) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt1"), Name (mkSimpleId "pt2")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "buml:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:Position")) [Term_seq (Name_term (mkSimpleId "pt1"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:Position")) [Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt1"), Name (mkSimpleId "pt2")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "s"), Name (mkSimpleId "pt1"), Name (mkSimpleId "pt2")] (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt2")), Term_seq (Name_term (mkSimpleId "pt1"))]) nullRange]) nullRange) nullRange)) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt1"), Name (mkSimpleId "pt2"), Name (mkSimpleId "pt11"), Name (mkSimpleId "pt22")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt11")), Term_seq (Name_term (mkSimpleId "pt22"))]) nullRange]) nullRange) (Bool_sent (BinOp Biconditional (Atom_sent (Equation (Name_term (mkSimpleId "pt1")) (Name_term (mkSimpleId "pt11"))) nullRange) (Atom_sent (Equation (Name_term (mkSimpleId "pt2")) (Name_term (mkSimpleId "pt22"))) nullRange)) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Ordered-Set")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Bool_sent (BinOp Implication (Quant_sent Existential [Name (mkSimpleId "pt")] (Atom_sent (Atom (Name_term (mkSimpleId "form:in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt"))]) nullRange) nullRange) (Bool_sent (Junction Conjunction [Quant_sent Existential [Name (mkSimpleId "pt1")] (Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt2")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) nullRange)) nullRange) nullRange, Quant_sent Existential [Name (mkSimpleId "pt2")] (Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt1")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) nullRange)) nullRange) nullRange]) nullRange)) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt1"), Name (mkSimpleId "pt11")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Ordered-Set")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt2")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) nullRange)) nullRange, Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt2")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt11")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) nullRange)) nullRange]) nullRange) (Atom_sent (Equation (Name_term (mkSimpleId "pt1")) (Name_term (mkSimpleId "pt11"))) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Ordered-Set")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Quant_sent Existential [Name (mkSimpleId "pt2")] (Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt1")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) nullRange)) nullRange) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt2"), Name (mkSimpleId "pt22")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Ordered-Set")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt1")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) nullRange)) nullRange, Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt1")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt22"))]) nullRange) nullRange)) nullRange]) nullRange) (Atom_sent (Equation (Name_term (mkSimpleId "pt2")) (Name_term (mkSimpleId "pt22"))) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:empty-ordered-set")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:Ordered-Set")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Ordered-Set")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:empty-ordered-set")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt")] (Atom_sent (Atom (Name_term (mkSimpleId "form:in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt"))]) nullRange) nullRange)) nullRange)) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt"), Name (mkSimpleId "n")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:ordered-set-position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "n"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Ordered-Set")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:Position")) [Term_seq (Name_term (mkSimpleId "pt"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "buml:UnlimtedNatural")) [Term_seq (Name_term (mkSimpleId "n"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt"), Name (mkSimpleId "n1"), Name (mkSimpleId "n2")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:ordered-set-position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "n1"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:ordered-set-position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "n2"))]) nullRange]) nullRange) (Atom_sent (Equation (Name_term (mkSimpleId "n1")) (Name_term (mkSimpleId "n2"))) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt"))]) nullRange) (Quant_sent Existential [Name (mkSimpleId "n")] (Atom_sent (Atom (Name_term (mkSimpleId "form:ordered-set-position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "n"))]) nullRange) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt2")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Ordered-Set")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt1")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) nullRange)) nullRange]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:ordered-set-position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt2")), Term_seq (Name_term (mkSimpleId "form:1"))]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt1"), Name (mkSimpleId "n1"), Name (mkSimpleId "pt2"), Name (mkSimpleId "n2")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:ordered-set-position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "n1"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:ordered-set-position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt2")), Term_seq (Name_term (mkSimpleId "n2"))]) nullRange]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:add-one")) [Term_seq (Name_term (mkSimpleId "n1")), Term_seq (Name_term (mkSimpleId "n2"))]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "n")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:ordered-set-size")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "n"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Ordered-Set")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "buml:UnlimtedNatural")) [Term_seq (Name_term (mkSimpleId "n"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "n")] (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:ordered-set-size")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "n"))]) nullRange) (Bool_sent (Junction Disjunction [Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:empty-ordered-set")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Atom_sent (Equation (Name_term (mkSimpleId "n")) (Name_term (mkSimpleId "form:0"))) nullRange]) nullRange, Quant_sent Existential [Name (mkSimpleId "pt1")] (Bool_sent (Junction Conjunction [Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt2")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-ordered-set")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) nullRange)) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:ordered-set-position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "n"))]) nullRange]) nullRange) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "pt"), Name (mkSimpleId "x")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:in-position")) [Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:Position")) [Term_seq (Name_term (mkSimpleId "pt"))]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "pt"), Name (mkSimpleId "x1"), Name (mkSimpleId "x2")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:in-position")) [Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "x1"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:in-position")) [Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "x2"))]) nullRange]) nullRange) (Atom_sent (Equation (Name_term (mkSimpleId "x1")) (Name_term (mkSimpleId "x2"))) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "pt")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Position")) [Term_seq (Name_term (mkSimpleId "pt"))]) nullRange) (Quant_sent Existential [Name (mkSimpleId "x")] (Atom_sent (Atom (Name_term (mkSimpleId "form:in-position")) [Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "n"), Name (mkSimpleId "x")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:in-ordered-set-position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "n")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "buml:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:NaturalNumber")) [Term_seq (Name_term (mkSimpleId "n"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "n"), Name (mkSimpleId "x")] (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:in-ordered-set-position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "n")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange) (Quant_sent Existential [Name (mkSimpleId "pt")] (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:in-position")) [Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:ordered-set-position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "n"))]) nullRange]) nullRange) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s1"), Name (mkSimpleId "s2")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:same-ordered-set")) [Term_seq (Name_term (mkSimpleId "s1")), Term_seq (Name_term (mkSimpleId "s2"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Ordered-Set")) [Term_seq (Name_term (mkSimpleId "s1"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:Ordered-Set")) [Term_seq (Name_term (mkSimpleId "s2"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s1"), Name (mkSimpleId "s2")] (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:same-ordered-set")) [Term_seq (Name_term (mkSimpleId "s1")), Term_seq (Name_term (mkSimpleId "s2"))]) nullRange) (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "n")] (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:in-ordered-set-position-count")) [Term_seq (Name_term (mkSimpleId "s1")), Term_seq (Name_term (mkSimpleId "n")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:in-ordered-set-position-count")) [Term_seq (Name_term (mkSimpleId "s2")), Term_seq (Name_term (mkSimpleId "n")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange)) nullRange) nullRange)) nullRange) nullRange)] +ordered_setsSens :: [[PHRASE]] +ordered_setsSens = [ordered_setsSens1, ordered_setsSens2, ordered_setsSens3, ordered_setsSens4] + +sequencesdiscourseNames :: Set.Set Id +sequencesdiscourseNames = Set.fromList [stringToId "buml:Sequence", stringToId "buml:UnlimtedNatural", stringToId "form:0", stringToId "form:1", stringToId "form:NaturalNumber", stringToId "form:Pair", stringToId "form:Position", stringToId "form:Sequence", stringToId "form:add-one", stringToId "form:before-in-sequence", stringToId "form:empty-sequence", stringToId "form:first", stringToId "form:in-position", stringToId "form:in-position-count", stringToId "form:in-sequence", stringToId "form:n-select", stringToId "form:pair", stringToId "form:position-count", stringToId "form:same-sequence", stringToId "form:second", stringToId "form:select1", stringToId "form:select2", stringToId "form:sequence-insert", stringToId "form:sequence-length", stringToId "form:sequence-member", stringToId "insert-i"] +sequencesnondiscourseNames :: Set.Set Id +sequencesnondiscourseNames = Set.fromList [] +sequencessequenceMarkers :: Set.Set Id +sequencessequenceMarkers = Set.fromList [] +sequencesSens1 :: [PHRASE] +sequencesSens1 = [Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:sequence-member")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "s")] (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:sequence-member")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Quant_sent Existential [Name (mkSimpleId "pt")] (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:in-position")) [Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange]) nullRange) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "o")] (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:select1")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Name_term (mkSimpleId "form:empty-sequence"))] nullRange) (Name_term (mkSimpleId "form:empty-sequence"))) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "o"), Name (mkSimpleId "y"), Name (mkSimpleId "s")] (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:select1")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:pair")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Name_term (mkSimpleId "y"))] nullRange), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange) (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Name_term (mkSimpleId "y")), Term_seq (Funct_term (Name_term (mkSimpleId "form:select1")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "o"), Name (mkSimpleId "x"), Name (mkSimpleId "y"), Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Bool_sent (Negation (Atom_sent (Equation (Name_term (mkSimpleId "x")) (Name_term (mkSimpleId "o"))) nullRange)) nullRange) (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:select1")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:pair")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "y"))] nullRange), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange) (Funct_term (Name_term (mkSimpleId "form:select1")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "o")] (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:select2")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Name_term (mkSimpleId "form:empty-sequence"))] nullRange) (Name_term (mkSimpleId "form:empty-sequence"))) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "o"), Name (mkSimpleId "x"), Name (mkSimpleId "s")] (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:select2")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:pair")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "o"))] nullRange), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange) (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Funct_term (Name_term (mkSimpleId "form:select2")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "o"), Name (mkSimpleId "x"), Name (mkSimpleId "y"), Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Bool_sent (Negation (Atom_sent (Equation (Name_term (mkSimpleId "y")) (Name_term (mkSimpleId "o"))) nullRange)) nullRange) (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:select2")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:pair")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "y"))] nullRange), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange) (Funct_term (Name_term (mkSimpleId "form:select2")) [Term_seq (Name_term (mkSimpleId "o")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "i"), Name (mkSimpleId "s")] (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:n-select")) [Term_seq (Name_term (mkSimpleId "form:empty-sequence")), Term_seq (Name_term (mkSimpleId "i")), Term_seq (Name_term (mkSimpleId "s"))] nullRange) (Name_term (mkSimpleId "form:empty-sequence"))) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "a"), Name (mkSimpleId "i"), Name (mkSimpleId "s"), Name (mkSimpleId "t"), Name (mkSimpleId "x")] (Bool_sent (BinOp Implication (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "insert-i")) [Term_seq (Name_term (mkSimpleId "i")), Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "t"))] nullRange) (Name_term (mkSimpleId "s"))) nullRange) (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:n-select")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "a"))] nullRange), Term_seq (Name_term (mkSimpleId "i")), Term_seq (Name_term (mkSimpleId "t"))] nullRange) (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Funct_term (Name_term (mkSimpleId "form:n-select")) [Term_seq (Name_term (mkSimpleId "a")), Term_seq (Name_term (mkSimpleId "i")), Term_seq (Name_term (mkSimpleId "t"))] nullRange)] nullRange)) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "a"), Name (mkSimpleId "i"), Name (mkSimpleId "s"), Name (mkSimpleId "t")] (Bool_sent (BinOp Implication (Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "x")] (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "insert-i")) [Term_seq (Name_term (mkSimpleId "i")), Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "t"))] nullRange) (Name_term (mkSimpleId "s"))) nullRange) nullRange)) nullRange) (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:n-select")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "a"))] nullRange), Term_seq (Name_term (mkSimpleId "i")), Term_seq (Name_term (mkSimpleId "t"))] nullRange) (Funct_term (Name_term (mkSimpleId "form:n-select")) [Term_seq (Name_term (mkSimpleId "a")), Term_seq (Name_term (mkSimpleId "i")), Term_seq (Name_term (mkSimpleId "t"))] nullRange)) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "s")] (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "insert-i")) [Term_seq (Name_term (mkSimpleId "form:0")), Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))] nullRange) (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "i"), Name (mkSimpleId "j"), Name (mkSimpleId "x"), Name (mkSimpleId "y"), Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:add-one")) [Term_seq (Name_term (mkSimpleId "i")), Term_seq (Name_term (mkSimpleId "j"))]) nullRange) (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "insert-i")) [Term_seq (Name_term (mkSimpleId "j")), Term_seq (Name_term (mkSimpleId "x")), Term_seq (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Name_term (mkSimpleId "y")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange) (Funct_term (Name_term (mkSimpleId "form:sequence-insert")) [Term_seq (Name_term (mkSimpleId "y")), Term_seq (Funct_term (Name_term (mkSimpleId "insert-i")) [Term_seq (Name_term (mkSimpleId "i")), Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "s"))] nullRange)] nullRange)) nullRange)) nullRange) nullRange)] +sequencesSens2 :: [PHRASE] +sequencesSens2 = [Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "y")] (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:first")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:pair")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "y"))] nullRange)] nullRange) (Name_term (mkSimpleId "x"))) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "y")] (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:second")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:pair")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "y"))] nullRange)] nullRange) (Name_term (mkSimpleId "y"))) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "y")] (Atom_sent (Atom (Name_term (mkSimpleId "form:Pair")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:pair")) [Term_seq (Name_term (mkSimpleId "x")), Term_seq (Name_term (mkSimpleId "y"))] nullRange)]) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "p")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Pair")) [Term_seq (Name_term (mkSimpleId "p"))]) nullRange) (Atom_sent (Equation (Funct_term (Name_term (mkSimpleId "form:pair")) [Term_seq (Funct_term (Name_term (mkSimpleId "form:first")) [Term_seq (Name_term (mkSimpleId "p"))] nullRange), Term_seq (Funct_term (Name_term (mkSimpleId "form:second")) [Term_seq (Name_term (mkSimpleId "p"))] nullRange)] nullRange) (Name_term (mkSimpleId "p"))) nullRange)) nullRange) nullRange)] +sequencesSens3 :: [PHRASE] +sequencesSens3 = [Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:Position")) [Term_seq (Name_term (mkSimpleId "pt"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s1"), Name (mkSimpleId "s2"), Name (mkSimpleId "pt")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:in-sequence")) [Term_seq (Name_term (mkSimpleId "s1")), Term_seq (Name_term (mkSimpleId "pt"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:in-sequence")) [Term_seq (Name_term (mkSimpleId "s2")), Term_seq (Name_term (mkSimpleId "pt"))]) nullRange]) nullRange) (Atom_sent (Equation (Name_term (mkSimpleId "s1")) (Name_term (mkSimpleId "s2"))) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "pt")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Position")) [Term_seq (Name_term (mkSimpleId "pt"))]) nullRange) (Quant_sent Existential [Name (mkSimpleId "s")] (Atom_sent (Atom (Name_term (mkSimpleId "form:in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt"))]) nullRange) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt1"), Name (mkSimpleId "pt2")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "buml:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:Position")) [Term_seq (Name_term (mkSimpleId "pt1"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:Position")) [Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt1"), Name (mkSimpleId "pt2")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "s"), Name (mkSimpleId "pt1"), Name (mkSimpleId "pt2")] (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt2")), Term_seq (Name_term (mkSimpleId "pt1"))]) nullRange]) nullRange) nullRange)) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt1"), Name (mkSimpleId "pt2"), Name (mkSimpleId "pt11"), Name (mkSimpleId "pt22")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt11")), Term_seq (Name_term (mkSimpleId "pt22"))]) nullRange]) nullRange) (Bool_sent (BinOp Biconditional (Atom_sent (Equation (Name_term (mkSimpleId "pt1")) (Name_term (mkSimpleId "pt11"))) nullRange) (Atom_sent (Equation (Name_term (mkSimpleId "pt2")) (Name_term (mkSimpleId "pt22"))) nullRange)) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Bool_sent (BinOp Implication (Quant_sent Existential [Name (mkSimpleId "pt")] (Atom_sent (Atom (Name_term (mkSimpleId "form:in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt"))]) nullRange) nullRange) (Bool_sent (Junction Conjunction [Quant_sent Existential [Name (mkSimpleId "pt1")] (Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt2")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) nullRange)) nullRange) nullRange, Quant_sent Existential [Name (mkSimpleId "pt2")] (Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt1")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) nullRange)) nullRange) nullRange]) nullRange)) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt1"), Name (mkSimpleId "pt11")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt2")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) nullRange)) nullRange, Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt2")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt11")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) nullRange)) nullRange]) nullRange) (Atom_sent (Equation (Name_term (mkSimpleId "pt1")) (Name_term (mkSimpleId "pt11"))) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Quant_sent Existential [Name (mkSimpleId "pt2")] (Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt1")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) nullRange)) nullRange) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt2"), Name (mkSimpleId "pt22")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt1")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) nullRange)) nullRange, Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt1")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt22"))]) nullRange) nullRange)) nullRange]) nullRange) (Atom_sent (Equation (Name_term (mkSimpleId "pt2")) (Name_term (mkSimpleId "pt22"))) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:empty-sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:empty-sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange) (Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt")] (Atom_sent (Atom (Name_term (mkSimpleId "form:in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt"))]) nullRange) nullRange)) nullRange)) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt"), Name (mkSimpleId "n")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "n"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:Position")) [Term_seq (Name_term (mkSimpleId "pt"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "buml:UnlimtedNatural")) [Term_seq (Name_term (mkSimpleId "n"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt"), Name (mkSimpleId "n1"), Name (mkSimpleId "n2")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "n1"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "n2"))]) nullRange]) nullRange) (Atom_sent (Equation (Name_term (mkSimpleId "n1")) (Name_term (mkSimpleId "n2"))) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt"))]) nullRange) (Quant_sent Existential [Name (mkSimpleId "n")] (Atom_sent (Atom (Name_term (mkSimpleId "form:position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "n"))]) nullRange) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt2")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt1")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) nullRange)) nullRange]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt2")), Term_seq (Name_term (mkSimpleId "form:1"))]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "pt1"), Name (mkSimpleId "n1"), Name (mkSimpleId "pt2"), Name (mkSimpleId "n2")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "n1"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt2")), Term_seq (Name_term (mkSimpleId "n2"))]) nullRange]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:add-one")) [Term_seq (Name_term (mkSimpleId "n1")), Term_seq (Name_term (mkSimpleId "n2"))]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "n")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:sequence-length")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "n"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "buml:UnlimtedNatural")) [Term_seq (Name_term (mkSimpleId "n"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "n")] (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:sequence-length")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "n"))]) nullRange) (Bool_sent (Junction Disjunction [Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:empty-sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Atom_sent (Equation (Name_term (mkSimpleId "n")) (Name_term (mkSimpleId "form:0"))) nullRange]) nullRange, Quant_sent Existential [Name (mkSimpleId "pt1")] (Bool_sent (Junction Conjunction [Bool_sent (Negation (Quant_sent Existential [Name (mkSimpleId "pt2")] (Atom_sent (Atom (Name_term (mkSimpleId "form:before-in-sequence")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "pt2"))]) nullRange) nullRange)) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt1")), Term_seq (Name_term (mkSimpleId "n"))]) nullRange]) nullRange) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "pt"), Name (mkSimpleId "x")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:in-position")) [Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:Position")) [Term_seq (Name_term (mkSimpleId "pt"))]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "pt"), Name (mkSimpleId "x1"), Name (mkSimpleId "x2")] (Bool_sent (BinOp Implication (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:in-position")) [Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "x1"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:in-position")) [Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "x2"))]) nullRange]) nullRange) (Atom_sent (Equation (Name_term (mkSimpleId "x1")) (Name_term (mkSimpleId "x2"))) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "pt")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:Position")) [Term_seq (Name_term (mkSimpleId "pt"))]) nullRange) (Quant_sent Existential [Name (mkSimpleId "x")] (Atom_sent (Atom (Name_term (mkSimpleId "form:in-position")) [Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "n"), Name (mkSimpleId "x")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:in-position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "n")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "buml:Sequence")) [Term_seq (Name_term (mkSimpleId "s"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:NaturalNumber")) [Term_seq (Name_term (mkSimpleId "n"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s"), Name (mkSimpleId "n"), Name (mkSimpleId "x")] (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:in-position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "n")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange) (Quant_sent Existential [Name (mkSimpleId "pt")] (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:in-position")) [Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:position-count")) [Term_seq (Name_term (mkSimpleId "s")), Term_seq (Name_term (mkSimpleId "pt")), Term_seq (Name_term (mkSimpleId "n"))]) nullRange]) nullRange) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s1"), Name (mkSimpleId "s2")] (Bool_sent (BinOp Implication (Atom_sent (Atom (Name_term (mkSimpleId "form:same-sequence")) [Term_seq (Name_term (mkSimpleId "s1")), Term_seq (Name_term (mkSimpleId "s2"))]) nullRange) (Bool_sent (Junction Conjunction [Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s1"))]) nullRange, Atom_sent (Atom (Name_term (mkSimpleId "form:Sequence")) [Term_seq (Name_term (mkSimpleId "s2"))]) nullRange]) nullRange)) nullRange) nullRange), + Sentence (Quant_sent Universal [Name (mkSimpleId "s1"), Name (mkSimpleId "s2")] (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:same-sequence")) [Term_seq (Name_term (mkSimpleId "s1")), Term_seq (Name_term (mkSimpleId "s2"))]) nullRange) (Quant_sent Universal [Name (mkSimpleId "x"), Name (mkSimpleId "n")] (Bool_sent (BinOp Biconditional (Atom_sent (Atom (Name_term (mkSimpleId "form:in-position-count")) [Term_seq (Name_term (mkSimpleId "s1")), Term_seq (Name_term (mkSimpleId "n")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange) (Atom_sent (Atom (Name_term (mkSimpleId "form:in-position-count")) [Term_seq (Name_term (mkSimpleId "s2")), Term_seq (Name_term (mkSimpleId "n")), Term_seq (Name_term (mkSimpleId "x"))]) nullRange)) nullRange) nullRange)) nullRange) nullRange)] +sequencesSens :: [[PHRASE]] +sequencesSens = [sequencesSens1, sequencesSens2, sequencesSens3] + +preambleSens :: [[[PHRASE]]] +preambleSens = [pairsSens, uml_enumerationsSens, bagsSens, booleanSens, clsequencesSens, setsSens, uml_cd_preliminariesSens, sequences_insertSens, stringsSens, collection_typesSens, numbersSens, ordered_setsSens, sequencesSens] +preambleDiscourseNames :: [Set.Set Id] +preambleDiscourseNames = [pairsdiscourseNames, uml_enumerationsdiscourseNames, bagsdiscourseNames, booleandiscourseNames, clsequencesdiscourseNames, setsdiscourseNames, uml_cd_preliminariesdiscourseNames, sequences_insertdiscourseNames, stringsdiscourseNames, collection_typesdiscourseNames, numbersdiscourseNames, ordered_setsdiscourseNames, sequencesdiscourseNames] +preambleNonDiscourseNames :: [Set.Set Id] +preambleNonDiscourseNames = [pairsnondiscourseNames, uml_enumerationsnondiscourseNames, bagsnondiscourseNames, booleannondiscourseNames, clsequencesnondiscourseNames, setsnondiscourseNames, uml_cd_preliminariesnondiscourseNames, sequences_insertnondiscourseNames, stringsnondiscourseNames, collection_typesnondiscourseNames, numbersnondiscourseNames, ordered_setsnondiscourseNames, sequencesnondiscourseNames] +preambleSequenceMarkers :: [Set.Set Id] +preambleSequenceMarkers = [pairssequenceMarkers, uml_enumerationssequenceMarkers, bagssequenceMarkers, booleansequenceMarkers, clsequencessequenceMarkers, setssequenceMarkers, uml_cd_preliminariessequenceMarkers, sequences_insertsequenceMarkers, stringssequenceMarkers, collection_typessequenceMarkers, numberssequenceMarkers, ordered_setssequenceMarkers, sequencessequenceMarkers] diff --git a/UML/Utils.hs b/UML/Utils.hs new file mode 100644 index 0000000000..c7a6ac0115 --- /dev/null +++ b/UML/Utils.hs @@ -0,0 +1,14 @@ +module UML.Utils where + +import Text.XML.Light +import UML.XMINames + +parse :: Maybe String -> String -> (Element -> a) -> [Element] -> [a] +parse _ _ _ [] = [] +parse xmiv s f (el : lis) = + case (findAttr (typeName xmiv) el) == Just s of + True -> ((f el) : (parse xmiv s f lis)) + False -> parse xmiv s f lis + +getStringNotInList :: String -> [String] -> String +getStringNotInList s l = s ++ show (head [i | i <- [0 ..], not (elem (s ++ (show i)) l)]) diff --git a/UML/XMINames.hs b/UML/XMINames.hs new file mode 100644 index 0000000000..8bec8ed84f --- /dev/null +++ b/UML/XMINames.hs @@ -0,0 +1,67 @@ +module UML.XMINames where + +import Text.XML.Light +import UML.UML + +xmiURI1 :: Maybe String +xmiURI2 :: Maybe String +--xmiURI1 = Just "http://www.eclipse.org/uml2/3.0.0/UML" +xmiURI1 = Just "http://www.eclipse.org/uml2/5.0.0/UML" +xmiURI2 = Just "http://www.omg.org/spec/XMI/20131001" +--xmiURI2 = Just "http://schema.omg.org/spec/XMI/2.1" + +modelName :: Maybe String -> QName +modelName xmiURI1 = QName {qName = "Model", qURI = xmiURI1 , qPrefix = Just "uml"} -- uri:Just "http://www.eclipse.org/uml2/5.0.0/UML" + +packagedElementName :: QName +packagedElementName = QName {qName = "packagedElement", qURI = Nothing, qPrefix = Nothing} + +generalizationName :: QName +generalizationName = QName {qName = "generalization", qURI = Nothing, qPrefix = Nothing} + +attributeName :: QName +attributeName = QName {qName = "ownedAttribute", qURI = Nothing, qPrefix = Nothing} + +attrTypeName1 :: QName +attrTypeName1 = QName {qName = "type", qURI = Nothing, qPrefix = Nothing} + +attrTypeName2 :: QName +attrTypeName2 = QName {qName = "href", qURI = Nothing, qPrefix = Nothing} + +attrIdName :: Maybe String -> QName +attrIdName xmiURI2 = QName {qName = "id", qURI = xmiURI2 , qPrefix = Nothing} + +typeName :: Maybe String -> QName +typeName xmiURI2 = QName {qName = "type", qURI = xmiURI2, qPrefix = Nothing} + +nameName :: QName +nameName = QName {qName = "name", qURI = Nothing, qPrefix = Nothing} + +attrGeneralName :: QName +attrGeneralName = QName {qName = "general", qURI = Nothing, qPrefix = Nothing} + +procedureName :: QName +procedureName = QName {qName = "ownedOperation", qURI = Nothing, qPrefix = Nothing} + +procParaName :: QName +procParaName = QName {qName = "ownedParameter", qURI = Nothing, qPrefix = Nothing} + +procDirName :: QName +procDirName = QName {qName = "direction", qURI = Nothing, qPrefix = Nothing} + +assoEndName :: QName +assoEndName = QName {qName = "memberEnd", qURI = Nothing, qPrefix = Nothing} + +-- state machinge + +smRegionName :: QName +smRegionName = QName {qName = "region", qURI = Nothing, qPrefix = Nothing} + +smSubvertexName :: QName +smSubvertexName = QName {qName = "subvertex", qURI = Nothing, qPrefix = Nothing} + +smStateName :: QName +smStateName = QName {qName = "state", qURI = Nothing, qPrefix = Nothing} + +sName :: String -> QName +sName s = QName {qName = s, qURI = Nothing, qPrefix = Nothing}