* Kiepuszewski et al. (2000) Bartek Kiepuszewski, Arthur H.M. ter Hofstede, and Christoph Bussler. 2000.  On Structured Workflow Modelling. In _Advanced Information Systems Engineering, 12th International Conference CAiSE 2000, Stockholm, Sweden, June 5–9, 2000, Proceedings_ _(Lecture Notes in Computer Science)_ , Vol. 1789. Springer, 431–445.  https://doi.org/10.1007/3-540-45140-4_29
  * Kiepuszewski et al. (2003) Bartek Kiepuszewski, Arthur H.M. ter Hofstede, and Wil M.P. van der Aalst. 2003.  Fundamentals of Control Flow in Workflows.  _Acta Informatica_ 39, 3 (2003), 143–209.  https://doi.org/10.1007/s00236-002-0105-4
  * La Rosa et al. (2013) Marcello La Rosa, Marlon Dumas, Reina Uba, and Remco M. Dijkman. 2013.  Business Process Model Merging: An Approach to Business Process Consolidation.  _ACM Transactions on Software Engineering and Methodology (TOSEM)_ 22, 2 (2013), 11.  https://doi.org/10.1145/2430545.2430547
  * La Rosa et al. (2011) Marcello La Rosa, Hajo A. Reijers, Wil M.P. van der Aalst, Remco M. Dijkman, Jan Mendling, Marlon Dumas, and Luciano García-Bañuelos. 2011.  Apromore: An Advanced Process Model Repository.  _Expert Systems with Applications (ESWA)_ 38, 6 (2011), 7029–7040.
  * Larcker and Lessig (1980) David F. Larcker and V. Parker Lessig. 1980.  Perceived Usefulness of Information: A Psychometric Examination.  _Decision Sciences_ 11, 1 (1980), 121–134.  https://doi.org/10.1111/j.1540-5915.1980.tb01130.x
  * Leopold (2013) Henrik Leopold. 2013\.  _Natural Language in Business Process Models: Theoretical Foundations, Techniques, and Applications_. Lecture Notes in Business Information Processing, Vol. 168.  Springer-Verlag.
  * Li and Liu (2007) Yujian Li and Bi Liu. 2007\.  A Normalized Levenshtein Distance Metric.  _IEEE Transactions on Pattern Analysis and Machine Intelligence (TPAMI)_ 29, 6 (2007), 1091–1095.
  * Lohmann et al. (2009a) Niels Lohmann, H.M.W. Verbeek, and Remco M. Dijkman. 2009a.  Petri Net Transformations for Business Processes—A Survey.  _Transactions on Petri Nets and Other Models of Concurrency (TOPNOC)_ 5460 (2009), 46–63.
  * Lohmann et al. (2009b) Niels Lohmann, H.M.W. Verbeek, Chun Ouyang, and Christian Stahl. 2009b.  Comparing and Evaluating Petri Net Semantics for BPEL.  _International Journal of Business Process Integration and Management (IJBPIM)_ 4, 1 (2009), 60–73.  https://doi.org/10.1504/IJBPIM.2009.026986
  * Louden (2011) Kenneth C. Louden. 2011\.  _Programming Languages: Principles and Practices_.  Cengage Learning.
  * Manning et al. (2008) Christopher D. Manning, Prabhakar Raghavan, and Hinrich Schütze. 2008.  _Introduction to Information Retrieval_.  Cambridge University Press, Cambridge, UK.
  * McMillan (1992) Kenneth L. McMillan. 1992\.  Using Unfoldings to Avoid the State Explosion Problem in the Verification of Asynchronous Circuits. In _Computer Aided Verification (CAV)_ _(Lecture Notes in Computer Science)_ , Vol. 663. Springer, 164–177.
  * Mendling et al. (2012) Jan Mendling, Mark Strembeck, and Jan Recker. 2012\.  Factors of Process Model Comprehension: Findings from a Series of Experiments.  _Decision Support Systems (DSS)_ 53, 1 (2012).
  * Meyer (1990) Bertrand Meyer. 1990\.  _Introduction to the Theory of Programming Languages_.  Prentice-Hall.
  * Nielsen et al. (1981) Mogens Nielsen, Gordon D. Plotkin, and Glynn Winskel. 1981\.  Petri Nets, Event Structures and Domains, Part I.  _Theoretical Computer Science (TCS)_ 13 (1981), 85–108.
  * of Computer Science and Lipton (1976) Yale University. Department of Computer Science and R.J. Lipton. 1976\.  _The reachability problem requires exponential space_.  Department of Computer Science, Yale University.
  * Osterweil et al. (2017) Leon J. Osterweil, Matt Bishop, Heather M. Conboy, Huong Phan, Borislava I. Simidchieva, George S. Avrunin, Lori A. Clarke, and Sean Peisert. 2017.  Iterative Analysis to Improve Key Properties of Critical Human-Intensive Processes: An Election Security Example.  _ACM Transactions on Privacy and Security_ 20, 2 (mar 2017), 5:1–5:31.  https://doi.org/10.1145/3041041
  * Ouyang et al. (2009) Chun Ouyang, Marlon Dumas, Wil M. P. van der Aalst, Arthur H. M. ter Hofstede, and Jan Mendling. 2009\.  From business process models to process-oriented software systems.  _ACM Transactions on Software Engineering and Methodology (TOSEM)_ 19, 1 (2009), 2:1–2:37.  https://doi.org/10.1145/1555392.1555395
  * Parr (2013) Terence John Parr. 2013\.  _The Definitive ANTLR 4 Reference_.  Pragmatic Programmers, LLC.
  * Parr and Quong (1995) Terence John Parr and Russell W. Quong. 1995.  ANTLR: A Predicated- LL(k)  Parser Generator.  _Software, Practice and Experience (SPE)_ 25, 7 (1995), 789–810.
  * Polyvyanyy (2007) Artem Polyvyanyy. 2007\.  _Evaluation of a Novel Information Retrieval Model: eTVSM_.  Master’s thesis. University of Potsdam.
  * Polyvyanyy (2012) Artem Polyvyanyy. 2012\.  _Structuring Process Models_.  Ph.D. Dissertation. University of Potsdam.
  * Polyvyanyy (2018) Artem Polyvyanyy. 2018\.  _Business Process Querying_.  Springer International Publishing, 1–9.  https://doi.org/10.1007/978-3-319-63962-8_108-1
  * Polyvyanyy et al. (2016) Artem Polyvyanyy, Abel Armas-Cervantes, Marlon Dumas, and Luciano García-Bañuelos. 2016\.  On the Expressive Power of Behavioral Profiles.  _Formal Aspects of Computing (FAOC)_ 28, 4 (2016), 597–613.
  * Polyvyanyy et al. (2015a) Artem Polyvyanyy, Luigi Corno, Raffaele Conforti, Simon Raboczi, Marcello La Rosa, and Giancarlo Fortino. 2015a.  Process Querying in Apromore. In _BPM 2015 Demo Track_.
  * Polyvyanyy et al. (2012) Artem Polyvyanyy, Luciano García-Bañuelos, and Marlon Dumas. 2012\.  Structuring Acyclic Process Models.  _Information Systems (IS)_ 37, 6 (2012), 518–538.  https://doi.org/10.1016/j.is.2011.10.005
  * Polyvyanyy et al. (2014a) Artem Polyvyanyy, Marcello La Rosa, and Arthur H.M. ter Hofstede. 2014a.  Indexing and Efficient Instance-Based Retrieval of Process Models Using Untanglings. In _Advanced Information Systems Engineering—26th International Conference, CAiSE 2014, Thessaloniki, Greece, June 16–20, 2014. Proceedings_ _(Lecture Notes in Computer Science)_ , Vol. 8484. Springer, 439–456.  https://doi.org/10.1007/978-3-319-07881-6_30
  * Polyvyanyy et al. (2017) Artem Polyvyanyy, Chun Ouyang, Alistair Barros, and Wil M. P. van der Aalst. 2017.  Process querying: Enabling business intelligence through query-based process analytics.  _Decision Support Systems_ 100 (2017), 41–56.  https://doi.org/10.1016/j.dss.2017.04.011
  * Polyvyanyy et al. (2015b) Artem Polyvyanyy, Marcello La Rosa, Chun Ouyang, and Arthur H. M. ter Hofstede. 2015b.  Untanglings: a novel approach to analyzing concurrent systems.  _Formal Aspects of Computing (FAOC)_ 27, 5–6 (2015), 753–788.  https://doi.org/10.1007/s00165-014-0329-4
  * Polyvyanyy et al. (2008) Artem Polyvyanyy, Sergey Smirnov, and Mathias Weske. 2008\.  Reducing Complexity of Large EPCs. In _Modellierung betrieblicher Informationssysteme—Modellierung zwischen SOA und Compliance Management, 27–28 November 2008. Saarbrücken, Germany_ _(Lecture Notes in Informatics)_ , Vol. 141. Gesellschaft für Informatik, 195–207.
  * Polyvyanyy et al. (2010) Artem Polyvyanyy, Jussi Vanhatalo, and Hagen Völzer. 2010\.  Simplified Computation and Generalization of the Refined Process Structure Tree. In _Web Services and Formal Methods. 7th International Workshop, WS-FM 2010, Hoboken, NJ, USA, September 16–17, 2010. Revised Selected Papers_ _(Lecture Notes in Computer Science)_ , Vol. 6551. Springer, 25–41.  https://doi.org/10.1007/978-3-642-19589-1_2
  * Polyvyanyy and Weidlich (2013) Artem Polyvyanyy and Matthias Weidlich. 2013.  Towards a Compendium of Process Technologies: The jBPT Library for Process Model Analysis. In _CAiSE Forum_ _(CEUR Workshop Proceedings)_ , Vol. 998. CEUR-WS.org, 106–113.
  * Polyvyanyy et al. (2014b) Artem Polyvyanyy, Matthias Weidlich, Raffaele Conforti, Marcello La Rosa, and Arthur H.M. ter Hofstede. 2014b.  The 4C Spectrum of Fundamental Behavioral Relations for Concurrent Systems. In _PETRI NETS_ _(Lecture Notes in Computer Science)_ , Vol. 8489. Springer, 210–232.
  * Rackoff (1978) Charles Rackoff. 1978\.  The Covering and Boundedness Problems for Vector Addition Systems.  _Theoretical Computer Science (TCS)_ 6 (1978), 223–231.
  * Ryan and Bernard (2003) Gery W. Ryan and H. Russell Bernard. 2003.  Techniques to Identify Themes.  _Field Methods_ 15, 1 (feb 2003), 85–109.  https://doi.org/10.1177/1525822x02239569
  * Sassone et al. (1996) Vladimiro Sassone, Mogens Nielsen, and Glynn Winskel. 1996\.  Models for Concurrency: Towards a Classification.  _Theoretical Computer Science_ 170, 1-2 (dec 1996), 297–348.  https://doi.org/10.1016/S0304-3975(96)80710-9
  * Scheer et al. (2005) August-Wilhelm Scheer, Oliver Thomas, and Otmar Adam. 2005\.  Process Modeling Using Event-Driven Process Chains.  In _Process-Aware Information Systems: Bridging People and Software Through Process Technology_. Wiley.
  * Schmidt (2000) Karsten Schmidt. 2000\.  LoLA: A Low Level Analyser. In _Application and Theory of Petri Nets (ICATPN)_ _(Lecture Notes in Computer Science)_ , Vol. 1825. Springer, 465–474.
  * Sprent (2011) Peter Sprent. 2011\.  _Sign Test_.  Springer Berlin Heidelberg, Berlin, Heidelberg, 1316–1317.  https://doi.org/10.1007/978-3-642-04898-2_515
  * ter Hofstede et al. (2013) Arthur H.M. ter Hofstede, Chun Ouyang, Marcello La Rosa, Liang Song, Jianmin Wang, and Artem Polyvyanyy. 2013.  APQL: A Process-model Query Language. In _Asia Pacific Business Process Management—First Asia Pacific Conference, AP-BPM 2013, Beijing, China, August 29–30, 2013. Selected Papers_ _(Lecture Notes in Business Information Processing)_ , Vol. 159. Springer, 23–38.  https://doi.org/10.1007/978-3-319-02922-1_2
  * URI Planning Interest Group (2001) URI Planning Interest Group. 2001\.  _URIs, URLs, and URNs: Clarifications and Recommendations 1.0_.  Technical Report. W3C.  http://www.w3.org/TR/uri-clarification/
  * van der Aalst (1997) Wil M.P. van der Aalst. 1997\.  Verification of Workflow Nets. In _Application and Theory of Petri Nets 1997, 18th International Conference, ICATPN’97, Toulouse, France, June 23–27, 1997, Proceedings_ _(Lecture Notes in Computer Science)_ , Pierre Azéma and Gianfranco Balbo (Eds.), Vol. 1248. Springer Berlin Heidelberg, 407–426.  https://doi.org/10.1007/3-540-63139-9_48
  * van der Aalst (1999) Wil M.P. van der Aalst. 1999\.  Formalization and Verification of Event-Driven Process Chains.  _Information & Software Technology_ 41, 10 (1999), 639–650.  https://doi.org/10.1016/S0950-5849(99)00016-6
  * van der Aalst (2016) Wil M. P. van der Aalst. 2016\.  _Process Mining - Data Science in Action, Second Edition_.  Springer Berlin Heidelberg.  https://doi.org/10.1007/978-3-662-49851-4
  * van der Aalst et al. (2009) Wil M. P. van der Aalst, Maja Pesic, and Helen Schonenberg. 2009\.  Declarative workflows: Balancing between flexibility and support.  _Computer Science - Research and Development_ 23, 2 (mar 2009), 99–113.  https://doi.org/10.1007/s00450-009-0057-9
  * van Dongen et al. (2007) Boudewijn F. van Dongen, Monique H. Jansen-Vullers, H.M.W. Verbeek, and Wil M.P. van der Aalst. 2007\.  Verification of the SAP Reference Models using EPC Reduction, State-space analysis, and Invariants.  _Computers in Industry (CII)_ 58, 6 (2007), 578–601.  https://doi.org/10.1016/j.compind.2007.01.001
  * van Maanen et al. (2009) Leendert van Maanen, Hedderik van Rijn, and Jelmer P. Borst. 2009.  Stroop and picture—word interference are two sides of the same coin.  _Psychonomic Bulletin & Review_ 16, 6 (01 Dec 2009), 987–999.  https://doi.org/10.3758/PBR.16.6.987
  * Verbeek et al. (2007) H.M.W. Verbeek, Wil M.P. van der Aalst, and Arthur H.M. ter Hofstede. 2007\.  Verifying Workflows with Cancellation Regions and OR-joins: An Approach Based on Relaxed Soundness and Invariants.  _The Computer Journal (COMJ)_ 50, 3 (2007), 294–314.  https://doi.org/10.1093/comjnl/bxl074
  * W3C XSL/XML Query Working Groups (2007) W3C XSL/XML Query Working Groups. 2007\.  The XPath 2.0 Standard.  http://www.network-theory.co.uk/w3c/xpath/
  * Wand and Wang (1996) Yair Wand and Richard Y. Wang. 1996.  Anchoring Data Quality Dimensions in Ontological Foundations.  _Communications of the ACM (CACM)_ 39, 11 (1996).
  * Wang et al. (2014) Jianmin Wang, Tao Jin, Raymond K. Wong, and Lijie Wen. 2014\.  Querying Business Process Model Repositories—A Survey of Current Approaches and Issues.  _World Wide Web (WWW)_ 17, 3 (2014), 427–454.
  * Weidlich et al. (2011) Matthias Weidlich, Artem Polyvyanyy, Jan Mendling, and Mathias Weske. 2011.  Causal Behavioural Profiles – Efficient Computation, Applications, and Evaluation.  _Fundamenta Informaticae (FUIN)_ 113, 3-4 (2011), 399–435.
  * Weske (2012) Mathias Weske. 2012\.  _Business Process Management - Concepts, Languages, Architectures_ (2nd ed.).  Springer.
  * Westergaard et al. (2013) Michael Westergaard, Christian Stahl, and Hajo A. Reijers. 2013\.  _UnconstrainedMiner: Efficient Discovery of Generalized Declarative Process Models_.  Technical Report BPM reports; Vol. 1328.  BPMcenter.org
  * White and Roth (2009) Ryen W. White and Resa A. Roth. 2009.  _Exploratory Search: Beyond the Query-Response Paradigm_.  Morgan & Claypool Publishers.  https://doi.org/10.2200/S00174ED1V01Y200901ICR003
  * Wolf (2018) Karsten Wolf. 2018\.  Interleaving Based Model Checking of Concurrency and Causality.  _Fundamenta Informaticae_ 161, 4 (2018), 423–445.  https://doi.org/10.3233/FI-2018-1709
  * Yan et al. (2015) Zhiqiang Yan, Remco M. Dijkman, and Paul W.P.J. Grefen. 2015\.  Generating Process Model Collections.  _Software & Systems Modeling (SOSYM)_ (2015), 1–17.

##  Appendix A Interview Instrument

This appendix contains the instrument used to conduct the empirical study
reported in Section 4.1.

##  Appendix B PQL Grammar

This appendix specifies the complete grammar of the PQL language captured in
the ANTLR notation. ANTLR (ANother Tool for Language Recognition) is a parser
generator for reading and translating structured text or binary files (Parr
and Quong, 1995; Parr, 2013). ANTLR can take a grammar of a language as input
and generate source code for a parser that can build and walk syntax trees
(Meyer, 1990). The language must be specified using a context-free grammar
which is expressed using extended Backus-Naur Form (Hopcroft et al., 2006).

.7em

       // PQL version 1.0 grammar for ANTLR v4
       // [The "BSD licence"]
       // Copyright (c) 2014-2016 Artem Polyvyanyy
       // All rights reserved.

       grammar PQL;

       query      : variables
                  SELECT attributes
                  FROM locations
                  (WHERE predicate)? EOS ;

       variables  : variable* ;
       variable   : varName ASSIGN
                    setOfTasks EOS ;

       varName    : VARIABLE_NAME ;

       attributes : attribute (SEP attribute)* ;
       attribute  : universe
                  | attributeName ;

       locations  : location (SEP location)* ;
       location   : universe
                  | locationPath ;

       universe           : UNIVERSE ;
       attributeName      : STRING ;
       locationPath       : STRING ;

       setOfTasks : tasks
                  | union
                  | intersection
                  | difference ;

       tasks      : varName
                  | setOfAllTasks
                  | setOfTasksLiteral
                  | setOfTasksConstruction
                  | setOfTasksParentheses ;

       setOfAllTasks      :
                  GET_TASKS LP RP;

       setOfTasksLiteral  :
                  LB (task (SEP task)*)? RB ;

       task       : approximate label
                  | label (LSB similarity RSB)? ;

       approximate: TILDE ;
       label      : STRING ;
       similarity : SIMILARITY ;

       setOfTasksConstruction      :
                    unaryPredicateConstruction
                  | binaryPredicateConstruction ;

       unaryPredicateConstruction  :
                    (GET_TASKS)unaryPredicateName
                    LP setOfTasks RP ;

       binaryPredicateConstruction :
                    (GET_TASKS)binaryPredicateName
                    LP setOfTasks SEP setOfTasks
                    SEP anyAll RP ;

       anyAll     : ANY | ALL ;

       unaryPredicateName : CAN_OCCUR
                  | ALWAYS_OCCURS;

       binaryPredicateName: CAN_CONFLICT
                  | CAN_COOCCUR
                  | CONFLICT
                  | COOCCUR
                  | TOTAL_CAUSAL
                  | TOTAL_CONCUR ;

       predicate  : proposition
                  | conjunction
                  | disjunction
                  | logicalTest ;

       proposition: unaryPredicate
                  | binaryPredicate
                  | unaryPredicateMacro
                  | binaryPredicateMacro
                  | setPredicate
                  | truthValue
                  | parentheses
                  | negation ;

       unaryPredicate      : unaryPredicateName
                    LP task RP ;

       binaryPredicate     : binaryPredicateName
                    LP task SEP task RP ;  ΨΨΨ

       unaryPredicateMacro : unaryPredicateName
                    LP setOfTasks SEP anyAll RP ;
    ΨΨ
       binaryPredicateMacro:
                    binaryPredicateMacroTaskSet
                  | binaryPredicateMacroSetSet ;

       binaryPredicateMacroTaskSet :
                    binaryPredicateName LP task
                    SEP setOfTasks SEP anyAll RP ;
    ΨΨ
       binaryPredicateMacroSetSet  :
                  binaryPredicateName
                  LP setOfTasks SEP setOfTasks
                  SEP anyEachAll RP ;

       anySomeEachAll  : ANY | SOME | EACH | ALL ;

       setPredicate: taskInSetOfTasks
                  | setComparison ;

       taskInSetOfTasks : task IN setOfTasks ;

       setComparison    : setOfTasks
                  setComparisonOperator
                  setOfTasks ;

       setComparisonOperator : identical
                  | different
                  | overlapsWith
                  | subsetOf
                  | properSubsetOf ;

       truthValue : TRUE
                  | FALSE ;

       logicalTest: isTrue
                  | isNotTrue
                  | isFalse
                  | isNotFalse ;

       union      : (tasks | difference |
                    intersection) UNION (tasks |
                    difference | intersection)
                    (UNION (tasks | difference
                    | intersection))* ;

       intersection : (tasks | difference)
                      INTERSECTION
                      (tasks | difference)
                      (INTERSECTION (tasks
                      | difference))* ;

       difference   : tasks DIFFERENCE tasks
                    | tasks DIFFERENCE
                      difference ;

       negation     : NOT proposition ;

       isTrue       : proposition IS TRUE ;
       isNotTrue    : proposition IS NOT TRUE ;
       isFalse      : proposition IS FALSE ;
       isNotFalse   : proposition IS NOT FALSE ;

       disjunction  : (proposition | logicalTest |
                conjunction) OR (proposition |
                logicalTest | conjunction) (OR
                (proposition | logicalTest
                | conjunction))* ;
    ΨΨ
       conjunction  : (proposition | logicalTest)
                AND (proposition | logicalTest)
                (AND (proposition
                | logicalTest))* ;

       parentheses  : LP proposition RP
               | LP conjunction RP
               | LP disjunction RP
               | LP logicalTest RP ;

       setOfTasksParentheses : LP varName RP
               | LP universe RP
               | LP setOfTasksLiteral RP
               | LP setOfTasksConstruction RP
               | LP union RP
               | LP difference RP
               | LP intersection RP
               | LP setOfTasksParentheses RP ;

       UNIVERSE     : ’*’ ;

       STRING       : DQ ( ESC_SEQ
                    | ~(’\\’|’"’) )* DQ ;
       VARIABLE_NAME: (’a’..’z’|’_’)
                      (’a’..’z’|’0’..’9’|’_’)*;
       SIMILARITY   : ’1’ | ’0’ (’.’ ’0’..’9’+)?
                    | ’.’ ’0’..’9’+ ;

       LP          : ’(’ ;
       RP          : ’)’ ;
       LB          : ’{’ ;
       RB          : ’}’ ;
       LSB         : ’[’ ;
       RSB         : ’]’ ;
       DQ          : ’"’ ;
       EOS         : ’;’ ;
       SEP         : ’,’ ;
       ASSIGN      : ’=’ ;
       TILDE       : ’~’ ;

       ESC_SEQ     : ’\\’ (’\"’|’\\’|’/’|’b’|
                   ’f’|’n’|’r’|’t’)
                   | UNICODE_ESC ;
       UNICODE_ESC : ’\\’ ’u’ HEX_DIGIT
                   HEX_DIGIT HEX_DIGIT HEX_DIGIT ;
       HEX_DIGIT   : (’0’..’9’|
                   ’a’..’f’|’A’..’F’) ;
       WS          : [ \r\t\n]+ -> skip ;
       LINE_COMMENT: ’--’ ~[\r\n]* -> skip ;

       SELECT      : ’SELECT’ ;
       FROM        : ’FROM’ ;
       WHERE       : ’WHERE’ ;

       EQUALS      : ’EQUALS’ ;
       OVERLAPS    : ’OVERLAPS’ ;
       WITH        : ’WITH’ ;
       SUBSET      : ’SUBSET’ ;
       PROPER      : ’PROPER’ ;
       GET_TASKS   : ’GetTasks’ ;

       NOT         : ’NOT’ ;
       AND         : ’AND’ ;
       OR          : ’OR’ ;

       ANY         : ’ANY’ ;
       SOME        : ’SOME’ ;
       EACH        : ’EACH’ ;
       ALL         : ’ALL’ ;

       IN          : ’IN’ ;
       IS          : ’IS’ ;
       OF          : ’OF’ ;

       TRUE        : ’TRUE’ ;
       FALSE       : ’FALSE’ ;

       identical       : EQUALS ;
       different       : NOT EQUALS ;
       overlapsWith    : OVERLAPS WITH ;
       subsetOf        : IS SUBSET OF ;
       properSubsetOf  : IS PROPER SUBSET OF ;

       UNION           : ’UNION’ ;
       INTERSECTION    : ’INTERSECT’ ;
       DIFFERENCE      : ’EXCEPT’ ;

       CAN_OCCUR       : ’CanOccur’ ;
       ALWAYS_OCCURS   : ’AlwaysOccurs’ ;
       CAN_CONFLICT    : ’CanConflict’ ;
       CAN_COOCCUR     : ’CanCooccur’ ;
       CONFLICT        : ’Conflict’ ;
       COOCCUR         : ’Cooccur’ ;
       TOTAL_CAUSAL    : ’TotalCausal’ ;
       TOTAL_CONCUR    : ’TotalConcurrent’ ;

##  Appendix C PQL Queries

This appendix contains 150 PQL query templates used in the evaluation reported
in Section 6. Each template is a PQL query with placeholders for activity
labels. The templates can be instantiated with specific labels and used as a
benchmark to evaluate performance of PQL tools. The query templates were
developed to exploit the various features of the PQL grammar. According to the
PQL features they support, these query templates are divided into three
categories and further subdivided into groups and subgroups, refer to Section
6.1 for details.

Table 12. PQL query templates. No. |  ID |  PQL template
---|---|---
1 |  1.a.1 |  SELECT * FROM * WHERE CanOccur("L1");
2 |  1.a.2 |  SELECT * FROM * WHERE AlwaysOccurs("L1");
3 |  1.b.1 |  SELECT * FROM * WHERE Cooccur("L1","L2");
4 |  1.b.2 |  SELECT * FROM * WHERE Conflict("L1","L2");
5 |  1.b.3 |  SELECT * FROM * WHERE TotalCausal("L1","L2");
6 |  1.b.4 |  SELECT * FROM * WHERE TotalConcurrent("L1","L2");
7 |  2.a.1.1 |  SELECT * FROM * WHERE NOT CanOccur("L1");
8 |  2.a.1.2 |  SELECT * FROM * WHERE NOT AlwaysOccurs("L1");
9 |  2.a.1.3 |  SELECT * FROM * WHERE NOT Cooccur("L1","L2");
10 |  2.a.1.4 |  SELECT * FROM * WHERE NOT Conflict("L1","L2");
11 |  2.a.1.5 |  SELECT * FROM * WHERE NOT TotalCausal("L1","L2");
12 |  2.a.1.6 |  SELECT * FROM * WHERE NOT TotalConcurrent("L1","L2");
13 |  2.a.2.1 |  SELECT * FROM * WHERE CanOccur("L1") AND CanOccur("L2");
14 |  2.a.2.2 |  SELECT * FROM * WHERE CanOccur("L1") AND CanOccur("L2") AND CanOccur("L3");
15 |  2.a.2.3 |  SELECT * FROM * WHERE CanOccur("L1") AND CanOccur("L2") AND CanOccur("L3") AND CanOccur("L4");
16 |  2.a.2.4 |  SELECT * FROM * WHERE AlwaysOccurs("L1") AND AlwaysOccurs("L2");
17 |  2.a.2.5 |  SELECT * FROM * WHERE AlwaysOccurs("L1") AND AlwaysOccurs("L2") AND AlwaysOccurs("L3");
18 |  2.a.2.6 |  SELECT * FROM * WHERE AlwaysOccurs("L1") AND AlwaysOccurs("L2") AND AlwaysOccurs("L3") AND AlwaysOccurs("L4");
19 |  2.a.2.7 |  SELECT * FROM * WHERE Cooccur("L1","L2") AND Cooccur("L3","L4");
20 |  2.a.2.8 |  SELECT * FROM * WHERE Cooccur("L1","L2") AND Cooccur("L3","L4") AND Cooccur("L5","L6");
21 |  2.a.2.9 |  SELECT * FROM * WHERE Cooccur("L1","L2") AND Cooccur("L3","L4") AND Cooccur("L5","L6") AND Cooccur("L7","L8");
22 |  2.a.2.10 |  SELECT * FROM * WHERE Conflict("L1","L2") AND Conflict("L3","L4");
23 |  2.a.2.11 |  SELECT * FROM * WHERE Conflict("L1","L2") AND Conflict("L3","L4") AND Conflict("L5","L6");
24 |  2.a.2.12 |  SELECT * FROM * WHERE Conflict("L1","L2") AND Conflict("L3","L4") AND Conflict("L5","L6") AND Conflict("L7","L8");
25 |  2.a.2.13 |  SELECT * FROM * WHERE TotalCausal("L1","L2") AND TotalCausal("L3","L4");
26 |  2.a.2.14 |  SELECT * FROM * WHERE TotalCausal("L1","L2") AND TotalCausal("L3","L4") AND TotalCausal("L5","L6");
27 |  2.a.2.15 |  SELECT * FROM * WHERE TotalCausal("L1","L2") AND TotalCausal("L3","L4") AND TotalCausal("L5","L6") AND TotalCausal("L7","L8");
28 |  2.a.2.16 |  SELECT * FROM * WHERE TotalConcurrent("L1","L2") AND TotalConcurrent("L3","L4");
29 |  2.a.2.17 |  SELECT * FROM * WHERE TotalConcurrent("L1","L2") AND TotalConcurrent("L3","L4") AND TotalConcurrent("L5","L6");
30 |  2.a.2.18 |  SELECT * FROM * WHERE TotalConcurrent("L1","L2") AND TotalConcurrent("L3","L4") AND TotalConcurrent("L5","L6") AND TotalConcurrent("L7","L8");
31 |  2.a.3.1 |  SELECT * FROM * WHERE CanOccur("L1") OR CanOccur("L2");
32 |  2.a.3.2 |  SELECT * FROM * WHERE CanOccur("L1") OR CanOccur("L2") OR CanOccur("L3");
33 |  2.a.3.3 |  SELECT * FROM * WHERE CanOccur("L1") OR CanOccur("L2") OR CanOccur("L3") OR CanOccur("L4");
34 |  2.a.3.4 |  SELECT * FROM * WHERE AlwaysOccurs("L1") OR AlwaysOccurs("L2");
35 |  2.a.3.5 |  SELECT * FROM * WHERE AlwaysOccurs("L1") OR AlwaysOccurs("L2") OR AlwaysOccurs("L3");
36 |  2.a.3.6 |  SELECT * FROM * WHERE AlwaysOccurs("L1") OR AlwaysOccurs("L2") OR AlwaysOccurs("L3") OR AlwaysOccurs("L4");
37 |  2.a.3.7 |  SELECT * FROM * WHERE Cooccur("L1","L2") OR Cooccur("L3","L4");
38 |  2.a.3.8 |  SELECT * FROM * WHERE Cooccur("L1","L2") OR Cooccur("L3","L4") OR Cooccur("L5","L6");
39 |  2.a.3.9 |  SELECT * FROM * WHERE Cooccur("L1","L2") OR Cooccur("L3","L4") OR Cooccur("L5","L6") OR Cooccur("L7","L8");
40 |  2.a.3.10 |  SELECT * FROM * WHERE Conflict("L1","L2") OR Conflict("L3","L4");
41 |  2.a.3.11 |  SELECT * FROM * WHERE Conflict("L1","L2") OR Conflict("L3","L4") OR Conflict("L5","L6");
42 |  2.a.3.12 |  SELECT * FROM * WHERE Conflict("L1","L2") OR Conflict("L3","L4") OR Conflict("L5","L6") OR Conflict("L7","L8");
43 |  2.a.3.13 |  SELECT * FROM * WHERE TotalCausal("L1","L2") OR TotalCausal("L3","L4");
44 |  2.a.3.14 |  SELECT * FROM * WHERE TotalCausal("L1","L2") OR TotalCausal("L3","L4") OR TotalCausal("L5","L6");
45 |  2.a.3.15 |  SELECT * FROM * WHERE TotalCausal("L1","L2") OR TotalCausal("L3","L4") OR TotalCausal("L5","L6") OR TotalCausal("L7","L8");
46 |  2.a.3.16 |  SELECT * FROM * WHERE TotalConcurrent("L1","L2") OR TotalConcurrent("L3","L4");
47 |  2.a.3.17 |  SELECT * FROM * WHERE TotalConcurrent("L1","L2") OR TotalConcurrent("L3","L4") OR TotalConcurrent("L5","L6");
48 |  2.a.3.18 |  SELECT * FROM * WHERE TotalConcurrent("L1","L2") OR TotalConcurrent("L3","L4") OR TotalConcurrent("L5","L6") OR TotalConcurrent("L7","L8");
49 |  2.b.1.1 |  SELECT * FROM * WHERE CanOccur("L1") AND Conflict("L2","L3");
50 |  2.b.1.2 |  SELECT * FROM * WHERE AlwaysOccurs("L1") AND Cooccur("L2","L3") AND TotalConcurrent("L4","L5");
51 |  2.b.1.3 |  SELECT * FROM * WHERE Cooccur("L1","L2") AND TotalCausal("L3","L4") AND TotalConcurrent("L5","L6");
52 |  2.b.2.1 |  SELECT * FROM * WHERE AlwaysOccurs("L1") OR Cooccur("L2","L3");
53 |  2.b.2.2 |  SELECT * FROM * WHERE CanOccur("L1") OR AlwaysOccurs("L2") OR Conflict("L3","L4");
54 |  2.b.2.3 |  SELECT * FROM * WHERE Conflict("L1","L2") OR TotalCausal("L3","L4") OR TotalConcurrent("L5","L6");
55 |  2.b.3.1 |  SELECT * FROM * WHERE AlwaysOccurs("L1") OR (Cooccur("L2","L3") AND (NOT TotalCausal("L4","L5")));
56 |  2.b.3.2 |  SELECT * FROM * WHERE (CanOccur("L1") AND (NOT Conflict("L2","L3"))) OR (TotalConcurrent("L4","L5") AND AlwaysOccurs("L6"));
57 |  3.a.1.1 |  SELECT * FROM * WHERE CanOccur([2ex].{"L1","L2"[2ex].},ALL);
58 |  3.a.1.2 |  SELECT * FROM * WHERE CanOccur([2ex].{"L1","L2","L3"[2ex].},ALL);
59 |  3.a.1.3 |  SELECT * FROM * WHERE CanOccur([2ex].{"L1","L2","L3","L4"[2ex].},ALL);
60 |  3.a.1.4 |  SELECT * FROM * WHERE CanOccur([2ex].{"L1","L2"[2ex].},ANY);
61 |  3.a.1.5 |  SELECT * FROM * WHERE CanOccur([2ex].{"L1","L2","L3"[2ex].},ANY);
62 |  3.a.1.6 |  SELECT * FROM * WHERE CanOccur([2ex].{"L1","L2","L3","L4"[2ex].},ANY);
63 |  3.a.1.7 |  SELECT * FROM * WHERE AlwaysOccurs([2ex].{"L1","L2"[2ex].},ALL);
64 |  3.a.1.8 |  SELECT * FROM * WHERE AlwaysOccurs([2ex].{"L1","L2","L3"[2ex].},ALL);
65 |  3.a.1.9 |  SELECT * FROM * WHERE AlwaysOccurs([2ex].{"L1","L2","L3","L4"[2ex].},ALL);
66 |  3.a.1.10 |  SELECT * FROM * WHERE AlwaysOccurs([2ex].{"L1","L2"[2ex].},ANY);
67 |  3.a.1.11 |  SELECT * FROM * WHERE AlwaysOccurs([2ex].{"L1","L2","L3"[2ex].},ANY);
68 |  3.a.1.12 |  SELECT * FROM * WHERE AlwaysOccurs([2ex].{"L1","L2","L3","L4"[2ex].},ANY);
69 |  3.a.2.1 |  SELECT * FROM * WHERE Cooccur("L1",[2ex].{"L2","L3"[2ex].},ALL);
70 |  3.a.2.2 |  SELECT * FROM * WHERE Cooccur("L1",[2ex].{"L2","L3","L4"[2ex].},ALL);
71 |  3.a.2.3 |  SELECT * FROM * WHERE Cooccur("L1",[2ex].{"L2","L3","L4","L5"[2ex].},ALL);
72 |  3.a.2.4 |  SELECT * FROM * WHERE Cooccur("L1",[2ex].{"L2","L3"[2ex].},ANY);
73 |  3.a.2.5 |  SELECT * FROM * WHERE Cooccur("L1",[2ex].{"L2","L3","L4"[2ex].},ANY);
74 |  3.a.2.6 |  SELECT * FROM * WHERE Cooccur("L1",[2ex].{"L2","L3","L4","L5"[2ex].},ANY);
75 |  3.a.2.7 |  SELECT * FROM * WHERE Conflict("L1",[2ex].{"L2","L3"[2ex].},ALL);
76 |  3.a.2.8 |  SELECT * FROM * WHERE Conflict("L1",[2ex].{"L2","L3","L4"[2ex].},ALL);
77 |  3.a.2.9 |  SELECT * FROM * WHERE Conflict("L1",[2ex].{"L2","L3","L4","L5"[2ex].},ALL);
78 |  3.a.2.10 |  SELECT * FROM * WHERE Conflict("L1",[2ex].{"L2","L3"[2ex].},ANY);
79 |  3.a.2.11 |  SELECT * FROM * WHERE Conflict("L1",[2ex].{"L2","L3","L4"[2ex].},ANY);
80 |  3.a.2.12 |  SELECT * FROM * WHERE Conflict("L1",[2ex].{"L2","L3","L4","L5"[2ex].},ANY);
81 |  3.a.2.13 |  SELECT * FROM * WHERE TotalCausal("L1",[2ex].{"L2","L3"[2ex].},ALL);
82 |  3.a.2.14 |  SELECT * FROM * WHERE TotalCausal("L1",[2ex].{"L2","L3","L4"[2ex].},ALL);
83 |  3.a.2.15 |  SELECT * FROM * WHERE TotalCausal("L1",[2ex].{"L2","L3","L4","L5"[2ex].},ALL);
84 |  3.a.2.16 |  SELECT * FROM * WHERE TotalCausal("L1",[2ex].{"L2","L3"[2ex].},ANY);
85 |  3.a.2.17 |  SELECT * FROM * WHERE TotalCausal("L1",[2ex].{"L2","L3","L4"[2ex].},ANY);
86 |  3.a.2.18 |  SELECT * FROM * WHERE TotalCausal("L1",[2ex].{"L2","L3","L4","L5"[2ex].},ANY);
87 |  3.a.2.19 |  SELECT * FROM * WHERE TotalConcurrent("L1",[2ex].{"L2","L3"[2ex].},ALL);
88 |  3.a.2.20 |  SELECT * FROM * WHERE TotalConcurrent("L1",[2ex].{"L2","L3","L4"[2ex].},ALL);
89 |  3.a.2.21 |  SELECT * FROM * WHERE TotalConcurrent("L1",[2ex].{"L2","L3","L4","L5"[2ex].},ALL);
90 |  3.a.2.22 |  SELECT * FROM * WHERE TotalConcurrent("L1",[2ex].{"L2","L3"[2ex].},ANY);
91 |  3.a.2.23 |  SELECT * FROM * WHERE TotalConcurrent("L1",[2ex].{"L2","L3","L4"[2ex].},ANY);
92 |  3.a.2.24 |  SELECT * FROM * WHERE TotalConcurrent("L1",[2ex].{"L2","L3","L4","L5"[2ex].},ANY);
93 |  3.a.3.1 |  SELECT * FROM * WHERE Cooccur([2ex].{"L1","L2"[2ex].},[2ex].{"L3","L4"[2ex].},ALL);
94 |  3.a.3.2 |  SELECT * FROM * WHERE Cooccur([2ex].{"L1","L2","L3"[2ex].},[2ex].{"L4","L5","L6"[2ex].},ALL);
95 |  3.a.3.3 |  SELECT * FROM * WHERE Cooccur([2ex].{"L1","L2","L3","L4"[2ex].},[2ex].{"L5","L6","L7","L8"[2ex].},ALL);
96 |  3.a.3.4 |  SELECT * FROM * WHERE Cooccur([2ex].{"L1","L2"[2ex].},[2ex].{"L3","L4"[2ex].},ANY);
97 |  3.a.3.5 |  SELECT * FROM * WHERE Cooccur([2ex].{"L1","L2","L3"[2ex].},[2ex].{"L4","L5","L6"[2ex].},ANY);
98 |  3.a.3.6 |  SELECT * FROM * WHERE Cooccur([2ex].{"L1","L2","L3","L4"[2ex].},[2ex].{"L5","L6","L7","L8"[2ex].},ANY);
99 |  3.a.3.7 |  SELECT * FROM * WHERE Cooccur([2ex].{"L1","L2"[2ex].},[2ex].{"L3","L4"[2ex].},EACH);
100 |  3.a.3.8 |  SELECT * FROM * WHERE Cooccur([2ex].{"L1","L2","L3"[2ex].},[2ex].{"L4","L5","L6"[2ex].},EACH);
101 |  3.a.3.9 |  SELECT * FROM * WHERE Cooccur([2ex].{"L1","L2","L3","L4"[2ex].},[2ex].{"L5","L6","L7","L8"[2ex].},EACH);
102 |  3.a.3.10 |  SELECT * FROM * WHERE Conflict([2ex].{"L1","L2"[2ex].},[2ex].{"L3","L4"[2ex].},ALL);
103 |  3.a.3.11 |  SELECT * FROM * WHERE Conflict([2ex].{"L1","L2","L3"[2ex].},[2ex].{"L4","L5","L6"[2ex].},ALL);
104 |  3.a.3.12 |  SELECT * FROM * WHERE Conflict([2ex].{"L1","L2","L3","L4"[2ex].},[2ex].{"L5","L6","L7","L8"[2ex].},ALL);
105 |  3.a.3.13 |  SELECT * FROM * WHERE Conflict([2ex].{"L1","L2"[2ex].},[2ex].{"L3","L4"[2ex].},ANY);
106 |  3.a.3.14 |  SELECT * FROM * WHERE Conflict([2ex].{"L1","L2","L3"[2ex].},[2ex].{"L4","L5","L6"[2ex].},ANY);
107 |  3.a.3.15 |  SELECT * FROM * WHERE Conflict([2ex].{"L1","L2","L3","L4"[2ex].},[2ex].{"L5","L6","L7","L8"[2ex].},ANY);
108 |  3.a.3.16 |  SELECT * FROM * WHERE Conflict([2ex].{"L1","L2"[2ex].},[2ex].{"L3","L4"[2ex].},EACH);
109 |  3.a.3.17 |  SELECT * FROM * WHERE Conflict([2ex].{"L1","L2","L3"[2ex].},[2ex].{"L4","L5","L6"[2ex].},EACH);
110 |  3.a.3.18 |  SELECT * FROM * WHERE Conflict([2ex].{"L1","L2","L3","L4"[2ex].},[2ex].{"L5","L6","L7","L8"[2ex].},EACH);
111 |  3.a.3.19 |  SELECT * FROM * WHERE TotalCausal([2ex].{"L1","L2"[2ex].},[2ex].{"L3","L4"[2ex].},ALL);
112 |  3.a.3.20 |  SELECT * FROM * WHERE TotalCausal([2ex].{"L1","L2","L3"[2ex].},[2ex].{"L4","L5","L6"[2ex].},ALL);
113 |  3.a.3.21 |  SELECT * FROM * WHERE TotalCausal([2ex].{"L1","L2","L3","L4"[2ex].},[2ex].{"L5","L6","L7","L8"[2ex].},ALL);
114 |  3.a.3.22 |  SELECT * FROM * WHERE TotalCausal([2ex].{"L1","L2"[2ex].},[2ex].{"L3","L4"[2ex].},ANY);
115 |  3.a.3.23 |  SELECT * FROM * WHERE TotalCausal([2ex].{"L1","L2","L3"[2ex].},[2ex].{"L4","L5","L6"[2ex].},ANY);
116 |  3.a.3.24 |  SELECT * FROM * WHERE TotalCausal([2ex].{"L1","L2","L3","L4"[2ex].},[2ex].{"L5","L6","L7","L8"[2ex].},ANY);
117 |  3.a.3.25 |  SELECT * FROM * WHERE TotalCausal([2ex].{"L1","L2"[2ex].},[2ex].{"L3","L4"[2ex].},EACH);
118 |  3.a.3.26 |  SELECT * FROM * WHERE TotalCausal([2ex].{"L1","L2","L3"[2ex].},[2ex].{"L4","L5","L6"[2ex].},EACH);
119 |  3.a.3.27 |  SELECT * FROM * WHERE TotalCausal([2ex].{"L1","L2","L3","L4"[2ex].},[2ex].{"L5","L6","L7","L8"[2ex].},EACH);
120 |  3.a.3.28 |  SELECT * FROM * WHERE TotalConcurrent([2ex].{"L1","L2"[2ex].},[2ex].{"L3","L4"[2ex].},ALL);
121 |  3.a.3.29 |  SELECT * FROM * WHERE TotalConcurrent([2ex].{"L1","L2","L3"[2ex].},[2ex].{"L4","L5","L6"[2ex].},ALL);
122 |  3.a.3.30 |  SELECT * FROM * WHERE TotalConcurrent([2ex].{"L1","L2","L3","L4"[2ex].},[2ex].{"L5","L6","L7","L8"[2ex].},ALL);
123 |  3.a.3.31 |  SELECT * FROM * WHERE TotalConcurrent([2ex].{"L1","L2"[2ex].},[2ex].{"L3","L4"[2ex].},ANY);
124 |  3.a.3.32 |  SELECT * FROM * WHERE TotalConcurrent([2ex].{"L1","L2","L3"[2ex].},[2ex].{"L4","L5","L6"[2ex].},ANY);
125 |  3.a.3.33 |  SELECT * FROM * WHERE TotalConcurrent([2ex].{"L1","L2","L3","L4"[2ex].},[2ex].{"L5","L6","L7","L8"[2ex].},ANY);
126 |  3.a.3.34 |  SELECT * FROM * WHERE TotalConcurrent([2ex].{"L1","L2"[2ex].},[2ex].{"L3","L4"[2ex].},EACH);
127 |  3.a.3.35 |  SELECT * FROM * WHERE TotalConcurrent([2ex].{"L1","L2","L3"[2ex].},[2ex].{"L4","L5","L6"[2ex].},EACH);
128 |  3.a.3.36 |  SELECT * FROM * WHERE TotalConcurrent([2ex].{"L1","L2","L3","L4"[2ex].},[2ex].{"L5","L6","L7","L8"[2ex].},EACH);
129 |  3.b.1.1 |  SELECT * FROM * WHERE "L1" IN GetTasksCanOccur([2ex].{"L2","L3","L4"[2ex].});
130 |  3.b.1.2 |  SELECT * FROM * WHERE "L1" IN GetTasksAlwaysOccurs([2ex].{"L2","L3","L4"[2ex].});
131 |  3.b.2.1 |  SELECT * FROM * WHERE "L1" IN GetTasksCooccur([2ex].{"L2","L3"[2ex].},[2ex].{"L4","L5","L6"[2ex].},ALL);
132 |  3.b.2.2 |  SELECT * FROM * WHERE "L1" IN GetTasksCooccur([2ex].{"L2","L3"[2ex].},[2ex].{"L4","L5","L6"[2ex].},ANY);
133 |  3.b.2.3 |  SELECT * FROM * WHERE "L1" IN GetTasksConflict([2ex].{"L2","L3"[2ex].},[2ex].{"L4","L5","L6"[2ex].},ALL);
134 |  3.b.2.4 |  SELECT * FROM * WHERE "L1" IN GetTasksConflict([2ex].{"L2","L3"[2ex].},[2ex].{"L4","L5","L6"[2ex].},ANY);
135 |  3.b.2.5 |  SELECT * FROM * WHERE "L1" IN GetTasksTotalCausal([2ex].{"L2","L3"[2ex].},[2ex].{"L4","L5","L6"[2ex].},ALL);
136 |  3.b.2.6 |  SELECT * FROM * WHERE "L1" IN GetTasksTotalCausal([2ex].{"L2","L3"[2ex].},[2ex].{"L4","L5","L6"[2ex].},ANY);
137 |  3.b.2.7 |  SELECT * FROM * WHERE "L1" IN GetTasksTotalConcurrent([2ex].{"L2","L3"[2ex].},[2ex].{"L4","L5","L6"[2ex].},ALL);
138 |  3.b.2.8 |  SELECT * FROM * WHERE "L1" IN GetTasksTotalConcurrent([2ex].{"L2","L3"[2ex].},[2ex].{"L4","L5","L6"[2ex].},ANY);
139 |  3.b.3.1 |  SELECT * FROM * WHERE "L1" IN GetTasksAlwaysOccurs([2ex].{"L2","L3","L4"[2ex].}) UNION GetTasksTotalCausal([2ex].{"L5","L6"[2ex].},[2ex].{"L7","L8","L9"[2ex].},ALL);
140 |  3.b.3.2 |  SELECT * FROM * WHERE "L1" IN GetTasksCanOccur([2ex].{"L2","L3","L4"[2ex].}) INTERSECT GetTasksConflict([2ex].{"L5","L6"[2ex].},[2ex].{"L7","L8","L9"[2ex].},ANY);
141 |  3.b.3.3 |  SELECT * FROM * WHERE "L1" IN GetTasksCooccur([2ex].{"L2","L3"[2ex].},[2ex].{"L4","L5","L6"[2ex].},ANY) EXCEPT GetTasksTotalConcurrent([2ex].{"L7","L8"[2ex].},[2ex].{"L9","L10","L11"[2ex].},ANY);
142 |  3.b.3.4 |  SELECT * FROM * WHERE "L1" IN (GetTasksCooccur([2ex].{"L2","L3"[2ex].},[2ex].{"L4","L5","L6"[2ex].},ANY) EXCEPT GetTasksTotalConcurrent([2ex].{"L7","L8"[2ex].},[2ex].{"L9","L10","L11"[2ex].},ANY)) UNION (GetTasksCanOccur([2ex].{"L12","L13","L14"[2ex].}) INTERSECT GetTasksConflict([2ex].{"L15","L16"[2ex].},[2ex].{"L17","L18","L19"[2ex].},ALL));
143 |  3.b.3.5 |  SELECT * FROM * WHERE "L1" IN (GetTasksCooccur([2ex].{"L2","L3"[2ex].},[2ex].{"L4","L5","L6"[2ex].},ANY) UNION GetTasksTotalConcurrent([2ex].{"L7","L8"[2ex].},[2ex].{"L9","L10","L11"[2ex].},ALL)) INTERSECT (GetTasksCanOccur([2ex].{"L12","L13","L14"[2ex].}) EXCEPT GetTasksConflict([2ex].{"L15","L16"[2ex].},[2ex].{"L17","L18","L19"[2ex].},ALL));
144 |  3.b.4.1 |  SELECT * FROM * WHERE ([2ex].{"L1","L2","L3"[2ex].} EXCEPT GetTasksConflict([2ex].{"L4","L5"[2ex].},[2ex].{"L6","L7","L8"[2ex].},ALL)) EQUALS GetTasksTotalCausal([2ex].{"L9","L10"[2ex].},[2ex].{"L11","L12","L13"[2ex].},ALL);
145 |  3.b.4.2 |  SELECT * FROM * WHERE GetTasksCooccur([2ex].{"L1","L2"[2ex].},[2ex].{"L3","L4","L5"[2ex].},ANY) NOT EQUALS GetTasksTotalConcurrent([2ex].{"L6","L7"[2ex].},[2ex].{"L8","L9","L10"[2ex].},ANY);
146 |  3.b.4.3 |  SELECT * FROM * WHERE ([2ex].{"L1","L2","L3"[2ex].} EXCEPT GetTasksCooccur([2ex].{"L4","L5"[2ex].},[2ex].{"L6","L7","L8"[2ex].},ALL)) OVERLAPS WITH GetTasksConflict([2ex].{"L9","L10"[2ex].},[2ex].{"L11","L12","L13"[2ex].},ANY);
147 |  3.b.4.4 |  SELECT * FROM * WHERE ([2ex].{"L1","L2","L3"[2ex].} EXCEPT GetTasksAlwaysOccurs([2ex].{"L4","L5","L6"[2ex].}) IS SUBSET OF GetTasksCanOccur([2ex].{"L7","L8","L9"[2ex].}));
148 |  3.b.4.5 |  SELECT * FROM * WHERE GetTasksTotalCausal([2ex].{"L1","L2"[2ex].},[2ex].{"L3","L4","L5"[2ex].},ALL) IS PROPER SUBSET OF ([2ex].{"L6","L7","L8"[2ex].} EXCEPT GetTasksTotalConcurrent([2ex].{"L9","L10"[2ex].},[2ex].{"L11","L12","L13"[2ex].},ALL));
149 |  3.b.4.6 |  SELECT * FROM * WHERE (GetTasksCooccur([2ex].{"L1","L2"[2ex].},[2ex].{"L3","L4","L5"[2ex].},ALL)) EQUALS GetTasksTotalConcurrent([2ex].{"L6","L7"[2ex].},[2ex].{"L8","L9","L10"[2ex].},ALL) OR ((GetTasksCanOccur([2ex].{"L11","L12","L13"[2ex].}) OVERLAPS WITH GetTasksConflict([2ex].{"L14","L15"[2ex].},[2ex].{"L16","L17","L18"[2ex].},ALL)) AND (([2ex].{"L19","L20","L21"[2ex].} EXCEPT GetTasksTotalCausal([2ex].{"L22","L23"[2ex].},[2ex].{"L24","L25","L26"[2ex].},ANY)) IS SUBSET OF GetTasksAlwaysOccurs([2ex].{"L27","L28","L29"[2ex].})));
150 |  3.b.4.7 |  SELECT * FROM * WHERE (NOT (GetTasksCooccur([2ex].{"L1","L2"[2ex].},[2ex].{"L3","L4","L5"[2ex].},ANY) OVERLAPS WITH GetTasksTotalConcurrent([2ex].{"L6","L7"[2ex].},[2ex].{"L8","L9","L10"[2ex].},ANY))) AND ((GetTasksConflict([2ex].{"L11","L12"[2ex].},[2ex].{"L13","L14","L15"[2ex].},ALL) IS PROPER SUBSET OF GetTasksCanOccur([2ex].{"L16","L17","L18"[2ex].})) AND (([2ex].{"L19","L20","L21"[2ex].} EXCEPT GetTasksTotalCausal([2ex].{"L22","L23"[2ex].},[2ex].{"L24","L25","L26"[2ex].},ALL)) NOT EQUALS GetTasksAlwaysOccurs([2ex].{"L27","L28","L29"[2ex].})));