LCOV - code coverage report
Current view: top level - core/include/mcrl2/core/detail - soundness_checks.h (source / functions) Hit Total Coverage
Test: mcrl2_coverage.info.cleaned Lines: 1595 2460 64.8 %
Date: 2019-09-14 00:54:39 Functions: 420 449 93.5 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : // Author(s): Wieger Wesselink
       2             : // Copyright: see the accompanying file COPYING or copy at
       3             : // https://github.com/mCRL2org/mCRL2/blob/master/COPYING
       4             : //
       5             : // Distributed under the Boost Software License, Version 1.0.
       6             : // (See accompanying file LICENSE_1_0.txt or copy at
       7             : // http://www.boost.org/LICENSE_1_0.txt)
       8             : //
       9             : /// \file mcrl2/core/detail/soundness_checks.h
      10             : /// \brief Add your file description here.
      11             : 
      12             : #ifndef MCRL2_CORE_DETAIL_SOUNDNESS_CHECKS_H
      13             : #define MCRL2_CORE_DETAIL_SOUNDNESS_CHECKS_H
      14             : 
      15             : // This file contains soundness checks for LPS terms.
      16             : // N.B. This file is automatically generated!
      17             : 
      18             : #include "mcrl2/atermpp/aterm.h"
      19             : #include "mcrl2/atermpp/aterm_appl.h"
      20             : #include "mcrl2/atermpp/aterm_list.h"
      21             : #include "mcrl2/atermpp/aterm_string.h"
      22             : #include "mcrl2/core/detail/function_symbols.h"
      23             : #include "mcrl2/utilities/logger.h"
      24             : #include "mcrl2/utilities/unused.h"
      25             : 
      26             : #include <iostream>
      27             : 
      28             : namespace mcrl2
      29             : {
      30             : 
      31             : namespace core
      32             : {
      33             : 
      34             : namespace detail
      35             : {
      36             : 
      37             : // checks
      38             : // 1) if term t satisfies the predicate f
      39             : template <typename Term, typename CheckFunction>
      40  1041981272 : bool check_term_argument(const Term& t, CheckFunction f)
      41             : {
      42  1041981272 :   return f(t);
      43             : }
      44             : 
      45             : // checks
      46             : // 1) if term t is a list,
      47             : // 2) if the list has the proper minimum size
      48             : // 3) if all elements of the list satisfy the predicate f
      49             : template <typename Term, typename CheckFunction>
      50   131720506 : bool check_list_argument(const Term& t, CheckFunction f, unsigned int minimum_size)
      51             : {
      52   131720506 :   const atermpp::aterm& term(t);
      53   131720506 :   if (!t.type_is_list())
      54             :   {
      55           0 :     return false;
      56             :   }
      57   131720506 :   const atermpp::aterm_list& l = atermpp::down_cast<atermpp::aterm_list>(term);
      58   131720506 :   if (l.size() < minimum_size)
      59             :   {
      60           0 :     return false;
      61             :   }
      62   341762075 :   for (const auto& x: l)
      63             :   {
      64   210041569 :     if (!f(x))
      65             :     {
      66           0 :       return false;
      67             :     }
      68             :   }
      69   131720506 :   return true;
      70             : }
      71             : 
      72             : template <typename Term>
      73   497599072 : bool check_rule_String(const Term& t)
      74             : {
      75   497599072 :   const atermpp::aterm& term(t);
      76   497599072 :   if (!term.type_is_appl())
      77             :   {
      78           0 :     return false;
      79             :   }
      80   497599072 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
      81   497599072 :   if (a.size() > 0)
      82             :   {
      83           0 :     return false;
      84             :   }
      85   497599072 :   if (a == atermpp::empty_string())
      86             :   {
      87           0 :     return false;
      88             :   }
      89   497599072 :   return true;
      90             : }
      91             : 
      92             : template <typename Term>
      93     6657750 : bool check_rule_StringOrEmpty(const Term& t)
      94             : {
      95     6657750 :   const atermpp::aterm& term(t);
      96     6657750 :   if (!term.type_is_appl())
      97             :   {
      98           0 :     return false;
      99             :   }
     100     6657750 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
     101     6657750 :   return a.size() <= 0;
     102             : }
     103             : 
     104             : template <typename Term>
     105   124494795 : bool check_rule_Number(const Term& t)
     106             : {
     107   124494795 :   const atermpp::aterm& term(t);
     108   124494795 :   return term.type_is_int();
     109             : }
     110             : 
     111             : template <typename Term> bool check_rule_DataExpr(const Term& t);
     112             : 
     113             : // DataAppl(DataExpr, DataExpr+)
     114             : template <typename Term>
     115    45603002 : bool check_term_DataAppl(const Term& t)
     116             : {
     117    45603002 :   utilities::mcrl2_unused(t);
     118             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
     119             :   // check the type of the term
     120    45603002 :   const atermpp::aterm& term(t);
     121    45603002 :   if (!term.type_is_appl())
     122             :   {
     123           0 :     return false;
     124             :   }
     125    45603002 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
     126    45603002 :   if (!gsIsDataAppl(a))
     127             :   {
     128      596689 :     return false;
     129             :   }
     130             : #ifndef LPS_NO_RECURSIVE_SOUNDNESS_CHECKS
     131   161731106 :   for (const auto& child : a)
     132             :   {
     133   116724793 :     if (!check_term_argument(child, check_rule_DataExpr<atermpp::aterm>))
     134             :     {
     135           0 :       mCRL2log(log::debug, "soundness_checks") << "check_rule_DataExpr" << std::endl;
     136           0 :       return false;
     137             :     }
     138             :   }
     139             : #endif // LPS_NO_RECURSIVE_SOUNDNESS_CHECKS
     140             : 
     141             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
     142    45006313 :   return true;
     143             : }
     144             : 
     145             : //--- start generated code ---//
     146             : template <typename Term> bool check_rule_SortExpr(const Term& t);
     147             : template <typename Term> bool check_rule_SortId(const Term& t);
     148             : template <typename Term> bool check_rule_SortConsType(const Term& t);
     149             : template <typename Term> bool check_rule_StructCons(const Term& t);
     150             : template <typename Term> bool check_rule_StructProj(const Term& t);
     151             : template <typename Term> bool check_rule_DataExpr(const Term& t);
     152             : template <typename Term> bool check_rule_DataVarId(const Term& t);
     153             : template <typename Term> bool check_rule_OpId(const Term& t);
     154             : template <typename Term> bool check_rule_UntypedDataParameter(const Term& t);
     155             : template <typename Term> bool check_rule_BindingOperator(const Term& t);
     156             : template <typename Term> bool check_rule_WhrDecl(const Term& t);
     157             : template <typename Term> bool check_rule_DataVarIdInit(const Term& t);
     158             : template <typename Term> bool check_rule_UntypedIdentifierAssignment(const Term& t);
     159             : template <typename Term> bool check_rule_DataSpec(const Term& t);
     160             : template <typename Term> bool check_rule_SortSpec(const Term& t);
     161             : template <typename Term> bool check_rule_ConsSpec(const Term& t);
     162             : template <typename Term> bool check_rule_MapSpec(const Term& t);
     163             : template <typename Term> bool check_rule_DataEqnSpec(const Term& t);
     164             : template <typename Term> bool check_rule_SortDecl(const Term& t);
     165             : template <typename Term> bool check_rule_DataEqn(const Term& t);
     166             : template <typename Term> bool check_rule_MultAct(const Term& t);
     167             : template <typename Term> bool check_rule_TimedMultAct(const Term& t);
     168             : template <typename Term> bool check_rule_UntypedMultiAction(const Term& t);
     169             : template <typename Term> bool check_rule_Action(const Term& t);
     170             : template <typename Term> bool check_rule_ActId(const Term& t);
     171             : template <typename Term> bool check_rule_ProcExpr(const Term& t);
     172             : template <typename Term> bool check_rule_ProcVarId(const Term& t);
     173             : template <typename Term> bool check_rule_MultActName(const Term& t);
     174             : template <typename Term> bool check_rule_RenameExpr(const Term& t);
     175             : template <typename Term> bool check_rule_CommExpr(const Term& t);
     176             : template <typename Term> bool check_rule_ProcSpec(const Term& t);
     177             : template <typename Term> bool check_rule_ActSpec(const Term& t);
     178             : template <typename Term> bool check_rule_GlobVarSpec(const Term& t);
     179             : template <typename Term> bool check_rule_ProcEqnSpec(const Term& t);
     180             : template <typename Term> bool check_rule_ProcEqn(const Term& t);
     181             : template <typename Term> bool check_rule_MultActOrDelta(const Term& t);
     182             : template <typename Term> bool check_rule_ProcInit(const Term& t);
     183             : template <typename Term> bool check_rule_Distribution(const Term& t);
     184             : template <typename Term> bool check_rule_LinProcSpec(const Term& t);
     185             : template <typename Term> bool check_rule_LinearProcess(const Term& t);
     186             : template <typename Term> bool check_rule_LinearProcessSummand(const Term& t);
     187             : template <typename Term> bool check_rule_LinearProcessInit(const Term& t);
     188             : template <typename Term> bool check_rule_StateFrm(const Term& t);
     189             : template <typename Term> bool check_rule_RegFrm(const Term& t);
     190             : template <typename Term> bool check_rule_ActFrm(const Term& t);
     191             : template <typename Term> bool check_rule_ParamIdOrAction(const Term& t);
     192             : template <typename Term> bool check_rule_ActionRenameRules(const Term& t);
     193             : template <typename Term> bool check_rule_ActionRenameRule(const Term& t);
     194             : template <typename Term> bool check_rule_ActionRenameRuleRHS(const Term& t);
     195             : template <typename Term> bool check_rule_ActionRenameSpec(const Term& t);
     196             : template <typename Term> bool check_rule_PBES(const Term& t);
     197             : template <typename Term> bool check_rule_PBEqnSpec(const Term& t);
     198             : template <typename Term> bool check_rule_PBInit(const Term& t);
     199             : template <typename Term> bool check_rule_PBEqn(const Term& t);
     200             : template <typename Term> bool check_rule_FixPoint(const Term& t);
     201             : template <typename Term> bool check_rule_PropVarDecl(const Term& t);
     202             : template <typename Term> bool check_rule_PBExpr(const Term& t);
     203             : template <typename Term> bool check_rule_PropVarInst(const Term& t);
     204             : template <typename Term> bool check_rule_BES(const Term& t);
     205             : template <typename Term> bool check_rule_BooleanEquation(const Term& t);
     206             : template <typename Term> bool check_rule_BooleanVariable(const Term& t);
     207             : template <typename Term> bool check_rule_BooleanExpression(const Term& t);
     208             : template <typename Term> bool check_rule_BddExpression(const Term& t);
     209             : template <typename Term> bool check_term_BooleanOr(const Term& t);
     210             : template <typename Term> bool check_term_ProcEqn(const Term& t);
     211             : template <typename Term> bool check_term_Hide(const Term& t);
     212             : template <typename Term> bool check_term_SortArrow(const Term& t);
     213             : template <typename Term> bool check_term_ProcessAssignment(const Term& t);
     214             : template <typename Term> bool check_term_Forall(const Term& t);
     215             : template <typename Term> bool check_term_CommExpr(const Term& t);
     216             : template <typename Term> bool check_term_StateNot(const Term& t);
     217             : template <typename Term> bool check_term_UntypedSetBagComp(const Term& t);
     218             : template <typename Term> bool check_term_SortFSet(const Term& t);
     219             : template <typename Term> bool check_term_StateImp(const Term& t);
     220             : template <typename Term> bool check_term_PBESExists(const Term& t);
     221             : template <typename Term> bool check_term_PBESImp(const Term& t);
     222             : template <typename Term> bool check_term_Binder(const Term& t);
     223             : template <typename Term> bool check_term_StochasticOperator(const Term& t);
     224             : template <typename Term> bool check_term_SortRef(const Term& t);
     225             : template <typename Term> bool check_term_ProcEqnSpec(const Term& t);
     226             : template <typename Term> bool check_term_StateForall(const Term& t);
     227             : template <typename Term> bool check_term_BooleanImp(const Term& t);
     228             : template <typename Term> bool check_term_SortId(const Term& t);
     229             : template <typename Term> bool check_term_StateNu(const Term& t);
     230             : template <typename Term> bool check_term_RegNil(const Term& t);
     231             : template <typename Term> bool check_term_DataSpec(const Term& t);
     232             : template <typename Term> bool check_term_Tau(const Term& t);
     233             : template <typename Term> bool check_term_StateYaledTimed(const Term& t);
     234             : template <typename Term> bool check_term_SortCons(const Term& t);
     235             : template <typename Term> bool check_term_DataEqnSpec(const Term& t);
     236             : template <typename Term> bool check_term_LinearProcessSummand(const Term& t);
     237             : template <typename Term> bool check_term_SortSpec(const Term& t);
     238             : template <typename Term> bool check_term_ActionRenameRules(const Term& t);
     239             : template <typename Term> bool check_term_ActAnd(const Term& t);
     240             : template <typename Term> bool check_term_BooleanEquation(const Term& t);
     241             : template <typename Term> bool check_term_ConsSpec(const Term& t);
     242             : template <typename Term> bool check_term_SortList(const Term& t);
     243             : template <typename Term> bool check_term_Sum(const Term& t);
     244             : template <typename Term> bool check_term_DataVarId(const Term& t);
     245             : template <typename Term> bool check_term_ProcVarId(const Term& t);
     246             : template <typename Term> bool check_term_ProcessInit(const Term& t);
     247             : template <typename Term> bool check_term_UntypedIdentifier(const Term& t);
     248             : template <typename Term> bool check_term_BooleanFalse(const Term& t);
     249             : template <typename Term> bool check_term_BES(const Term& t);
     250             : template <typename Term> bool check_term_MapSpec(const Term& t);
     251             : template <typename Term> bool check_term_IfThen(const Term& t);
     252             : template <typename Term> bool check_term_BooleanAnd(const Term& t);
     253             : template <typename Term> bool check_term_LinProcSpec(const Term& t);
     254             : template <typename Term> bool check_term_Choice(const Term& t);
     255             : template <typename Term> bool check_term_LinearProcessInit(const Term& t);
     256             : template <typename Term> bool check_term_MultAct(const Term& t);
     257             : template <typename Term> bool check_term_PropVarInst(const Term& t);
     258             : template <typename Term> bool check_term_BagComp(const Term& t);
     259             : template <typename Term> bool check_term_StateDelay(const Term& t);
     260             : template <typename Term> bool check_term_RegAlt(const Term& t);
     261             : template <typename Term> bool check_term_BddFalse(const Term& t);
     262             : template <typename Term> bool check_term_StructCons(const Term& t);
     263             : template <typename Term> bool check_term_Mu(const Term& t);
     264             : template <typename Term> bool check_term_PBEqnSpec(const Term& t);
     265             : template <typename Term> bool check_term_UntypedRegFrm(const Term& t);
     266             : template <typename Term> bool check_term_Distribution(const Term& t);
     267             : template <typename Term> bool check_term_BooleanTrue(const Term& t);
     268             : template <typename Term> bool check_term_Block(const Term& t);
     269             : template <typename Term> bool check_term_Rename(const Term& t);
     270             : template <typename Term> bool check_term_Exists(const Term& t);
     271             : template <typename Term> bool check_term_Sync(const Term& t);
     272             : template <typename Term> bool check_term_ActExists(const Term& t);
     273             : template <typename Term> bool check_term_ProcSpec(const Term& t);
     274             : template <typename Term> bool check_term_UntypedSortsPossible(const Term& t);
     275             : template <typename Term> bool check_term_StateMu(const Term& t);
     276             : template <typename Term> bool check_term_BddIf(const Term& t);
     277             : template <typename Term> bool check_term_StateFalse(const Term& t);
     278             : template <typename Term> bool check_term_PBESFalse(const Term& t);
     279             : template <typename Term> bool check_term_PBESForall(const Term& t);
     280             : template <typename Term> bool check_term_StateTrue(const Term& t);
     281             : template <typename Term> bool check_term_BInit(const Term& t);
     282             : template <typename Term> bool check_term_UntypedSortUnknown(const Term& t);
     283             : template <typename Term> bool check_term_RegTrans(const Term& t);
     284             : template <typename Term> bool check_term_StateDelayTimed(const Term& t);
     285             : template <typename Term> bool check_term_Nu(const Term& t);
     286             : template <typename Term> bool check_term_SortStruct(const Term& t);
     287             : template <typename Term> bool check_term_AtTime(const Term& t);
     288             : template <typename Term> bool check_term_ActOr(const Term& t);
     289             : template <typename Term> bool check_term_Comm(const Term& t);
     290             : template <typename Term> bool check_term_BooleanNot(const Term& t);
     291             : template <typename Term> bool check_term_Delta(const Term& t);
     292             : template <typename Term> bool check_term_ActMultAct(const Term& t);
     293             : template <typename Term> bool check_term_StateAnd(const Term& t);
     294             : template <typename Term> bool check_term_LMerge(const Term& t);
     295             : template <typename Term> bool check_term_SetComp(const Term& t);
     296             : template <typename Term> bool check_term_ActForall(const Term& t);
     297             : template <typename Term> bool check_term_RenameExpr(const Term& t);
     298             : template <typename Term> bool check_term_Merge(const Term& t);
     299             : template <typename Term> bool check_term_ActSpec(const Term& t);
     300             : template <typename Term> bool check_term_BooleanVariable(const Term& t);
     301             : template <typename Term> bool check_term_Action(const Term& t);
     302             : template <typename Term> bool check_term_PBESAnd(const Term& t);
     303             : template <typename Term> bool check_term_Lambda(const Term& t);
     304             : template <typename Term> bool check_term_StateMust(const Term& t);
     305             : template <typename Term> bool check_term_Seq(const Term& t);
     306             : template <typename Term> bool check_term_DataVarIdInit(const Term& t);
     307             : template <typename Term> bool check_term_Process(const Term& t);
     308             : template <typename Term> bool check_term_TimedMultAct(const Term& t);
     309             : template <typename Term> bool check_term_ActionRenameSpec(const Term& t);
     310             : template <typename Term> bool check_term_PBES(const Term& t);
     311             : template <typename Term> bool check_term_StateVar(const Term& t);
     312             : template <typename Term> bool check_term_ActionRenameRule(const Term& t);
     313             : template <typename Term> bool check_term_RegSeq(const Term& t);
     314             : template <typename Term> bool check_term_ActNot(const Term& t);
     315             : template <typename Term> bool check_term_LinearProcess(const Term& t);
     316             : template <typename Term> bool check_term_ActAt(const Term& t);
     317             : template <typename Term> bool check_term_DataEqn(const Term& t);
     318             : template <typename Term> bool check_term_PBESNot(const Term& t);
     319             : template <typename Term> bool check_term_StateExists(const Term& t);
     320             : template <typename Term> bool check_term_StateMay(const Term& t);
     321             : template <typename Term> bool check_term_PBESTrue(const Term& t);
     322             : template <typename Term> bool check_term_MultActName(const Term& t);
     323             : template <typename Term> bool check_term_IfThenElse(const Term& t);
     324             : template <typename Term> bool check_term_UntypedSortVariable(const Term& t);
     325             : template <typename Term> bool check_term_StateOr(const Term& t);
     326             : template <typename Term> bool check_term_StructProj(const Term& t);
     327             : template <typename Term> bool check_term_PBEqn(const Term& t);
     328             : template <typename Term> bool check_term_Whr(const Term& t);
     329             : template <typename Term> bool check_term_OpId(const Term& t);
     330             : template <typename Term> bool check_term_SortSet(const Term& t);
     331             : template <typename Term> bool check_term_ActFalse(const Term& t);
     332             : template <typename Term> bool check_term_ActId(const Term& t);
     333             : template <typename Term> bool check_term_StateYaled(const Term& t);
     334             : template <typename Term> bool check_term_PBESOr(const Term& t);
     335             : template <typename Term> bool check_term_BddTrue(const Term& t);
     336             : template <typename Term> bool check_term_UntypedProcessAssignment(const Term& t);
     337             : template <typename Term> bool check_term_SortFBag(const Term& t);
     338             : template <typename Term> bool check_term_Allow(const Term& t);
     339             : template <typename Term> bool check_term_PropVarDecl(const Term& t);
     340             : template <typename Term> bool check_term_ActImp(const Term& t);
     341             : template <typename Term> bool check_term_SortBag(const Term& t);
     342             : template <typename Term> bool check_term_PBInit(const Term& t);
     343             : template <typename Term> bool check_term_ActTrue(const Term& t);
     344             : template <typename Term> bool check_term_RegTransOrNil(const Term& t);
     345             : template <typename Term> bool check_term_UntypedMultiAction(const Term& t);
     346             : template <typename Term> bool check_term_GlobVarSpec(const Term& t);
     347             : template <typename Term> bool check_term_UntypedIdentifierAssignment(const Term& t);
     348             : template <typename Term> bool check_term_UntypedDataParameter(const Term& t);
     349             : 
     350             : template <typename Term>
     351   500109448 : bool check_rule_SortExpr(const Term& t)
     352             : {
     353   500109448 :   utilities::mcrl2_unused(t);
     354             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
     355   500109448 :   return check_rule_SortId(t)
     356   134861096 :          || check_term_SortCons(t)
     357   114823187 :          || check_term_SortStruct(t)
     358   112108342 :          || check_term_SortArrow(t)
     359    11449332 :          || check_term_UntypedSortUnknown(t)
     360      122635 :          || check_term_UntypedSortsPossible(t)
     361   873474040 :          || check_term_UntypedSortVariable(t);
     362             : #else
     363             :   return true;
     364             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
     365             : }
     366             : 
     367             : template <typename Term>
     368   500110368 : bool check_rule_SortId(const Term& t)
     369             : {
     370   500110368 :   utilities::mcrl2_unused(t);
     371             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
     372   500110368 :   return check_term_SortId(t);
     373             : #else
     374             :   return true;
     375             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
     376             : }
     377             : 
     378             : template <typename Term>
     379    23884054 : bool check_rule_SortConsType(const Term& t)
     380             : {
     381    23884054 :   utilities::mcrl2_unused(t);
     382             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
     383    23884054 :   return check_term_SortList(t)
     384    10542028 :          || check_term_SortSet(t)
     385     8054623 :          || check_term_SortBag(t)
     386     7007130 :          || check_term_SortFSet(t)
     387    49487835 :          || check_term_SortFBag(t);
     388             : #else
     389             :   return true;
     390             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
     391             : }
     392             : 
     393             : template <typename Term>
     394     5543943 : bool check_rule_StructCons(const Term& t)
     395             : {
     396     5543943 :   utilities::mcrl2_unused(t);
     397             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
     398     5543943 :   return check_term_StructCons(t);
     399             : #else
     400             :   return true;
     401             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
     402             : }
     403             : 
     404             : template <typename Term>
     405     1113807 : bool check_rule_StructProj(const Term& t)
     406             : {
     407     1113807 :   utilities::mcrl2_unused(t);
     408             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
     409     1113807 :   return check_term_StructProj(t);
     410             : #else
     411             :   return true;
     412             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
     413             : }
     414             : 
     415             : template <typename Term>
     416   164075085 : bool check_rule_DataExpr(const Term& t)
     417             : {
     418   164075085 :   utilities::mcrl2_unused(t);
     419             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
     420   164075085 :   return check_rule_DataVarId(t)
     421   124862397 :          || check_rule_OpId(t)
     422    45349440 :          || check_term_DataAppl(t)
     423      596689 :          || check_term_Binder(t)
     424      488051 :          || check_term_Whr(t)
     425   335371662 :          || check_term_UntypedIdentifier(t);
     426             : #else
     427             :   return true;
     428             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
     429             : }
     430             : 
     431             : template <typename Term>
     432   166836825 : bool check_rule_DataVarId(const Term& t)
     433             : {
     434   166836825 :   utilities::mcrl2_unused(t);
     435             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
     436   166836825 :   return check_term_DataVarId(t);
     437             : #else
     438             :   return true;
     439             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
     440             : }
     441             : 
     442             : template <typename Term>
     443   124862513 : bool check_rule_OpId(const Term& t)
     444             : {
     445   124862513 :   utilities::mcrl2_unused(t);
     446             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
     447   124862513 :   return check_term_OpId(t);
     448             : #else
     449             :   return true;
     450             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
     451             : }
     452             : 
     453             : template <typename Term>
     454       41987 : bool check_rule_UntypedDataParameter(const Term& t)
     455             : {
     456       41987 :   utilities::mcrl2_unused(t);
     457             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
     458       41987 :   return check_term_UntypedDataParameter(t);
     459             : #else
     460             :   return true;
     461             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
     462             : }
     463             : 
     464             : template <typename Term>
     465      159839 : bool check_rule_BindingOperator(const Term& t)
     466             : {
     467      159839 :   utilities::mcrl2_unused(t);
     468             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
     469      159839 :   return check_term_Forall(t)
     470       95254 :          || check_term_Exists(t)
     471       94367 :          || check_term_SetComp(t)
     472       94226 :          || check_term_BagComp(t)
     473       94178 :          || check_term_Lambda(t)
     474      537864 :          || check_term_UntypedSetBagComp(t);
     475             : #else
     476             :   return true;
     477             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
     478             : }
     479             : 
     480             : template <typename Term>
     481       65191 : bool check_rule_WhrDecl(const Term& t)
     482             : {
     483       65191 :   utilities::mcrl2_unused(t);
     484             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
     485       65191 :   return check_rule_DataVarIdInit(t)
     486       65191 :          || check_rule_UntypedIdentifierAssignment(t);
     487             : #else
     488             :   return true;
     489             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
     490             : }
     491             : 
     492             : template <typename Term>
     493      967589 : bool check_rule_DataVarIdInit(const Term& t)
     494             : {
     495      967589 :   utilities::mcrl2_unused(t);
     496             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
     497      967589 :   return check_term_DataVarIdInit(t);
     498             : #else
     499             :   return true;
     500             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
     501             : }
     502             : 
     503             : template <typename Term>
     504       22736 : bool check_rule_UntypedIdentifierAssignment(const Term& t)
     505             : {
     506       22736 :   utilities::mcrl2_unused(t);
     507             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
     508       22736 :   return check_term_UntypedIdentifierAssignment(t);
     509             : #else
     510             :   return true;
     511             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
     512             : }
     513             : 
     514             : template <typename Term>
     515         296 : bool check_rule_DataSpec(const Term& t)
     516             : {
     517         296 :   utilities::mcrl2_unused(t);
     518             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
     519         296 :   return check_term_DataSpec(t);
     520             : #else
     521             :   return true;
     522             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
     523             : }
     524             : 
     525             : template <typename Term>
     526         296 : bool check_rule_SortSpec(const Term& t)
     527             : {
     528         296 :   utilities::mcrl2_unused(t);
     529             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
     530         296 :   return check_term_SortSpec(t);
     531             : #else
     532             :   return true;
     533             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
     534             : }
     535             : 
     536             : template <typename Term>
     537         296 : bool check_rule_ConsSpec(const Term& t)
     538             : {
     539         296 :   utilities::mcrl2_unused(t);
     540             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
     541         296 :   return check_term_ConsSpec(t);
     542             : #else
     543             :   return true;
     544             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
     545             : }
     546             : 
     547             : template <typename Term>
     548         296 : bool check_rule_MapSpec(const Term& t)
     549             : {
     550         296 :   utilities::mcrl2_unused(t);
     551             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
     552         296 :   return check_term_MapSpec(t);
     553             : #else
     554             :   return true;
     555             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
     556             : }
     557             : 
     558             : template <typename Term>
     559         296 : bool check_rule_DataEqnSpec(const Term& t)
     560             : {
     561         296 :   utilities::mcrl2_unused(t);
     562             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
     563         296 :   return check_term_DataEqnSpec(t);
     564             : #else
     565             :   return true;
     566             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
     567             : }
     568             : 
     569             : template <typename Term>
     570         160 : bool check_rule_SortDecl(const Term& t)
     571             : {
     572         160 :   utilities::mcrl2_unused(t);
     573             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
     574         160 :   return check_rule_SortId(t)
     575         160 :          || check_term_SortRef(t);
     576             : #else
     577             :   return true;
     578             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
     579             : }
     580             : 
     581             : template <typename Term>
     582         125 : bool check_rule_DataEqn(const Term& t)
     583             : {
     584         125 :   utilities::mcrl2_unused(t);
     585             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
     586         125 :   return check_term_DataEqn(t);
     587             : #else
     588             :   return true;
     589             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
     590             : }
     591             : 
     592             : template <typename Term>
     593          75 : bool check_rule_MultAct(const Term& t)
     594             : {
     595          75 :   utilities::mcrl2_unused(t);
     596             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
     597          75 :   return check_term_MultAct(t);
     598             : #else
     599             :   return true;
     600             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
     601             : }
     602             : 
     603             : template <typename Term>
     604             : bool check_rule_TimedMultAct(const Term& t)
     605             : {
     606             :   utilities::mcrl2_unused(t);
     607             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
     608             :   return check_term_TimedMultAct(t);
     609             : #else
     610             :   return true;
     611             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
     612             : }
     613             : 
     614             : template <typename Term>
     615        1749 : bool check_rule_UntypedMultiAction(const Term& t)
     616             : {
     617        1749 :   utilities::mcrl2_unused(t);
     618             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
     619        1749 :   return check_term_UntypedMultiAction(t);
     620             : #else
     621             :   return true;
     622             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
     623             : }
     624             : 
     625             : template <typename Term>
     626     3600678 : bool check_rule_Action(const Term& t)
     627             : {
     628     3600678 :   utilities::mcrl2_unused(t);
     629             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
     630     3600678 :   return check_term_Action(t);
     631             : #else
     632             :   return true;
     633             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
     634             : }
     635             : 
     636             : template <typename Term>
     637     1019440 : bool check_rule_ActId(const Term& t)
     638             : {
     639     1019440 :   utilities::mcrl2_unused(t);
     640             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
     641     1019440 :   return check_term_ActId(t);
     642             : #else
     643             :   return true;
     644             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
     645             : }
     646             : 
     647             : template <typename Term>
     648     3594117 : bool check_rule_ProcExpr(const Term& t)
     649             : {
     650     3594117 :   utilities::mcrl2_unused(t);
     651             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
     652     3594117 :   return check_rule_Action(t)
     653     2609901 :          || check_term_Process(t)
     654     2512641 :          || check_term_ProcessAssignment(t)
     655     1722688 :          || check_term_Delta(t)
     656     1678175 :          || check_term_Tau(t)
     657     1661776 :          || check_term_Sum(t)
     658     1579418 :          || check_term_Block(t)
     659     1579418 :          || check_term_Hide(t)
     660     1578932 :          || check_term_Rename(t)
     661     1578932 :          || check_term_Comm(t)
     662     1573659 :          || check_term_Allow(t)
     663     1485453 :          || check_term_Sync(t)
     664     1429944 :          || check_term_AtTime(t)
     665     1377109 :          || check_term_Seq(t)
     666      687336 :          || check_term_IfThen(t)
     667      408824 :          || check_term_IfThenElse(t)
     668      372358 :          || check_term_BInit(t)
     669      372358 :          || check_term_Merge(t)
     670      326649 :          || check_term_LMerge(t)
     671      326649 :          || check_term_Choice(t)
     672       79806 :          || check_term_StochasticOperator(t)
     673       41992 :          || check_term_UntypedProcessAssignment(t)
     674    28578135 :          || check_rule_UntypedDataParameter(t);
     675             : #else
     676             :   return true;
     677             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
     678             : }
     679             : 
     680             : template <typename Term>
     681      951722 : bool check_rule_ProcVarId(const Term& t)
     682             : {
     683      951722 :   utilities::mcrl2_unused(t);
     684             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
     685      951722 :   return check_term_ProcVarId(t);
     686             : #else
     687             :   return true;
     688             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
     689             : }
     690             : 
     691             : template <typename Term>
     692      354233 : bool check_rule_MultActName(const Term& t)
     693             : {
     694      354233 :   utilities::mcrl2_unused(t);
     695             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
     696      354233 :   return check_term_MultActName(t);
     697             : #else
     698             :   return true;
     699             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
     700             : }
     701             : 
     702             : template <typename Term>
     703           0 : bool check_rule_RenameExpr(const Term& t)
     704             : {
     705           0 :   utilities::mcrl2_unused(t);
     706             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
     707           0 :   return check_term_RenameExpr(t);
     708             : #else
     709             :   return true;
     710             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
     711             : }
     712             : 
     713             : template <typename Term>
     714       19436 : bool check_rule_CommExpr(const Term& t)
     715             : {
     716       19436 :   utilities::mcrl2_unused(t);
     717             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
     718       19436 :   return check_term_CommExpr(t);
     719             : #else
     720             :   return true;
     721             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
     722             : }
     723             : 
     724             : template <typename Term>
     725             : bool check_rule_ProcSpec(const Term& t)
     726             : {
     727             :   utilities::mcrl2_unused(t);
     728             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
     729             :   return check_term_ProcSpec(t);
     730             : #else
     731             :   return true;
     732             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
     733             : }
     734             : 
     735             : template <typename Term>
     736           5 : bool check_rule_ActSpec(const Term& t)
     737             : {
     738           5 :   utilities::mcrl2_unused(t);
     739             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
     740           5 :   return check_term_ActSpec(t);
     741             : #else
     742             :   return true;
     743             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
     744             : }
     745             : 
     746             : template <typename Term>
     747         176 : bool check_rule_GlobVarSpec(const Term& t)
     748             : {
     749         176 :   utilities::mcrl2_unused(t);
     750             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
     751         176 :   return check_term_GlobVarSpec(t);
     752             : #else
     753             :   return true;
     754             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
     755             : }
     756             : 
     757             : template <typename Term>
     758           0 : bool check_rule_ProcEqnSpec(const Term& t)
     759             : {
     760           0 :   utilities::mcrl2_unused(t);
     761             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
     762           0 :   return check_term_ProcEqnSpec(t);
     763             : #else
     764             :   return true;
     765             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
     766             : }
     767             : 
     768             : template <typename Term>
     769           0 : bool check_rule_ProcEqn(const Term& t)
     770             : {
     771           0 :   utilities::mcrl2_unused(t);
     772             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
     773           0 :   return check_term_ProcEqn(t);
     774             : #else
     775             :   return true;
     776             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
     777             : }
     778             : 
     779             : template <typename Term>
     780          75 : bool check_rule_MultActOrDelta(const Term& t)
     781             : {
     782          75 :   utilities::mcrl2_unused(t);
     783             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
     784          75 :   return check_rule_MultAct(t)
     785          75 :          || check_term_Delta(t);
     786             : #else
     787             :   return true;
     788             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
     789             : }
     790             : 
     791             : template <typename Term>
     792           0 : bool check_rule_ProcInit(const Term& t)
     793             : {
     794           0 :   utilities::mcrl2_unused(t);
     795             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
     796           0 :   return check_term_ProcessInit(t);
     797             : #else
     798             :   return true;
     799             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
     800             : }
     801             : 
     802             : template <typename Term>
     803        7236 : bool check_rule_Distribution(const Term& t)
     804             : {
     805        7236 :   utilities::mcrl2_unused(t);
     806             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
     807        7236 :   return check_term_Distribution(t);
     808             : #else
     809             :   return true;
     810             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
     811             : }
     812             : 
     813             : template <typename Term>
     814             : bool check_rule_LinProcSpec(const Term& t)
     815             : {
     816             :   utilities::mcrl2_unused(t);
     817             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
     818             :   return check_term_LinProcSpec(t);
     819             : #else
     820             :   return true;
     821             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
     822             : }
     823             : 
     824             : template <typename Term>
     825           5 : bool check_rule_LinearProcess(const Term& t)
     826             : {
     827           5 :   utilities::mcrl2_unused(t);
     828             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
     829           5 :   return check_term_LinearProcess(t);
     830             : #else
     831             :   return true;
     832             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
     833             : }
     834             : 
     835             : template <typename Term>
     836          75 : bool check_rule_LinearProcessSummand(const Term& t)
     837             : {
     838          75 :   utilities::mcrl2_unused(t);
     839             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
     840          75 :   return check_term_LinearProcessSummand(t);
     841             : #else
     842             :   return true;
     843             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
     844             : }
     845             : 
     846             : template <typename Term>
     847           5 : bool check_rule_LinearProcessInit(const Term& t)
     848             : {
     849           5 :   utilities::mcrl2_unused(t);
     850             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
     851           5 :   return check_term_LinearProcessInit(t);
     852             : #else
     853             :   return true;
     854             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
     855             : }
     856             : 
     857             : template <typename Term>
     858       30952 : bool check_rule_StateFrm(const Term& t)
     859             : {
     860       30952 :   utilities::mcrl2_unused(t);
     861             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
     862       30952 :   return check_rule_DataExpr(t)
     863       29334 :          || check_term_StateTrue(t)
     864       26038 :          || check_term_StateFalse(t)
     865       24836 :          || check_term_StateNot(t)
     866       23563 :          || check_term_StateAnd(t)
     867       20549 :          || check_term_StateOr(t)
     868       19559 :          || check_term_StateImp(t)
     869       18343 :          || check_term_StateForall(t)
     870       17974 :          || check_term_StateExists(t)
     871       17848 :          || check_term_StateMust(t)
     872       13022 :          || check_term_StateMay(t)
     873        9874 :          || check_term_StateYaled(t)
     874        9874 :          || check_term_StateYaledTimed(t)
     875        9862 :          || check_term_StateDelay(t)
     876        9862 :          || check_term_StateDelayTimed(t)
     877        9842 :          || check_term_StateVar(t)
     878        4726 :          || check_term_StateNu(t)
     879        3331 :          || check_term_StateMu(t)
     880      299389 :          || check_rule_UntypedDataParameter(t);
     881             : #else
     882             :   return true;
     883             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
     884             : }
     885             : 
     886             : template <typename Term>
     887        8961 : bool check_rule_RegFrm(const Term& t)
     888             : {
     889        8961 :   utilities::mcrl2_unused(t);
     890             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
     891        8961 :   return check_rule_ActFrm(t)
     892         379 :          || check_term_RegNil(t)
     893         379 :          || check_term_RegSeq(t)
     894         355 :          || check_term_RegAlt(t)
     895         355 :          || check_term_RegTrans(t)
     896         355 :          || check_term_RegTransOrNil(t)
     897       10784 :          || check_term_UntypedRegFrm(t);
     898             : #else
     899             :   return true;
     900             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
     901             : }
     902             : 
     903             : template <typename Term>
     904       12790 : bool check_rule_ActFrm(const Term& t)
     905             : {
     906       12790 :   utilities::mcrl2_unused(t);
     907             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
     908       12790 :   return check_rule_DataExpr(t)
     909       12790 :          || check_term_ActTrue(t)
     910       10814 :          || check_term_ActFalse(t)
     911       10814 :          || check_term_ActNot(t)
     912        8828 :          || check_term_ActAnd(t)
     913        8485 :          || check_term_ActOr(t)
     914        8401 :          || check_term_ActImp(t)
     915        8401 :          || check_term_ActForall(t)
     916        8299 :          || check_term_ActExists(t)
     917        8250 :          || check_term_ActAt(t)
     918        8250 :          || check_term_ActMultAct(t)
     919        1749 :          || check_rule_UntypedDataParameter(t)
     920      107871 :          || check_rule_UntypedMultiAction(t);
     921             : #else
     922             :   return true;
     923             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
     924             : }
     925             : 
     926             : template <typename Term>
     927             : bool check_rule_ParamIdOrAction(const Term& t)
     928             : {
     929             :   utilities::mcrl2_unused(t);
     930             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
     931             :   return check_rule_UntypedDataParameter(t)
     932             :          || check_rule_Action(t);
     933             : #else
     934             :   return true;
     935             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
     936             : }
     937             : 
     938             : template <typename Term>
     939             : bool check_rule_ActionRenameRules(const Term& t)
     940             : {
     941             :   utilities::mcrl2_unused(t);
     942             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
     943             :   return check_term_ActionRenameRules(t);
     944             : #else
     945             :   return true;
     946             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
     947             : }
     948             : 
     949             : template <typename Term>
     950             : bool check_rule_ActionRenameRule(const Term& t)
     951             : {
     952             :   utilities::mcrl2_unused(t);
     953             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
     954             :   return check_term_ActionRenameRule(t);
     955             : #else
     956             :   return true;
     957             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
     958             : }
     959             : 
     960             : template <typename Term>
     961             : bool check_rule_ActionRenameRuleRHS(const Term& t)
     962             : {
     963             :   utilities::mcrl2_unused(t);
     964             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
     965             :   return check_rule_UntypedDataParameter(t)
     966             :          || check_rule_Action(t)
     967             :          || check_term_Delta(t)
     968             :          || check_term_Tau(t);
     969             : #else
     970             :   return true;
     971             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
     972             : }
     973             : 
     974             : template <typename Term>
     975             : bool check_rule_ActionRenameSpec(const Term& t)
     976             : {
     977             :   utilities::mcrl2_unused(t);
     978             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
     979             :   return check_term_ActionRenameSpec(t);
     980             : #else
     981             :   return true;
     982             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
     983             : }
     984             : 
     985             : template <typename Term>
     986         171 : bool check_rule_PBES(const Term& t)
     987             : {
     988         171 :   utilities::mcrl2_unused(t);
     989             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
     990         171 :   return check_term_PBES(t);
     991             : #else
     992             :   return true;
     993             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
     994             : }
     995             : 
     996             : template <typename Term>
     997         171 : bool check_rule_PBEqnSpec(const Term& t)
     998             : {
     999         171 :   utilities::mcrl2_unused(t);
    1000             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    1001         171 :   return check_term_PBEqnSpec(t);
    1002             : #else
    1003             :   return true;
    1004             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    1005             : }
    1006             : 
    1007             : template <typename Term>
    1008         171 : bool check_rule_PBInit(const Term& t)
    1009             : {
    1010         171 :   utilities::mcrl2_unused(t);
    1011             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    1012         171 :   return check_term_PBInit(t);
    1013             : #else
    1014             :   return true;
    1015             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    1016             : }
    1017             : 
    1018             : template <typename Term>
    1019         550 : bool check_rule_PBEqn(const Term& t)
    1020             : {
    1021         550 :   utilities::mcrl2_unused(t);
    1022             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    1023         550 :   return check_term_PBEqn(t);
    1024             : #else
    1025             :   return true;
    1026             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    1027             : }
    1028             : 
    1029             : template <typename Term>
    1030        4144 : bool check_rule_FixPoint(const Term& t)
    1031             : {
    1032        4144 :   utilities::mcrl2_unused(t);
    1033             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    1034        4144 :   return check_term_Mu(t)
    1035        4144 :          || check_term_Nu(t);
    1036             : #else
    1037             :   return true;
    1038             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    1039             : }
    1040             : 
    1041             : template <typename Term>
    1042         550 : bool check_rule_PropVarDecl(const Term& t)
    1043             : {
    1044         550 :   utilities::mcrl2_unused(t);
    1045             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    1046         550 :   return check_term_PropVarDecl(t);
    1047             : #else
    1048             :   return true;
    1049             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    1050             : }
    1051             : 
    1052             : template <typename Term>
    1053      234630 : bool check_rule_PBExpr(const Term& t)
    1054             : {
    1055      234630 :   utilities::mcrl2_unused(t);
    1056             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    1057      234630 :   return check_rule_DataExpr(t)
    1058      177529 :          || check_term_PBESTrue(t)
    1059      177529 :          || check_term_PBESFalse(t)
    1060      177529 :          || check_term_PBESNot(t)
    1061      173105 :          || check_term_PBESAnd(t)
    1062      129058 :          || check_term_PBESOr(t)
    1063       99789 :          || check_term_PBESImp(t)
    1064       93547 :          || check_term_PBESForall(t)
    1065       86866 :          || check_term_PBESExists(t)
    1066       80499 :          || check_rule_PropVarInst(t)
    1067     1430081 :          || check_rule_UntypedDataParameter(t);
    1068             : #else
    1069             :   return true;
    1070             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    1071             : }
    1072             : 
    1073             : template <typename Term>
    1074       80670 : bool check_rule_PropVarInst(const Term& t)
    1075             : {
    1076       80670 :   utilities::mcrl2_unused(t);
    1077             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    1078       80670 :   return check_term_PropVarInst(t);
    1079             : #else
    1080             :   return true;
    1081             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    1082             : }
    1083             : 
    1084             : template <typename Term>
    1085           1 : bool check_rule_BES(const Term& t)
    1086             : {
    1087           1 :   utilities::mcrl2_unused(t);
    1088             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    1089           1 :   return check_term_BES(t);
    1090             : #else
    1091             :   return true;
    1092             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    1093             : }
    1094             : 
    1095             : template <typename Term>
    1096           4 : bool check_rule_BooleanEquation(const Term& t)
    1097             : {
    1098           4 :   utilities::mcrl2_unused(t);
    1099             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    1100           4 :   return check_term_BooleanEquation(t);
    1101             : #else
    1102             :   return true;
    1103             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    1104             : }
    1105             : 
    1106             : template <typename Term>
    1107        1114 : bool check_rule_BooleanVariable(const Term& t)
    1108             : {
    1109        1114 :   utilities::mcrl2_unused(t);
    1110             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    1111        1114 :   return check_term_BooleanVariable(t);
    1112             : #else
    1113             :   return true;
    1114             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    1115             : }
    1116             : 
    1117             : template <typename Term>
    1118        1295 : bool check_rule_BooleanExpression(const Term& t)
    1119             : {
    1120        1295 :   utilities::mcrl2_unused(t);
    1121             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    1122        1295 :   return check_term_BooleanTrue(t)
    1123        1163 :          || check_term_BooleanFalse(t)
    1124        1110 :          || check_rule_BooleanVariable(t)
    1125         190 :          || check_term_BooleanNot(t)
    1126         189 :          || check_term_BooleanAnd(t)
    1127          44 :          || check_term_BooleanOr(t)
    1128        3991 :          || check_term_BooleanImp(t);
    1129             : #else
    1130             :   return true;
    1131             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    1132             : }
    1133             : 
    1134             : template <typename Term>
    1135          24 : bool check_rule_BddExpression(const Term& t)
    1136             : {
    1137          24 :   utilities::mcrl2_unused(t);
    1138             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    1139          24 :   return check_term_BddTrue(t)
    1140          16 :          || check_term_BddFalse(t)
    1141          40 :          || check_term_BddIf(t);
    1142             : #else
    1143             :   return true;
    1144             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    1145             : }
    1146             : 
    1147             : // BooleanOr(BooleanExpression, BooleanExpression)
    1148             : template <typename Term>
    1149          44 : bool check_term_BooleanOr(const Term& t)
    1150             : {
    1151          44 :   utilities::mcrl2_unused(t);
    1152             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    1153             :   // check the type of the term
    1154          44 :   const atermpp::aterm& term(t);
    1155          44 :   if (!term.type_is_appl())
    1156             :   {
    1157           0 :     return false;
    1158             :   }
    1159          44 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    1160          44 :   if (a.function() != core::detail::function_symbols::BooleanOr)
    1161             :   {
    1162           6 :     return false;
    1163             :   }
    1164             : 
    1165             :   // check the children
    1166          38 :   if (a.size() != 2)
    1167             :   {
    1168           0 :     return false;
    1169             :   }
    1170             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    1171          38 :   if (!check_term_argument(a[0], check_rule_BooleanExpression<atermpp::aterm>))
    1172             :   {
    1173           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_BooleanExpression" << std::endl;
    1174           0 :     return false;
    1175             :   }
    1176          38 :   if (!check_term_argument(a[1], check_rule_BooleanExpression<atermpp::aterm>))
    1177             :   {
    1178           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_BooleanExpression" << std::endl;
    1179           0 :     return false;
    1180             :   }
    1181             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    1182             : 
    1183             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    1184          38 :   return true;
    1185             : }
    1186             : 
    1187             : // ProcEqn(ProcVarId, DataVarId*, ProcExpr)
    1188             : template <typename Term>
    1189           0 : bool check_term_ProcEqn(const Term& t)
    1190             : {
    1191           0 :   utilities::mcrl2_unused(t);
    1192             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    1193             :   // check the type of the term
    1194           0 :   const atermpp::aterm& term(t);
    1195           0 :   if (!term.type_is_appl())
    1196             :   {
    1197           0 :     return false;
    1198             :   }
    1199           0 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    1200           0 :   if (a.function() != core::detail::function_symbols::ProcEqn)
    1201             :   {
    1202           0 :     return false;
    1203             :   }
    1204             : 
    1205             :   // check the children
    1206           0 :   if (a.size() != 3)
    1207             :   {
    1208           0 :     return false;
    1209             :   }
    1210             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    1211           0 :   if (!check_term_argument(a[0], check_rule_ProcVarId<atermpp::aterm>))
    1212             :   {
    1213           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_ProcVarId" << std::endl;
    1214           0 :     return false;
    1215             :   }
    1216           0 :   if (!check_list_argument(a[1], check_rule_DataVarId<atermpp::aterm>, 0))
    1217             :   {
    1218           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_DataVarId" << std::endl;
    1219           0 :     return false;
    1220             :   }
    1221           0 :   if (!check_term_argument(a[2], check_rule_ProcExpr<atermpp::aterm>))
    1222             :   {
    1223           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_ProcExpr" << std::endl;
    1224           0 :     return false;
    1225             :   }
    1226             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    1227             : 
    1228             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    1229           0 :   return true;
    1230             : }
    1231             : 
    1232             : // Hide(String*, ProcExpr)
    1233             : template <typename Term>
    1234     1579664 : bool check_term_Hide(const Term& t)
    1235             : {
    1236     1579664 :   utilities::mcrl2_unused(t);
    1237             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    1238             :   // check the type of the term
    1239     1579664 :   const atermpp::aterm& term(t);
    1240     1579664 :   if (!term.type_is_appl())
    1241             :   {
    1242           0 :     return false;
    1243             :   }
    1244     1579664 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    1245     1579664 :   if (a.function() != core::detail::function_symbols::Hide)
    1246             :   {
    1247     1578932 :     return false;
    1248             :   }
    1249             : 
    1250             :   // check the children
    1251         732 :   if (a.size() != 2)
    1252             :   {
    1253           0 :     return false;
    1254             :   }
    1255             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    1256         732 :   if (!check_list_argument(a[0], check_rule_String<atermpp::aterm>, 0))
    1257             :   {
    1258           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_String" << std::endl;
    1259           0 :     return false;
    1260             :   }
    1261         732 :   if (!check_term_argument(a[1], check_rule_ProcExpr<atermpp::aterm>))
    1262             :   {
    1263           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_ProcExpr" << std::endl;
    1264           0 :     return false;
    1265             :   }
    1266             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    1267             : 
    1268             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    1269         732 :   return true;
    1270             : }
    1271             : 
    1272             : // SortArrow(SortExpr+, SortExpr)
    1273             : template <typename Term>
    1274   129940320 : bool check_term_SortArrow(const Term& t)
    1275             : {
    1276   129940320 :   utilities::mcrl2_unused(t);
    1277             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    1278             :   // check the type of the term
    1279   129940320 :   const atermpp::aterm& term(t);
    1280   129940320 :   if (!term.type_is_appl())
    1281             :   {
    1282           0 :     return false;
    1283             :   }
    1284   129940320 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    1285   129940320 :   if (a.function() != core::detail::function_symbols::SortArrow)
    1286             :   {
    1287    11449332 :     return false;
    1288             :   }
    1289             : 
    1290             :   // check the children
    1291   118490988 :   if (a.size() != 2)
    1292             :   {
    1293           0 :     return false;
    1294             :   }
    1295             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    1296   118490988 :   if (!check_list_argument(a[0], check_rule_SortExpr<atermpp::aterm>, 1))
    1297             :   {
    1298           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_SortExpr" << std::endl;
    1299           0 :     return false;
    1300             :   }
    1301   118490988 :   if (!check_term_argument(a[1], check_rule_SortExpr<atermpp::aterm>))
    1302             :   {
    1303           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_SortExpr" << std::endl;
    1304           0 :     return false;
    1305             :   }
    1306             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    1307             : 
    1308             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    1309   118490988 :   return true;
    1310             : }
    1311             : 
    1312             : // ProcessAssignment(ProcVarId, DataVarIdInit*)
    1313             : template <typename Term>
    1314     2575392 : bool check_term_ProcessAssignment(const Term& t)
    1315             : {
    1316     2575392 :   utilities::mcrl2_unused(t);
    1317             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    1318             :   // check the type of the term
    1319     2575392 :   const atermpp::aterm& term(t);
    1320     2575392 :   if (!term.type_is_appl())
    1321             :   {
    1322           0 :     return false;
    1323             :   }
    1324     2575392 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    1325     2575392 :   if (a.function() != core::detail::function_symbols::ProcessAssignment)
    1326             :   {
    1327     1722688 :     return false;
    1328             :   }
    1329             : 
    1330             :   // check the children
    1331      852704 :   if (a.size() != 2)
    1332             :   {
    1333           0 :     return false;
    1334             :   }
    1335             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    1336      852704 :   if (!check_term_argument(a[0], check_rule_ProcVarId<atermpp::aterm>))
    1337             :   {
    1338           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_ProcVarId" << std::endl;
    1339           0 :     return false;
    1340             :   }
    1341      852704 :   if (!check_list_argument(a[1], check_rule_DataVarIdInit<atermpp::aterm>, 0))
    1342             :   {
    1343           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_DataVarIdInit" << std::endl;
    1344           0 :     return false;
    1345             :   }
    1346             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    1347             : 
    1348             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    1349      852704 :   return true;
    1350             : }
    1351             : 
    1352             : // Forall()
    1353             : template <typename Term>
    1354      159839 : bool check_term_Forall(const Term& t)
    1355             : {
    1356      159839 :   utilities::mcrl2_unused(t);
    1357             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    1358             :   // check the type of the term
    1359      159839 :   const atermpp::aterm& term(t);
    1360      159839 :   if (!term.type_is_appl())
    1361             :   {
    1362           0 :     return false;
    1363             :   }
    1364      159839 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    1365      159839 :   if (a.function() != core::detail::function_symbols::Forall)
    1366             :   {
    1367       95254 :     return false;
    1368             :   }
    1369             : 
    1370             :   // check the children
    1371       64585 :   if (a.size() != 0)
    1372             :   {
    1373           0 :     return false;
    1374             :   }
    1375             : 
    1376             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    1377       64585 :   return true;
    1378             : }
    1379             : 
    1380             : // CommExpr(MultActName, String)
    1381             : template <typename Term>
    1382       19436 : bool check_term_CommExpr(const Term& t)
    1383             : {
    1384       19436 :   utilities::mcrl2_unused(t);
    1385             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    1386             :   // check the type of the term
    1387       19436 :   const atermpp::aterm& term(t);
    1388       19436 :   if (!term.type_is_appl())
    1389             :   {
    1390           0 :     return false;
    1391             :   }
    1392       19436 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    1393       19436 :   if (a.function() != core::detail::function_symbols::CommExpr)
    1394             :   {
    1395           0 :     return false;
    1396             :   }
    1397             : 
    1398             :   // check the children
    1399       19436 :   if (a.size() != 2)
    1400             :   {
    1401           0 :     return false;
    1402             :   }
    1403             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    1404       19436 :   if (!check_term_argument(a[0], check_rule_MultActName<atermpp::aterm>))
    1405             :   {
    1406           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_MultActName" << std::endl;
    1407           0 :     return false;
    1408             :   }
    1409       19436 :   if (!check_term_argument(a[1], check_rule_String<atermpp::aterm>))
    1410             :   {
    1411           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_String" << std::endl;
    1412           0 :     return false;
    1413             :   }
    1414             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    1415             : 
    1416             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    1417       19436 :   return true;
    1418             : }
    1419             : 
    1420             : // StateNot(StateFrm)
    1421             : template <typename Term>
    1422       24836 : bool check_term_StateNot(const Term& t)
    1423             : {
    1424       24836 :   utilities::mcrl2_unused(t);
    1425             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    1426             :   // check the type of the term
    1427       24836 :   const atermpp::aterm& term(t);
    1428       24836 :   if (!term.type_is_appl())
    1429             :   {
    1430           0 :     return false;
    1431             :   }
    1432       24836 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    1433       24836 :   if (a.function() != core::detail::function_symbols::StateNot)
    1434             :   {
    1435       23563 :     return false;
    1436             :   }
    1437             : 
    1438             :   // check the children
    1439        1273 :   if (a.size() != 1)
    1440             :   {
    1441           0 :     return false;
    1442             :   }
    1443             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    1444        1273 :   if (!check_term_argument(a[0], check_rule_StateFrm<atermpp::aterm>))
    1445             :   {
    1446           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_StateFrm" << std::endl;
    1447           0 :     return false;
    1448             :   }
    1449             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    1450             : 
    1451             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    1452        1273 :   return true;
    1453             : }
    1454             : 
    1455             : // UntypedSetBagComp()
    1456             : template <typename Term>
    1457         108 : bool check_term_UntypedSetBagComp(const Term& t)
    1458             : {
    1459         108 :   utilities::mcrl2_unused(t);
    1460             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    1461             :   // check the type of the term
    1462         108 :   const atermpp::aterm& term(t);
    1463         108 :   if (!term.type_is_appl())
    1464             :   {
    1465           0 :     return false;
    1466             :   }
    1467         108 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    1468         108 :   if (a.function() != core::detail::function_symbols::UntypedSetBagComp)
    1469             :   {
    1470           0 :     return false;
    1471             :   }
    1472             : 
    1473             :   // check the children
    1474         108 :   if (a.size() != 0)
    1475             :   {
    1476           0 :     return false;
    1477             :   }
    1478             : 
    1479             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    1480         108 :   return true;
    1481             : }
    1482             : 
    1483             : // SortFSet()
    1484             : template <typename Term>
    1485     7007678 : bool check_term_SortFSet(const Term& t)
    1486             : {
    1487     7007678 :   utilities::mcrl2_unused(t);
    1488             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    1489             :   // check the type of the term
    1490     7007678 :   const atermpp::aterm& term(t);
    1491     7007678 :   if (!term.type_is_appl())
    1492             :   {
    1493           0 :     return false;
    1494             :   }
    1495     7007678 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    1496     7007678 :   if (a.function() != core::detail::function_symbols::SortFSet)
    1497             :   {
    1498     1565853 :     return false;
    1499             :   }
    1500             : 
    1501             :   // check the children
    1502     5441825 :   if (a.size() != 0)
    1503             :   {
    1504           0 :     return false;
    1505             :   }
    1506             : 
    1507             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    1508     5441825 :   return true;
    1509             : }
    1510             : 
    1511             : // StateImp(StateFrm, StateFrm)
    1512             : template <typename Term>
    1513       19605 : bool check_term_StateImp(const Term& t)
    1514             : {
    1515       19605 :   utilities::mcrl2_unused(t);
    1516             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    1517             :   // check the type of the term
    1518       19605 :   const atermpp::aterm& term(t);
    1519       19605 :   if (!term.type_is_appl())
    1520             :   {
    1521           0 :     return false;
    1522             :   }
    1523       19605 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    1524       19605 :   if (a.function() != core::detail::function_symbols::StateImp)
    1525             :   {
    1526       18343 :     return false;
    1527             :   }
    1528             : 
    1529             :   // check the children
    1530        1262 :   if (a.size() != 2)
    1531             :   {
    1532           0 :     return false;
    1533             :   }
    1534             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    1535        1262 :   if (!check_term_argument(a[0], check_rule_StateFrm<atermpp::aterm>))
    1536             :   {
    1537           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_StateFrm" << std::endl;
    1538           0 :     return false;
    1539             :   }
    1540        1262 :   if (!check_term_argument(a[1], check_rule_StateFrm<atermpp::aterm>))
    1541             :   {
    1542           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_StateFrm" << std::endl;
    1543           0 :     return false;
    1544             :   }
    1545             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    1546             : 
    1547             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    1548        1262 :   return true;
    1549             : }
    1550             : 
    1551             : // PBESExists(DataVarId+, PBExpr)
    1552             : template <typename Term>
    1553       86867 : bool check_term_PBESExists(const Term& t)
    1554             : {
    1555       86867 :   utilities::mcrl2_unused(t);
    1556             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    1557             :   // check the type of the term
    1558       86867 :   const atermpp::aterm& term(t);
    1559       86867 :   if (!term.type_is_appl())
    1560             :   {
    1561           0 :     return false;
    1562             :   }
    1563       86867 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    1564       86867 :   if (a.function() != core::detail::function_symbols::PBESExists)
    1565             :   {
    1566       80499 :     return false;
    1567             :   }
    1568             : 
    1569             :   // check the children
    1570        6368 :   if (a.size() != 2)
    1571             :   {
    1572           0 :     return false;
    1573             :   }
    1574             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    1575        6368 :   if (!check_list_argument(a[0], check_rule_DataVarId<atermpp::aterm>, 1))
    1576             :   {
    1577           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_DataVarId" << std::endl;
    1578           0 :     return false;
    1579             :   }
    1580        6368 :   if (!check_term_argument(a[1], check_rule_PBExpr<atermpp::aterm>))
    1581             :   {
    1582           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_PBExpr" << std::endl;
    1583           0 :     return false;
    1584             :   }
    1585             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    1586             : 
    1587             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    1588        6368 :   return true;
    1589             : }
    1590             : 
    1591             : // PBESImp(PBExpr, PBExpr)
    1592             : template <typename Term>
    1593       99971 : bool check_term_PBESImp(const Term& t)
    1594             : {
    1595       99971 :   utilities::mcrl2_unused(t);
    1596             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    1597             :   // check the type of the term
    1598       99971 :   const atermpp::aterm& term(t);
    1599       99971 :   if (!term.type_is_appl())
    1600             :   {
    1601           0 :     return false;
    1602             :   }
    1603       99971 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    1604       99971 :   if (a.function() != core::detail::function_symbols::PBESImp)
    1605             :   {
    1606       93547 :     return false;
    1607             :   }
    1608             : 
    1609             :   // check the children
    1610        6424 :   if (a.size() != 2)
    1611             :   {
    1612           0 :     return false;
    1613             :   }
    1614             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    1615        6424 :   if (!check_term_argument(a[0], check_rule_PBExpr<atermpp::aterm>))
    1616             :   {
    1617           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_PBExpr" << std::endl;
    1618           0 :     return false;
    1619             :   }
    1620        6424 :   if (!check_term_argument(a[1], check_rule_PBExpr<atermpp::aterm>))
    1621             :   {
    1622           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_PBExpr" << std::endl;
    1623           0 :     return false;
    1624             :   }
    1625             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    1626             : 
    1627             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    1628        6424 :   return true;
    1629             : }
    1630             : 
    1631             : // Binder(BindingOperator, DataVarId+, DataExpr)
    1632             : template <typename Term>
    1633      605889 : bool check_term_Binder(const Term& t)
    1634             : {
    1635      605889 :   utilities::mcrl2_unused(t);
    1636             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    1637             :   // check the type of the term
    1638      605889 :   const atermpp::aterm& term(t);
    1639      605889 :   if (!term.type_is_appl())
    1640             :   {
    1641           0 :     return false;
    1642             :   }
    1643      605889 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    1644      605889 :   if (a.function() != core::detail::function_symbols::Binder)
    1645             :   {
    1646      488051 :     return false;
    1647             :   }
    1648             : 
    1649             :   // check the children
    1650      117838 :   if (a.size() != 3)
    1651             :   {
    1652           0 :     return false;
    1653             :   }
    1654             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    1655      117838 :   if (!check_term_argument(a[0], check_rule_BindingOperator<atermpp::aterm>))
    1656             :   {
    1657           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_BindingOperator" << std::endl;
    1658           0 :     return false;
    1659             :   }
    1660      117838 :   if (!check_list_argument(a[1], check_rule_DataVarId<atermpp::aterm>, 1))
    1661             :   {
    1662           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_DataVarId" << std::endl;
    1663           0 :     return false;
    1664             :   }
    1665      117838 :   if (!check_term_argument(a[2], check_rule_DataExpr<atermpp::aterm>))
    1666             :   {
    1667           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_DataExpr" << std::endl;
    1668           0 :     return false;
    1669             :   }
    1670             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    1671             : 
    1672             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    1673      117838 :   return true;
    1674             : }
    1675             : 
    1676             : // StochasticOperator(DataVarId+, DataExpr, ProcExpr)
    1677             : template <typename Term>
    1678       80354 : bool check_term_StochasticOperator(const Term& t)
    1679             : {
    1680       80354 :   utilities::mcrl2_unused(t);
    1681             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    1682             :   // check the type of the term
    1683       80354 :   const atermpp::aterm& term(t);
    1684       80354 :   if (!term.type_is_appl())
    1685             :   {
    1686           0 :     return false;
    1687             :   }
    1688       80354 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    1689       80354 :   if (a.function() != core::detail::function_symbols::StochasticOperator)
    1690             :   {
    1691       41992 :     return false;
    1692             :   }
    1693             : 
    1694             :   // check the children
    1695       38362 :   if (a.size() != 3)
    1696             :   {
    1697           0 :     return false;
    1698             :   }
    1699             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    1700       38362 :   if (!check_list_argument(a[0], check_rule_DataVarId<atermpp::aterm>, 1))
    1701             :   {
    1702           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_DataVarId" << std::endl;
    1703           0 :     return false;
    1704             :   }
    1705       38362 :   if (!check_term_argument(a[1], check_rule_DataExpr<atermpp::aterm>))
    1706             :   {
    1707           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_DataExpr" << std::endl;
    1708           0 :     return false;
    1709             :   }
    1710       38362 :   if (!check_term_argument(a[2], check_rule_ProcExpr<atermpp::aterm>))
    1711             :   {
    1712           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_ProcExpr" << std::endl;
    1713           0 :     return false;
    1714             :   }
    1715             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    1716             : 
    1717             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    1718       38362 :   return true;
    1719             : }
    1720             : 
    1721             : // SortRef(SortId, SortExpr)
    1722             : template <typename Term>
    1723         760 : bool check_term_SortRef(const Term& t)
    1724             : {
    1725         760 :   utilities::mcrl2_unused(t);
    1726             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    1727             :   // check the type of the term
    1728         760 :   const atermpp::aterm& term(t);
    1729         760 :   if (!term.type_is_appl())
    1730             :   {
    1731           0 :     return false;
    1732             :   }
    1733         760 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    1734         760 :   if (a.function() != core::detail::function_symbols::SortRef)
    1735             :   {
    1736           0 :     return false;
    1737             :   }
    1738             : 
    1739             :   // check the children
    1740         760 :   if (a.size() != 2)
    1741             :   {
    1742           0 :     return false;
    1743             :   }
    1744             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    1745         760 :   if (!check_term_argument(a[0], check_rule_SortId<atermpp::aterm>))
    1746             :   {
    1747           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_SortId" << std::endl;
    1748           0 :     return false;
    1749             :   }
    1750         760 :   if (!check_term_argument(a[1], check_rule_SortExpr<atermpp::aterm>))
    1751             :   {
    1752           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_SortExpr" << std::endl;
    1753           0 :     return false;
    1754             :   }
    1755             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    1756             : 
    1757             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    1758         760 :   return true;
    1759             : }
    1760             : 
    1761             : // ProcEqnSpec(ProcEqn*)
    1762             : template <typename Term>
    1763           0 : bool check_term_ProcEqnSpec(const Term& t)
    1764             : {
    1765           0 :   utilities::mcrl2_unused(t);
    1766             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    1767             :   // check the type of the term
    1768           0 :   const atermpp::aterm& term(t);
    1769           0 :   if (!term.type_is_appl())
    1770             :   {
    1771           0 :     return false;
    1772             :   }
    1773           0 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    1774           0 :   if (a.function() != core::detail::function_symbols::ProcEqnSpec)
    1775             :   {
    1776           0 :     return false;
    1777             :   }
    1778             : 
    1779             :   // check the children
    1780           0 :   if (a.size() != 1)
    1781             :   {
    1782           0 :     return false;
    1783             :   }
    1784             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    1785           0 :   if (!check_list_argument(a[0], check_rule_ProcEqn<atermpp::aterm>, 0))
    1786             :   {
    1787           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_ProcEqn" << std::endl;
    1788           0 :     return false;
    1789             :   }
    1790             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    1791             : 
    1792             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    1793           0 :   return true;
    1794             : }
    1795             : 
    1796             : // StateForall(DataVarId+, StateFrm)
    1797             : template <typename Term>
    1798       18374 : bool check_term_StateForall(const Term& t)
    1799             : {
    1800       18374 :   utilities::mcrl2_unused(t);
    1801             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    1802             :   // check the type of the term
    1803       18374 :   const atermpp::aterm& term(t);
    1804       18374 :   if (!term.type_is_appl())
    1805             :   {
    1806           0 :     return false;
    1807             :   }
    1808       18374 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    1809       18374 :   if (a.function() != core::detail::function_symbols::StateForall)
    1810             :   {
    1811       17974 :     return false;
    1812             :   }
    1813             : 
    1814             :   // check the children
    1815         400 :   if (a.size() != 2)
    1816             :   {
    1817           0 :     return false;
    1818             :   }
    1819             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    1820         400 :   if (!check_list_argument(a[0], check_rule_DataVarId<atermpp::aterm>, 1))
    1821             :   {
    1822           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_DataVarId" << std::endl;
    1823           0 :     return false;
    1824             :   }
    1825         400 :   if (!check_term_argument(a[1], check_rule_StateFrm<atermpp::aterm>))
    1826             :   {
    1827           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_StateFrm" << std::endl;
    1828           0 :     return false;
    1829             :   }
    1830             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    1831             : 
    1832             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    1833         400 :   return true;
    1834             : }
    1835             : 
    1836             : // BooleanImp(BooleanExpression, BooleanExpression)
    1837             : template <typename Term>
    1838           6 : bool check_term_BooleanImp(const Term& t)
    1839             : {
    1840           6 :   utilities::mcrl2_unused(t);
    1841             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    1842             :   // check the type of the term
    1843           6 :   const atermpp::aterm& term(t);
    1844           6 :   if (!term.type_is_appl())
    1845             :   {
    1846           0 :     return false;
    1847             :   }
    1848           6 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    1849           6 :   if (a.function() != core::detail::function_symbols::BooleanImp)
    1850             :   {
    1851           0 :     return false;
    1852             :   }
    1853             : 
    1854             :   // check the children
    1855           6 :   if (a.size() != 2)
    1856             :   {
    1857           0 :     return false;
    1858             :   }
    1859             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    1860           6 :   if (!check_term_argument(a[0], check_rule_BooleanExpression<atermpp::aterm>))
    1861             :   {
    1862           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_BooleanExpression" << std::endl;
    1863           0 :     return false;
    1864             :   }
    1865           6 :   if (!check_term_argument(a[1], check_rule_BooleanExpression<atermpp::aterm>))
    1866             :   {
    1867           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_BooleanExpression" << std::endl;
    1868           0 :     return false;
    1869             :   }
    1870             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    1871             : 
    1872             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    1873           6 :   return true;
    1874             : }
    1875             : 
    1876             : // SortId(String)
    1877             : template <typename Term>
    1878   500574913 : bool check_term_SortId(const Term& t)
    1879             : {
    1880   500574913 :   utilities::mcrl2_unused(t);
    1881             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    1882             :   // check the type of the term
    1883   500574913 :   const atermpp::aterm& term(t);
    1884   500574913 :   if (!term.type_is_appl())
    1885             :   {
    1886           0 :     return false;
    1887             :   }
    1888   500574913 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    1889   500574913 :   if (a.function() != core::detail::function_symbols::SortId)
    1890             :   {
    1891   134861255 :     return false;
    1892             :   }
    1893             : 
    1894             :   // check the children
    1895   365713658 :   if (a.size() != 1)
    1896             :   {
    1897           0 :     return false;
    1898             :   }
    1899             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    1900   365713658 :   if (!check_term_argument(a[0], check_rule_String<atermpp::aterm>))
    1901             :   {
    1902           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_String" << std::endl;
    1903           0 :     return false;
    1904             :   }
    1905             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    1906             : 
    1907             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    1908   365713658 :   return true;
    1909             : }
    1910             : 
    1911             : // StateNu(String, DataVarIdInit*, StateFrm)
    1912             : template <typename Term>
    1913        4783 : bool check_term_StateNu(const Term& t)
    1914             : {
    1915        4783 :   utilities::mcrl2_unused(t);
    1916             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    1917             :   // check the type of the term
    1918        4783 :   const atermpp::aterm& term(t);
    1919        4783 :   if (!term.type_is_appl())
    1920             :   {
    1921           0 :     return false;
    1922             :   }
    1923        4783 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    1924        4783 :   if (a.function() != core::detail::function_symbols::StateNu)
    1925             :   {
    1926        3331 :     return false;
    1927             :   }
    1928             : 
    1929             :   // check the children
    1930        1452 :   if (a.size() != 3)
    1931             :   {
    1932           0 :     return false;
    1933             :   }
    1934             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    1935        1452 :   if (!check_term_argument(a[0], check_rule_String<atermpp::aterm>))
    1936             :   {
    1937           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_String" << std::endl;
    1938           0 :     return false;
    1939             :   }
    1940        1452 :   if (!check_list_argument(a[1], check_rule_DataVarIdInit<atermpp::aterm>, 0))
    1941             :   {
    1942           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_DataVarIdInit" << std::endl;
    1943           0 :     return false;
    1944             :   }
    1945        1452 :   if (!check_term_argument(a[2], check_rule_StateFrm<atermpp::aterm>))
    1946             :   {
    1947           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_StateFrm" << std::endl;
    1948           0 :     return false;
    1949             :   }
    1950             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    1951             : 
    1952             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    1953        1452 :   return true;
    1954             : }
    1955             : 
    1956             : // RegNil()
    1957             : template <typename Term>
    1958         379 : bool check_term_RegNil(const Term& t)
    1959             : {
    1960         379 :   utilities::mcrl2_unused(t);
    1961             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    1962             :   // check the type of the term
    1963         379 :   const atermpp::aterm& term(t);
    1964         379 :   if (!term.type_is_appl())
    1965             :   {
    1966           0 :     return false;
    1967             :   }
    1968         379 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    1969         379 :   if (a.function() != core::detail::function_symbols::RegNil)
    1970             :   {
    1971         379 :     return false;
    1972             :   }
    1973             : 
    1974             :   // check the children
    1975           0 :   if (a.size() != 0)
    1976             :   {
    1977           0 :     return false;
    1978             :   }
    1979             : 
    1980             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    1981           0 :   return true;
    1982             : }
    1983             : 
    1984             : // DataSpec(SortSpec, ConsSpec, MapSpec, DataEqnSpec)
    1985             : template <typename Term>
    1986         296 : bool check_term_DataSpec(const Term& t)
    1987             : {
    1988         296 :   utilities::mcrl2_unused(t);
    1989             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    1990             :   // check the type of the term
    1991         296 :   const atermpp::aterm& term(t);
    1992         296 :   if (!term.type_is_appl())
    1993             :   {
    1994           0 :     return false;
    1995             :   }
    1996         296 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    1997         296 :   if (a.function() != core::detail::function_symbols::DataSpec)
    1998             :   {
    1999           0 :     return false;
    2000             :   }
    2001             : 
    2002             :   // check the children
    2003         296 :   if (a.size() != 4)
    2004             :   {
    2005           0 :     return false;
    2006             :   }
    2007             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    2008         296 :   if (!check_term_argument(a[0], check_rule_SortSpec<atermpp::aterm>))
    2009             :   {
    2010           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_SortSpec" << std::endl;
    2011           0 :     return false;
    2012             :   }
    2013         296 :   if (!check_term_argument(a[1], check_rule_ConsSpec<atermpp::aterm>))
    2014             :   {
    2015           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_ConsSpec" << std::endl;
    2016           0 :     return false;
    2017             :   }
    2018         296 :   if (!check_term_argument(a[2], check_rule_MapSpec<atermpp::aterm>))
    2019             :   {
    2020           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_MapSpec" << std::endl;
    2021           0 :     return false;
    2022             :   }
    2023         296 :   if (!check_term_argument(a[3], check_rule_DataEqnSpec<atermpp::aterm>))
    2024             :   {
    2025           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_DataEqnSpec" << std::endl;
    2026           0 :     return false;
    2027             :   }
    2028             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    2029             : 
    2030             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    2031         296 :   return true;
    2032             : }
    2033             : 
    2034             : // Tau()
    2035             : template <typename Term>
    2036     1678175 : bool check_term_Tau(const Term& t)
    2037             : {
    2038     1678175 :   utilities::mcrl2_unused(t);
    2039             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    2040             :   // check the type of the term
    2041     1678175 :   const atermpp::aterm& term(t);
    2042     1678175 :   if (!term.type_is_appl())
    2043             :   {
    2044           0 :     return false;
    2045             :   }
    2046     1678175 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    2047     1678175 :   if (a.function() != core::detail::function_symbols::Tau)
    2048             :   {
    2049     1661776 :     return false;
    2050             :   }
    2051             : 
    2052             :   // check the children
    2053       16399 :   if (a.size() != 0)
    2054             :   {
    2055           0 :     return false;
    2056             :   }
    2057             : 
    2058             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    2059       16399 :   return true;
    2060             : }
    2061             : 
    2062             : // StateYaledTimed(DataExpr)
    2063             : template <typename Term>
    2064        9874 : bool check_term_StateYaledTimed(const Term& t)
    2065             : {
    2066        9874 :   utilities::mcrl2_unused(t);
    2067             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    2068             :   // check the type of the term
    2069        9874 :   const atermpp::aterm& term(t);
    2070        9874 :   if (!term.type_is_appl())
    2071             :   {
    2072           0 :     return false;
    2073             :   }
    2074        9874 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    2075        9874 :   if (a.function() != core::detail::function_symbols::StateYaledTimed)
    2076             :   {
    2077        9862 :     return false;
    2078             :   }
    2079             : 
    2080             :   // check the children
    2081          12 :   if (a.size() != 1)
    2082             :   {
    2083           0 :     return false;
    2084             :   }
    2085             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    2086          12 :   if (!check_term_argument(a[0], check_rule_DataExpr<atermpp::aterm>))
    2087             :   {
    2088           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_DataExpr" << std::endl;
    2089           0 :     return false;
    2090             :   }
    2091             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    2092             : 
    2093             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    2094          12 :   return true;
    2095             : }
    2096             : 
    2097             : // SortCons(SortConsType, SortExpr)
    2098             : template <typename Term>
    2099   137801723 : bool check_term_SortCons(const Term& t)
    2100             : {
    2101   137801723 :   utilities::mcrl2_unused(t);
    2102             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    2103             :   // check the type of the term
    2104   137801723 :   const atermpp::aterm& term(t);
    2105   137801723 :   if (!term.type_is_appl())
    2106             :   {
    2107           0 :     return false;
    2108             :   }
    2109   137801723 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    2110   137801723 :   if (a.function() != core::detail::function_symbols::SortCons)
    2111             :   {
    2112   114823187 :     return false;
    2113             :   }
    2114             : 
    2115             :   // check the children
    2116    22978536 :   if (a.size() != 2)
    2117             :   {
    2118           0 :     return false;
    2119             :   }
    2120             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    2121    22978536 :   if (!check_term_argument(a[0], check_rule_SortConsType<atermpp::aterm>))
    2122             :   {
    2123           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_SortConsType" << std::endl;
    2124           0 :     return false;
    2125             :   }
    2126    22978536 :   if (!check_term_argument(a[1], check_rule_SortExpr<atermpp::aterm>))
    2127             :   {
    2128           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_SortExpr" << std::endl;
    2129           0 :     return false;
    2130             :   }
    2131             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    2132             : 
    2133             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    2134    22978536 :   return true;
    2135             : }
    2136             : 
    2137             : // DataEqnSpec(DataEqn*)
    2138             : template <typename Term>
    2139         296 : bool check_term_DataEqnSpec(const Term& t)
    2140             : {
    2141         296 :   utilities::mcrl2_unused(t);
    2142             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    2143             :   // check the type of the term
    2144         296 :   const atermpp::aterm& term(t);
    2145         296 :   if (!term.type_is_appl())
    2146             :   {
    2147           0 :     return false;
    2148             :   }
    2149         296 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    2150         296 :   if (a.function() != core::detail::function_symbols::DataEqnSpec)
    2151             :   {
    2152           0 :     return false;
    2153             :   }
    2154             : 
    2155             :   // check the children
    2156         296 :   if (a.size() != 1)
    2157             :   {
    2158           0 :     return false;
    2159             :   }
    2160             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    2161         296 :   if (!check_list_argument(a[0], check_rule_DataEqn<atermpp::aterm>, 0))
    2162             :   {
    2163           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_DataEqn" << std::endl;
    2164           0 :     return false;
    2165             :   }
    2166             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    2167             : 
    2168             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    2169         296 :   return true;
    2170             : }
    2171             : 
    2172             : // LinearProcessSummand(DataVarId*, DataExpr, MultActOrDelta, DataExpr, DataVarIdInit*, Distribution)
    2173             : template <typename Term>
    2174          75 : bool check_term_LinearProcessSummand(const Term& t)
    2175             : {
    2176          75 :   utilities::mcrl2_unused(t);
    2177             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    2178             :   // check the type of the term
    2179          75 :   const atermpp::aterm& term(t);
    2180          75 :   if (!term.type_is_appl())
    2181             :   {
    2182           0 :     return false;
    2183             :   }
    2184          75 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    2185          75 :   if (a.function() != core::detail::function_symbols::LinearProcessSummand)
    2186             :   {
    2187           0 :     return false;
    2188             :   }
    2189             : 
    2190             :   // check the children
    2191          75 :   if (a.size() != 6)
    2192             :   {
    2193           0 :     return false;
    2194             :   }
    2195             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    2196          75 :   if (!check_list_argument(a[0], check_rule_DataVarId<atermpp::aterm>, 0))
    2197             :   {
    2198           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_DataVarId" << std::endl;
    2199           0 :     return false;
    2200             :   }
    2201          75 :   if (!check_term_argument(a[1], check_rule_DataExpr<atermpp::aterm>))
    2202             :   {
    2203           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_DataExpr" << std::endl;
    2204           0 :     return false;
    2205             :   }
    2206          75 :   if (!check_term_argument(a[2], check_rule_MultActOrDelta<atermpp::aterm>))
    2207             :   {
    2208           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_MultActOrDelta" << std::endl;
    2209           0 :     return false;
    2210             :   }
    2211          75 :   if (!check_term_argument(a[3], check_rule_DataExpr<atermpp::aterm>))
    2212             :   {
    2213           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_DataExpr" << std::endl;
    2214           0 :     return false;
    2215             :   }
    2216          75 :   if (!check_list_argument(a[4], check_rule_DataVarIdInit<atermpp::aterm>, 0))
    2217             :   {
    2218           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_DataVarIdInit" << std::endl;
    2219           0 :     return false;
    2220             :   }
    2221          75 :   if (!check_term_argument(a[5], check_rule_Distribution<atermpp::aterm>))
    2222             :   {
    2223           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_Distribution" << std::endl;
    2224           0 :     return false;
    2225             :   }
    2226             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    2227             : 
    2228             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    2229          75 :   return true;
    2230             : }
    2231             : 
    2232             : // SortSpec(SortDecl*)
    2233             : template <typename Term>
    2234         296 : bool check_term_SortSpec(const Term& t)
    2235             : {
    2236         296 :   utilities::mcrl2_unused(t);
    2237             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    2238             :   // check the type of the term
    2239         296 :   const atermpp::aterm& term(t);
    2240         296 :   if (!term.type_is_appl())
    2241             :   {
    2242           0 :     return false;
    2243             :   }
    2244         296 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    2245         296 :   if (a.function() != core::detail::function_symbols::SortSpec)
    2246             :   {
    2247           0 :     return false;
    2248             :   }
    2249             : 
    2250             :   // check the children
    2251         296 :   if (a.size() != 1)
    2252             :   {
    2253           0 :     return false;
    2254             :   }
    2255             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    2256         296 :   if (!check_list_argument(a[0], check_rule_SortDecl<atermpp::aterm>, 0))
    2257             :   {
    2258           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_SortDecl" << std::endl;
    2259           0 :     return false;
    2260             :   }
    2261             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    2262             : 
    2263             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    2264         296 :   return true;
    2265             : }
    2266             : 
    2267             : // ActionRenameRules(ActionRenameRule*)
    2268             : template <typename Term>
    2269             : bool check_term_ActionRenameRules(const Term& t)
    2270             : {
    2271             :   utilities::mcrl2_unused(t);
    2272             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    2273             :   // check the type of the term
    2274             :   const atermpp::aterm& term(t);
    2275             :   if (!term.type_is_appl())
    2276             :   {
    2277             :     return false;
    2278             :   }
    2279             :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    2280             :   if (a.function() != core::detail::function_symbols::ActionRenameRules)
    2281             :   {
    2282             :     return false;
    2283             :   }
    2284             : 
    2285             :   // check the children
    2286             :   if (a.size() != 1)
    2287             :   {
    2288             :     return false;
    2289             :   }
    2290             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    2291             :   if (!check_list_argument(a[0], check_rule_ActionRenameRule<atermpp::aterm>, 0))
    2292             :   {
    2293             :     mCRL2log(log::debug, "soundness_checks") << "check_rule_ActionRenameRule" << std::endl;
    2294             :     return false;
    2295             :   }
    2296             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    2297             : 
    2298             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    2299             :   return true;
    2300             : }
    2301             : 
    2302             : // ActAnd(ActFrm, ActFrm)
    2303             : template <typename Term>
    2304        8828 : bool check_term_ActAnd(const Term& t)
    2305             : {
    2306        8828 :   utilities::mcrl2_unused(t);
    2307             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    2308             :   // check the type of the term
    2309        8828 :   const atermpp::aterm& term(t);
    2310        8828 :   if (!term.type_is_appl())
    2311             :   {
    2312           0 :     return false;
    2313             :   }
    2314        8828 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    2315        8828 :   if (a.function() != core::detail::function_symbols::ActAnd)
    2316             :   {
    2317        8485 :     return false;
    2318             :   }
    2319             : 
    2320             :   // check the children
    2321         343 :   if (a.size() != 2)
    2322             :   {
    2323           0 :     return false;
    2324             :   }
    2325             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    2326         343 :   if (!check_term_argument(a[0], check_rule_ActFrm<atermpp::aterm>))
    2327             :   {
    2328           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_ActFrm" << std::endl;
    2329           0 :     return false;
    2330             :   }
    2331         343 :   if (!check_term_argument(a[1], check_rule_ActFrm<atermpp::aterm>))
    2332             :   {
    2333           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_ActFrm" << std::endl;
    2334           0 :     return false;
    2335             :   }
    2336             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    2337             : 
    2338             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    2339         343 :   return true;
    2340             : }
    2341             : 
    2342             : // BooleanEquation(FixPoint, BooleanVariable, BooleanExpression)
    2343             : template <typename Term>
    2344           4 : bool check_term_BooleanEquation(const Term& t)
    2345             : {
    2346           4 :   utilities::mcrl2_unused(t);
    2347             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    2348             :   // check the type of the term
    2349           4 :   const atermpp::aterm& term(t);
    2350           4 :   if (!term.type_is_appl())
    2351             :   {
    2352           0 :     return false;
    2353             :   }
    2354           4 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    2355           4 :   if (a.function() != core::detail::function_symbols::BooleanEquation)
    2356             :   {
    2357           0 :     return false;
    2358             :   }
    2359             : 
    2360             :   // check the children
    2361           4 :   if (a.size() != 3)
    2362             :   {
    2363           0 :     return false;
    2364             :   }
    2365             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    2366           4 :   if (!check_term_argument(a[0], check_rule_FixPoint<atermpp::aterm>))
    2367             :   {
    2368           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_FixPoint" << std::endl;
    2369           0 :     return false;
    2370             :   }
    2371           4 :   if (!check_term_argument(a[1], check_rule_BooleanVariable<atermpp::aterm>))
    2372             :   {
    2373           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_BooleanVariable" << std::endl;
    2374           0 :     return false;
    2375             :   }
    2376           4 :   if (!check_term_argument(a[2], check_rule_BooleanExpression<atermpp::aterm>))
    2377             :   {
    2378           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_BooleanExpression" << std::endl;
    2379           0 :     return false;
    2380             :   }
    2381             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    2382             : 
    2383             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    2384           4 :   return true;
    2385             : }
    2386             : 
    2387             : // ConsSpec(OpId*)
    2388             : template <typename Term>
    2389         296 : bool check_term_ConsSpec(const Term& t)
    2390             : {
    2391         296 :   utilities::mcrl2_unused(t);
    2392             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    2393             :   // check the type of the term
    2394         296 :   const atermpp::aterm& term(t);
    2395         296 :   if (!term.type_is_appl())
    2396             :   {
    2397           0 :     return false;
    2398             :   }
    2399         296 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    2400         296 :   if (a.function() != core::detail::function_symbols::ConsSpec)
    2401             :   {
    2402           0 :     return false;
    2403             :   }
    2404             : 
    2405             :   // check the children
    2406         296 :   if (a.size() != 1)
    2407             :   {
    2408           0 :     return false;
    2409             :   }
    2410             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    2411         296 :   if (!check_list_argument(a[0], check_rule_OpId<atermpp::aterm>, 0))
    2412             :   {
    2413           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_OpId" << std::endl;
    2414           0 :     return false;
    2415             :   }
    2416             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    2417             : 
    2418             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    2419         296 :   return true;
    2420             : }
    2421             : 
    2422             : // SortList()
    2423             : template <typename Term>
    2424    23885762 : bool check_term_SortList(const Term& t)
    2425             : {
    2426    23885762 :   utilities::mcrl2_unused(t);
    2427             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    2428             :   // check the type of the term
    2429    23885762 :   const atermpp::aterm& term(t);
    2430    23885762 :   if (!term.type_is_appl())
    2431             :   {
    2432           0 :     return false;
    2433             :   }
    2434    23885762 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    2435    23885762 :   if (a.function() != core::detail::function_symbols::SortList)
    2436             :   {
    2437    10542028 :     return false;
    2438             :   }
    2439             : 
    2440             :   // check the children
    2441    13343734 :   if (a.size() != 0)
    2442             :   {
    2443           0 :     return false;
    2444             :   }
    2445             : 
    2446             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    2447    13343734 :   return true;
    2448             : }
    2449             : 
    2450             : // Sum(DataVarId+, ProcExpr)
    2451             : template <typename Term>
    2452     1677431 : bool check_term_Sum(const Term& t)
    2453             : {
    2454     1677431 :   utilities::mcrl2_unused(t);
    2455             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    2456             :   // check the type of the term
    2457     1677431 :   const atermpp::aterm& term(t);
    2458     1677431 :   if (!term.type_is_appl())
    2459             :   {
    2460           0 :     return false;
    2461             :   }
    2462     1677431 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    2463     1677431 :   if (a.function() != core::detail::function_symbols::Sum)
    2464             :   {
    2465     1579418 :     return false;
    2466             :   }
    2467             : 
    2468             :   // check the children
    2469       98013 :   if (a.size() != 2)
    2470             :   {
    2471           0 :     return false;
    2472             :   }
    2473             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    2474       98013 :   if (!check_list_argument(a[0], check_rule_DataVarId<atermpp::aterm>, 1))
    2475             :   {
    2476           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_DataVarId" << std::endl;
    2477           0 :     return false;
    2478             :   }
    2479       98013 :   if (!check_term_argument(a[1], check_rule_ProcExpr<atermpp::aterm>))
    2480             :   {
    2481           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_ProcExpr" << std::endl;
    2482           0 :     return false;
    2483             :   }
    2484             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    2485             : 
    2486             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    2487       98013 :   return true;
    2488             : }
    2489             : 
    2490             : // DataVarId(String, SortExpr, Number)
    2491             : template <typename Term>
    2492   167818905 : bool check_term_DataVarId(const Term& t)
    2493             : {
    2494   167818905 :   utilities::mcrl2_unused(t);
    2495             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    2496             :   // check the type of the term
    2497   167818905 :   const atermpp::aterm& term(t);
    2498   167818905 :   if (!term.type_is_appl())
    2499             :   {
    2500           0 :     return false;
    2501             :   }
    2502   167818905 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    2503   167818905 :   if (a.function() != core::detail::function_symbols::DataVarId)
    2504             :   {
    2505   124862397 :     return false;
    2506             :   }
    2507             : 
    2508             :   // check the children
    2509    42956508 :   if (a.size() != 3)
    2510             :   {
    2511           0 :     return false;
    2512             :   }
    2513             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    2514    42956508 :   if (!check_term_argument(a[0], check_rule_String<atermpp::aterm>))
    2515             :   {
    2516           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_String" << std::endl;
    2517           0 :     return false;
    2518             :   }
    2519    42956508 :   if (!check_term_argument(a[1], check_rule_SortExpr<atermpp::aterm>))
    2520             :   {
    2521           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_SortExpr" << std::endl;
    2522           0 :     return false;
    2523             :   }
    2524    42956508 :   if (!check_term_argument(a[2], check_rule_Number<atermpp::aterm>))
    2525             :   {
    2526           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_Number" << std::endl;
    2527           0 :     return false;
    2528             :   }
    2529             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    2530             : 
    2531             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    2532    42956508 :   return true;
    2533             : }
    2534             : 
    2535             : // ProcVarId(String, DataVarId*, Number)
    2536             : template <typename Term>
    2537      951722 : bool check_term_ProcVarId(const Term& t)
    2538             : {
    2539      951722 :   utilities::mcrl2_unused(t);
    2540             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    2541             :   // check the type of the term
    2542      951722 :   const atermpp::aterm& term(t);
    2543      951722 :   if (!term.type_is_appl())
    2544             :   {
    2545           0 :     return false;
    2546             :   }
    2547      951722 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    2548      951722 :   if (a.function() != core::detail::function_symbols::ProcVarId)
    2549             :   {
    2550           0 :     return false;
    2551             :   }
    2552             : 
    2553             :   // check the children
    2554      951722 :   if (a.size() != 3)
    2555             :   {
    2556           0 :     return false;
    2557             :   }
    2558             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    2559      951722 :   if (!check_term_argument(a[0], check_rule_String<atermpp::aterm>))
    2560             :   {
    2561           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_String" << std::endl;
    2562           0 :     return false;
    2563             :   }
    2564      951722 :   if (!check_list_argument(a[1], check_rule_DataVarId<atermpp::aterm>, 0))
    2565             :   {
    2566           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_DataVarId" << std::endl;
    2567           0 :     return false;
    2568             :   }
    2569      951722 :   if (!check_term_argument(a[2], check_rule_Number<atermpp::aterm>))
    2570             :   {
    2571           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_Number" << std::endl;
    2572           0 :     return false;
    2573             :   }
    2574             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    2575             : 
    2576             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    2577      951722 :   return true;
    2578             : }
    2579             : 
    2580             : // ProcessInit(ProcExpr)
    2581             : template <typename Term>
    2582           0 : bool check_term_ProcessInit(const Term& t)
    2583             : {
    2584           0 :   utilities::mcrl2_unused(t);
    2585             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    2586             :   // check the type of the term
    2587           0 :   const atermpp::aterm& term(t);
    2588           0 :   if (!term.type_is_appl())
    2589             :   {
    2590           0 :     return false;
    2591             :   }
    2592           0 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    2593           0 :   if (a.function() != core::detail::function_symbols::ProcessInit)
    2594             :   {
    2595           0 :     return false;
    2596             :   }
    2597             : 
    2598             :   // check the children
    2599           0 :   if (a.size() != 1)
    2600             :   {
    2601           0 :     return false;
    2602             :   }
    2603             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    2604           0 :   if (!check_term_argument(a[0], check_rule_ProcExpr<atermpp::aterm>))
    2605             :   {
    2606           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_ProcExpr" << std::endl;
    2607           0 :     return false;
    2608             :   }
    2609             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    2610             : 
    2611             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    2612           0 :   return true;
    2613             : }
    2614             : 
    2615             : // UntypedIdentifier(String)
    2616             : template <typename Term>
    2617      494083 : bool check_term_UntypedIdentifier(const Term& t)
    2618             : {
    2619      494083 :   utilities::mcrl2_unused(t);
    2620             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    2621             :   // check the type of the term
    2622      494083 :   const atermpp::aterm& term(t);
    2623      494083 :   if (!term.type_is_appl())
    2624             :   {
    2625           0 :     return false;
    2626             :   }
    2627      494083 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    2628      494083 :   if (a.function() != core::detail::function_symbols::UntypedIdentifier)
    2629             :   {
    2630      219653 :     return false;
    2631             :   }
    2632             : 
    2633             :   // check the children
    2634      274430 :   if (a.size() != 1)
    2635             :   {
    2636           0 :     return false;
    2637             :   }
    2638             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    2639      274430 :   if (!check_term_argument(a[0], check_rule_String<atermpp::aterm>))
    2640             :   {
    2641           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_String" << std::endl;
    2642           0 :     return false;
    2643             :   }
    2644             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    2645             : 
    2646             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    2647      274430 :   return true;
    2648             : }
    2649             : 
    2650             : // BooleanFalse()
    2651             : template <typename Term>
    2652        1163 : bool check_term_BooleanFalse(const Term& t)
    2653             : {
    2654        1163 :   utilities::mcrl2_unused(t);
    2655             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    2656             :   // check the type of the term
    2657        1163 :   const atermpp::aterm& term(t);
    2658        1163 :   if (!term.type_is_appl())
    2659             :   {
    2660           0 :     return false;
    2661             :   }
    2662        1163 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    2663        1163 :   if (a.function() != core::detail::function_symbols::BooleanFalse)
    2664             :   {
    2665        1110 :     return false;
    2666             :   }
    2667             : 
    2668             :   // check the children
    2669          53 :   if (a.size() != 0)
    2670             :   {
    2671           0 :     return false;
    2672             :   }
    2673             : 
    2674             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    2675          53 :   return true;
    2676             : }
    2677             : 
    2678             : // BES(BooleanEquation*, BooleanExpression)
    2679             : template <typename Term>
    2680           1 : bool check_term_BES(const Term& t)
    2681             : {
    2682           1 :   utilities::mcrl2_unused(t);
    2683             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    2684             :   // check the type of the term
    2685           1 :   const atermpp::aterm& term(t);
    2686           1 :   if (!term.type_is_appl())
    2687             :   {
    2688           0 :     return false;
    2689             :   }
    2690           1 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    2691           1 :   if (a.function() != core::detail::function_symbols::BES)
    2692             :   {
    2693           0 :     return false;
    2694             :   }
    2695             : 
    2696             :   // check the children
    2697           1 :   if (a.size() != 2)
    2698             :   {
    2699           0 :     return false;
    2700             :   }
    2701             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    2702           1 :   if (!check_list_argument(a[0], check_rule_BooleanEquation<atermpp::aterm>, 0))
    2703             :   {
    2704           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_BooleanEquation" << std::endl;
    2705           0 :     return false;
    2706             :   }
    2707           1 :   if (!check_term_argument(a[1], check_rule_BooleanExpression<atermpp::aterm>))
    2708             :   {
    2709           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_BooleanExpression" << std::endl;
    2710           0 :     return false;
    2711             :   }
    2712             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    2713             : 
    2714             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    2715           1 :   return true;
    2716             : }
    2717             : 
    2718             : // MapSpec(OpId*)
    2719             : template <typename Term>
    2720         296 : bool check_term_MapSpec(const Term& t)
    2721             : {
    2722         296 :   utilities::mcrl2_unused(t);
    2723             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    2724             :   // check the type of the term
    2725         296 :   const atermpp::aterm& term(t);
    2726         296 :   if (!term.type_is_appl())
    2727             :   {
    2728           0 :     return false;
    2729             :   }
    2730         296 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    2731         296 :   if (a.function() != core::detail::function_symbols::MapSpec)
    2732             :   {
    2733           0 :     return false;
    2734             :   }
    2735             : 
    2736             :   // check the children
    2737         296 :   if (a.size() != 1)
    2738             :   {
    2739           0 :     return false;
    2740             :   }
    2741             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    2742         296 :   if (!check_list_argument(a[0], check_rule_OpId<atermpp::aterm>, 0))
    2743             :   {
    2744           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_OpId" << std::endl;
    2745           0 :     return false;
    2746             :   }
    2747             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    2748             : 
    2749             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    2750         296 :   return true;
    2751             : }
    2752             : 
    2753             : // IfThen(DataExpr, ProcExpr)
    2754             : template <typename Term>
    2755      709419 : bool check_term_IfThen(const Term& t)
    2756             : {
    2757      709419 :   utilities::mcrl2_unused(t);
    2758             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    2759             :   // check the type of the term
    2760      709419 :   const atermpp::aterm& term(t);
    2761      709419 :   if (!term.type_is_appl())
    2762             :   {
    2763           0 :     return false;
    2764             :   }
    2765      709419 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    2766      709419 :   if (a.function() != core::detail::function_symbols::IfThen)
    2767             :   {
    2768      408824 :     return false;
    2769             :   }
    2770             : 
    2771             :   // check the children
    2772      300595 :   if (a.size() != 2)
    2773             :   {
    2774           0 :     return false;
    2775             :   }
    2776             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    2777      300595 :   if (!check_term_argument(a[0], check_rule_DataExpr<atermpp::aterm>))
    2778             :   {
    2779           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_DataExpr" << std::endl;
    2780           0 :     return false;
    2781             :   }
    2782      300595 :   if (!check_term_argument(a[1], check_rule_ProcExpr<atermpp::aterm>))
    2783             :   {
    2784           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_ProcExpr" << std::endl;
    2785           0 :     return false;
    2786             :   }
    2787             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    2788             : 
    2789             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    2790      300595 :   return true;
    2791             : }
    2792             : 
    2793             : // BooleanAnd(BooleanExpression, BooleanExpression)
    2794             : template <typename Term>
    2795         189 : bool check_term_BooleanAnd(const Term& t)
    2796             : {
    2797         189 :   utilities::mcrl2_unused(t);
    2798             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    2799             :   // check the type of the term
    2800         189 :   const atermpp::aterm& term(t);
    2801         189 :   if (!term.type_is_appl())
    2802             :   {
    2803           0 :     return false;
    2804             :   }
    2805         189 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    2806         189 :   if (a.function() != core::detail::function_symbols::BooleanAnd)
    2807             :   {
    2808          44 :     return false;
    2809             :   }
    2810             : 
    2811             :   // check the children
    2812         145 :   if (a.size() != 2)
    2813             :   {
    2814           0 :     return false;
    2815             :   }
    2816             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    2817         145 :   if (!check_term_argument(a[0], check_rule_BooleanExpression<atermpp::aterm>))
    2818             :   {
    2819           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_BooleanExpression" << std::endl;
    2820           0 :     return false;
    2821             :   }
    2822         145 :   if (!check_term_argument(a[1], check_rule_BooleanExpression<atermpp::aterm>))
    2823             :   {
    2824           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_BooleanExpression" << std::endl;
    2825           0 :     return false;
    2826             :   }
    2827             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    2828             : 
    2829             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    2830         145 :   return true;
    2831             : }
    2832             : 
    2833             : // LinProcSpec(DataSpec, ActSpec, GlobVarSpec, LinearProcess, LinearProcessInit)
    2834             : template <typename Term>
    2835           5 : bool check_term_LinProcSpec(const Term& t)
    2836             : {
    2837           5 :   utilities::mcrl2_unused(t);
    2838             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    2839             :   // check the type of the term
    2840           5 :   const atermpp::aterm& term(t);
    2841           5 :   if (!term.type_is_appl())
    2842             :   {
    2843           0 :     return false;
    2844             :   }
    2845           5 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    2846           5 :   if (a.function() != core::detail::function_symbols::LinProcSpec)
    2847             :   {
    2848           0 :     return false;
    2849             :   }
    2850             : 
    2851             :   // check the children
    2852           5 :   if (a.size() != 5)
    2853             :   {
    2854           0 :     return false;
    2855             :   }
    2856             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    2857           5 :   if (!check_term_argument(a[0], check_rule_DataSpec<atermpp::aterm>))
    2858             :   {
    2859           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_DataSpec" << std::endl;
    2860           0 :     return false;
    2861             :   }
    2862           5 :   if (!check_term_argument(a[1], check_rule_ActSpec<atermpp::aterm>))
    2863             :   {
    2864           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_ActSpec" << std::endl;
    2865           0 :     return false;
    2866             :   }
    2867           5 :   if (!check_term_argument(a[2], check_rule_GlobVarSpec<atermpp::aterm>))
    2868             :   {
    2869           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_GlobVarSpec" << std::endl;
    2870           0 :     return false;
    2871             :   }
    2872           5 :   if (!check_term_argument(a[3], check_rule_LinearProcess<atermpp::aterm>))
    2873             :   {
    2874           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_LinearProcess" << std::endl;
    2875           0 :     return false;
    2876             :   }
    2877           5 :   if (!check_term_argument(a[4], check_rule_LinearProcessInit<atermpp::aterm>))
    2878             :   {
    2879           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_LinearProcessInit" << std::endl;
    2880           0 :     return false;
    2881             :   }
    2882             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    2883             : 
    2884             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    2885           5 :   return true;
    2886             : }
    2887             : 
    2888             : // Choice(ProcExpr, ProcExpr)
    2889             : template <typename Term>
    2890      369487 : bool check_term_Choice(const Term& t)
    2891             : {
    2892      369487 :   utilities::mcrl2_unused(t);
    2893             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    2894             :   // check the type of the term
    2895      369487 :   const atermpp::aterm& term(t);
    2896      369487 :   if (!term.type_is_appl())
    2897             :   {
    2898           0 :     return false;
    2899             :   }
    2900      369487 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    2901      369487 :   if (a.function() != core::detail::function_symbols::Choice)
    2902             :   {
    2903       79806 :     return false;
    2904             :   }
    2905             : 
    2906             :   // check the children
    2907      289681 :   if (a.size() != 2)
    2908             :   {
    2909           0 :     return false;
    2910             :   }
    2911             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    2912      289681 :   if (!check_term_argument(a[0], check_rule_ProcExpr<atermpp::aterm>))
    2913             :   {
    2914           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_ProcExpr" << std::endl;
    2915           0 :     return false;
    2916             :   }
    2917      289681 :   if (!check_term_argument(a[1], check_rule_ProcExpr<atermpp::aterm>))
    2918             :   {
    2919           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_ProcExpr" << std::endl;
    2920           0 :     return false;
    2921             :   }
    2922             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    2923             : 
    2924             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    2925      289681 :   return true;
    2926             : }
    2927             : 
    2928             : // LinearProcessInit(DataVarIdInit*, Distribution)
    2929             : template <typename Term>
    2930        7161 : bool check_term_LinearProcessInit(const Term& t)
    2931             : {
    2932        7161 :   utilities::mcrl2_unused(t);
    2933             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    2934             :   // check the type of the term
    2935        7161 :   const atermpp::aterm& term(t);
    2936        7161 :   if (!term.type_is_appl())
    2937             :   {
    2938           0 :     return false;
    2939             :   }
    2940        7161 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    2941        7161 :   if (a.function() != core::detail::function_symbols::LinearProcessInit)
    2942             :   {
    2943           0 :     return false;
    2944             :   }
    2945             : 
    2946             :   // check the children
    2947        7161 :   if (a.size() != 2)
    2948             :   {
    2949           0 :     return false;
    2950             :   }
    2951             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    2952        7161 :   if (!check_list_argument(a[0], check_rule_DataVarIdInit<atermpp::aterm>, 0))
    2953             :   {
    2954           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_DataVarIdInit" << std::endl;
    2955           0 :     return false;
    2956             :   }
    2957        7161 :   if (!check_term_argument(a[1], check_rule_Distribution<atermpp::aterm>))
    2958             :   {
    2959           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_Distribution" << std::endl;
    2960           0 :     return false;
    2961             :   }
    2962             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    2963             : 
    2964             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    2965        7161 :   return true;
    2966             : }
    2967             : 
    2968             : // MultAct(Action*)
    2969             : template <typename Term>
    2970          75 : bool check_term_MultAct(const Term& t)
    2971             : {
    2972          75 :   utilities::mcrl2_unused(t);
    2973             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    2974             :   // check the type of the term
    2975          75 :   const atermpp::aterm& term(t);
    2976          75 :   if (!term.type_is_appl())
    2977             :   {
    2978           0 :     return false;
    2979             :   }
    2980          75 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    2981          75 :   if (a.function() != core::detail::function_symbols::MultAct)
    2982             :   {
    2983           6 :     return false;
    2984             :   }
    2985             : 
    2986             :   // check the children
    2987          69 :   if (a.size() != 1)
    2988             :   {
    2989           0 :     return false;
    2990             :   }
    2991             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    2992          69 :   if (!check_list_argument(a[0], check_rule_Action<atermpp::aterm>, 0))
    2993             :   {
    2994           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_Action" << std::endl;
    2995           0 :     return false;
    2996             :   }
    2997             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    2998             : 
    2999             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    3000          69 :   return true;
    3001             : }
    3002             : 
    3003             : // PropVarInst(String, DataExpr*, Number)
    3004             : template <typename Term>
    3005       81544 : bool check_term_PropVarInst(const Term& t)
    3006             : {
    3007       81544 :   utilities::mcrl2_unused(t);
    3008             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    3009             :   // check the type of the term
    3010       81544 :   const atermpp::aterm& term(t);
    3011       81544 :   if (!term.type_is_appl())
    3012             :   {
    3013           0 :     return false;
    3014             :   }
    3015       81544 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    3016       81544 :   if (a.function() != core::detail::function_symbols::PropVarInst)
    3017             :   {
    3018        3570 :     return false;
    3019             :   }
    3020             : 
    3021             :   // check the children
    3022       77974 :   if (a.size() != 3)
    3023             :   {
    3024           0 :     return false;
    3025             :   }
    3026             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    3027       77974 :   if (!check_term_argument(a[0], check_rule_String<atermpp::aterm>))
    3028             :   {
    3029           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_String" << std::endl;
    3030           0 :     return false;
    3031             :   }
    3032       77974 :   if (!check_list_argument(a[1], check_rule_DataExpr<atermpp::aterm>, 0))
    3033             :   {
    3034           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_DataExpr" << std::endl;
    3035           0 :     return false;
    3036             :   }
    3037       77974 :   if (!check_term_argument(a[2], check_rule_Number<atermpp::aterm>))
    3038             :   {
    3039           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_Number" << std::endl;
    3040           0 :     return false;
    3041             :   }
    3042             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    3043             : 
    3044             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    3045       77974 :   return true;
    3046             : }
    3047             : 
    3048             : // BagComp()
    3049             : template <typename Term>
    3050       94226 : bool check_term_BagComp(const Term& t)
    3051             : {
    3052       94226 :   utilities::mcrl2_unused(t);
    3053             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    3054             :   // check the type of the term
    3055       94226 :   const atermpp::aterm& term(t);
    3056       94226 :   if (!term.type_is_appl())
    3057             :   {
    3058           0 :     return false;
    3059             :   }
    3060       94226 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    3061       94226 :   if (a.function() != core::detail::function_symbols::BagComp)
    3062             :   {
    3063       94178 :     return false;
    3064             :   }
    3065             : 
    3066             :   // check the children
    3067          48 :   if (a.size() != 0)
    3068             :   {
    3069           0 :     return false;
    3070             :   }
    3071             : 
    3072             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    3073          48 :   return true;
    3074             : }
    3075             : 
    3076             : // StateDelay()
    3077             : template <typename Term>
    3078        9862 : bool check_term_StateDelay(const Term& t)
    3079             : {
    3080        9862 :   utilities::mcrl2_unused(t);
    3081             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    3082             :   // check the type of the term
    3083        9862 :   const atermpp::aterm& term(t);
    3084        9862 :   if (!term.type_is_appl())
    3085             :   {
    3086           0 :     return false;
    3087             :   }
    3088        9862 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    3089        9862 :   if (a.function() != core::detail::function_symbols::StateDelay)
    3090             :   {
    3091        9862 :     return false;
    3092             :   }
    3093             : 
    3094             :   // check the children
    3095           0 :   if (a.size() != 0)
    3096             :   {
    3097           0 :     return false;
    3098             :   }
    3099             : 
    3100             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    3101           0 :   return true;
    3102             : }
    3103             : 
    3104             : // RegAlt(RegFrm, RegFrm)
    3105             : template <typename Term>
    3106         355 : bool check_term_RegAlt(const Term& t)
    3107             : {
    3108         355 :   utilities::mcrl2_unused(t);
    3109             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    3110             :   // check the type of the term
    3111         355 :   const atermpp::aterm& term(t);
    3112         355 :   if (!term.type_is_appl())
    3113             :   {
    3114           0 :     return false;
    3115             :   }
    3116         355 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    3117         355 :   if (a.function() != core::detail::function_symbols::RegAlt)
    3118             :   {
    3119         355 :     return false;
    3120             :   }
    3121             : 
    3122             :   // check the children
    3123           0 :   if (a.size() != 2)
    3124             :   {
    3125           0 :     return false;
    3126             :   }
    3127             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    3128           0 :   if (!check_term_argument(a[0], check_rule_RegFrm<atermpp::aterm>))
    3129             :   {
    3130           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_RegFrm" << std::endl;
    3131           0 :     return false;
    3132             :   }
    3133           0 :   if (!check_term_argument(a[1], check_rule_RegFrm<atermpp::aterm>))
    3134             :   {
    3135           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_RegFrm" << std::endl;
    3136           0 :     return false;
    3137             :   }
    3138             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    3139             : 
    3140             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    3141           0 :   return true;
    3142             : }
    3143             : 
    3144             : // BddFalse()
    3145             : template <typename Term>
    3146          16 : bool check_term_BddFalse(const Term& t)
    3147             : {
    3148          16 :   utilities::mcrl2_unused(t);
    3149             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    3150             :   // check the type of the term
    3151          16 :   const atermpp::aterm& term(t);
    3152          16 :   if (!term.type_is_appl())
    3153             :   {
    3154           0 :     return false;
    3155             :   }
    3156          16 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    3157          16 :   if (a.function() != core::detail::function_symbols::BddFalse)
    3158             :   {
    3159           9 :     return false;
    3160             :   }
    3161             : 
    3162             :   // check the children
    3163           7 :   if (a.size() != 0)
    3164             :   {
    3165           0 :     return false;
    3166             :   }
    3167             : 
    3168             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    3169           7 :   return true;
    3170             : }
    3171             : 
    3172             : // StructCons(String, StructProj*, StringOrEmpty)
    3173             : template <typename Term>
    3174     5543943 : bool check_term_StructCons(const Term& t)
    3175             : {
    3176     5543943 :   utilities::mcrl2_unused(t);
    3177             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    3178             :   // check the type of the term
    3179     5543943 :   const atermpp::aterm& term(t);
    3180     5543943 :   if (!term.type_is_appl())
    3181             :   {
    3182           0 :     return false;
    3183             :   }
    3184     5543943 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    3185     5543943 :   if (a.function() != core::detail::function_symbols::StructCons)
    3186             :   {
    3187           0 :     return false;
    3188             :   }
    3189             : 
    3190             :   // check the children
    3191     5543943 :   if (a.size() != 3)
    3192             :   {
    3193           0 :     return false;
    3194             :   }
    3195             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    3196     5543943 :   if (!check_term_argument(a[0], check_rule_String<atermpp::aterm>))
    3197             :   {
    3198           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_String" << std::endl;
    3199           0 :     return false;
    3200             :   }
    3201     5543943 :   if (!check_list_argument(a[1], check_rule_StructProj<atermpp::aterm>, 0))
    3202             :   {
    3203           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_StructProj" << std::endl;
    3204           0 :     return false;
    3205             :   }
    3206     5543943 :   if (!check_term_argument(a[2], check_rule_StringOrEmpty<atermpp::aterm>))
    3207             :   {
    3208           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_StringOrEmpty" << std::endl;
    3209           0 :     return false;
    3210             :   }
    3211             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    3212             : 
    3213             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    3214     5543943 :   return true;
    3215             : }
    3216             : 
    3217             : // Mu()
    3218             : template <typename Term>
    3219        4144 : bool check_term_Mu(const Term& t)
    3220             : {
    3221        4144 :   utilities::mcrl2_unused(t);
    3222             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    3223             :   // check the type of the term
    3224        4144 :   const atermpp::aterm& term(t);
    3225        4144 :   if (!term.type_is_appl())
    3226             :   {
    3227           0 :     return false;
    3228             :   }
    3229        4144 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    3230        4144 :   if (a.function() != core::detail::function_symbols::Mu)
    3231             :   {
    3232         829 :     return false;
    3233             :   }
    3234             : 
    3235             :   // check the children
    3236        3315 :   if (a.size() != 0)
    3237             :   {
    3238           0 :     return false;
    3239             :   }
    3240             : 
    3241             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    3242        3315 :   return true;
    3243             : }
    3244             : 
    3245             : // PBEqnSpec(PBEqn*)
    3246             : template <typename Term>
    3247         171 : bool check_term_PBEqnSpec(const Term& t)
    3248             : {
    3249         171 :   utilities::mcrl2_unused(t);
    3250             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    3251             :   // check the type of the term
    3252         171 :   const atermpp::aterm& term(t);
    3253         171 :   if (!term.type_is_appl())
    3254             :   {
    3255           0 :     return false;
    3256             :   }
    3257         171 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    3258         171 :   if (a.function() != core::detail::function_symbols::PBEqnSpec)
    3259             :   {
    3260           0 :     return false;
    3261             :   }
    3262             : 
    3263             :   // check the children
    3264         171 :   if (a.size() != 1)
    3265             :   {
    3266           0 :     return false;
    3267             :   }
    3268             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    3269         171 :   if (!check_list_argument(a[0], check_rule_PBEqn<atermpp::aterm>, 0))
    3270             :   {
    3271           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_PBEqn" << std::endl;
    3272           0 :     return false;
    3273             :   }
    3274             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    3275             : 
    3276             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    3277         171 :   return true;
    3278             : }
    3279             : 
    3280             : // UntypedRegFrm(String, RegFrm, RegFrm)
    3281             : template <typename Term>
    3282          12 : bool check_term_UntypedRegFrm(const Term& t)
    3283             : {
    3284          12 :   utilities::mcrl2_unused(t);
    3285             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    3286             :   // check the type of the term
    3287          12 :   const atermpp::aterm& term(t);
    3288          12 :   if (!term.type_is_appl())
    3289             :   {
    3290           0 :     return false;
    3291             :   }
    3292          12 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    3293          12 :   if (a.function() != core::detail::function_symbols::UntypedRegFrm)
    3294             :   {
    3295           0 :     return false;
    3296             :   }
    3297             : 
    3298             :   // check the children
    3299          12 :   if (a.size() != 3)
    3300             :   {
    3301           0 :     return false;
    3302             :   }
    3303             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    3304          12 :   if (!check_term_argument(a[0], check_rule_String<atermpp::aterm>))
    3305             :   {
    3306           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_String" << std::endl;
    3307           0 :     return false;
    3308             :   }
    3309          12 :   if (!check_term_argument(a[1], check_rule_RegFrm<atermpp::aterm>))
    3310             :   {
    3311           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_RegFrm" << std::endl;
    3312           0 :     return false;
    3313             :   }
    3314          12 :   if (!check_term_argument(a[2], check_rule_RegFrm<atermpp::aterm>))
    3315             :   {
    3316           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_RegFrm" << std::endl;
    3317           0 :     return false;
    3318             :   }
    3319             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    3320             : 
    3321             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    3322          12 :   return true;
    3323             : }
    3324             : 
    3325             : // Distribution(DataVarId*, DataExpr)
    3326             : template <typename Term>
    3327        7236 : bool check_term_Distribution(const Term& t)
    3328             : {
    3329        7236 :   utilities::mcrl2_unused(t);
    3330             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    3331             :   // check the type of the term
    3332        7236 :   const atermpp::aterm& term(t);
    3333        7236 :   if (!term.type_is_appl())
    3334             :   {
    3335           0 :     return false;
    3336             :   }
    3337        7236 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    3338        7236 :   if (a.function() != core::detail::function_symbols::Distribution)
    3339             :   {
    3340           0 :     return false;
    3341             :   }
    3342             : 
    3343             :   // check the children
    3344        7236 :   if (a.size() != 2)
    3345             :   {
    3346           0 :     return false;
    3347             :   }
    3348             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    3349        7236 :   if (!check_list_argument(a[0], check_rule_DataVarId<atermpp::aterm>, 0))
    3350             :   {
    3351           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_DataVarId" << std::endl;
    3352           0 :     return false;
    3353             :   }
    3354        7236 :   if (!check_term_argument(a[1], check_rule_DataExpr<atermpp::aterm>))
    3355             :   {
    3356           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_DataExpr" << std::endl;
    3357           0 :     return false;
    3358             :   }
    3359             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    3360             : 
    3361             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    3362        7236 :   return true;
    3363             : }
    3364             : 
    3365             : // BooleanTrue()
    3366             : template <typename Term>
    3367        1295 : bool check_term_BooleanTrue(const Term& t)
    3368             : {
    3369        1295 :   utilities::mcrl2_unused(t);
    3370             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    3371             :   // check the type of the term
    3372        1295 :   const atermpp::aterm& term(t);
    3373        1295 :   if (!term.type_is_appl())
    3374             :   {
    3375           0 :     return false;
    3376             :   }
    3377        1295 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    3378        1295 :   if (a.function() != core::detail::function_symbols::BooleanTrue)
    3379             :   {
    3380        1163 :     return false;
    3381             :   }
    3382             : 
    3383             :   // check the children
    3384         132 :   if (a.size() != 0)
    3385             :   {
    3386           0 :     return false;
    3387             :   }
    3388             : 
    3389             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    3390         132 :   return true;
    3391             : }
    3392             : 
    3393             : // Block(String*, ProcExpr)
    3394             : template <typename Term>
    3395     1579418 : bool check_term_Block(const Term& t)
    3396             : {
    3397     1579418 :   utilities::mcrl2_unused(t);
    3398             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    3399             :   // check the type of the term
    3400     1579418 :   const atermpp::aterm& term(t);
    3401     1579418 :   if (!term.type_is_appl())
    3402             :   {
    3403           0 :     return false;
    3404             :   }
    3405     1579418 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    3406     1579418 :   if (a.function() != core::detail::function_symbols::Block)
    3407             :   {
    3408     1579418 :     return false;
    3409             :   }
    3410             : 
    3411             :   // check the children
    3412           0 :   if (a.size() != 2)
    3413             :   {
    3414           0 :     return false;
    3415             :   }
    3416             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    3417           0 :   if (!check_list_argument(a[0], check_rule_String<atermpp::aterm>, 0))
    3418             :   {
    3419           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_String" << std::endl;
    3420           0 :     return false;
    3421             :   }
    3422           0 :   if (!check_term_argument(a[1], check_rule_ProcExpr<atermpp::aterm>))
    3423             :   {
    3424           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_ProcExpr" << std::endl;
    3425           0 :     return false;
    3426             :   }
    3427             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    3428             : 
    3429             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    3430           0 :   return true;
    3431             : }
    3432             : 
    3433             : // Rename(RenameExpr*, ProcExpr)
    3434             : template <typename Term>
    3435     1578932 : bool check_term_Rename(const Term& t)
    3436             : {
    3437     1578932 :   utilities::mcrl2_unused(t);
    3438             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    3439             :   // check the type of the term
    3440     1578932 :   const atermpp::aterm& term(t);
    3441     1578932 :   if (!term.type_is_appl())
    3442             :   {
    3443           0 :     return false;
    3444             :   }
    3445     1578932 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    3446     1578932 :   if (a.function() != core::detail::function_symbols::Rename)
    3447             :   {
    3448     1578932 :     return false;
    3449             :   }
    3450             : 
    3451             :   // check the children
    3452           0 :   if (a.size() != 2)
    3453             :   {
    3454           0 :     return false;
    3455             :   }
    3456             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    3457           0 :   if (!check_list_argument(a[0], check_rule_RenameExpr<atermpp::aterm>, 0))
    3458             :   {
    3459           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_RenameExpr" << std::endl;
    3460           0 :     return false;
    3461             :   }
    3462           0 :   if (!check_term_argument(a[1], check_rule_ProcExpr<atermpp::aterm>))
    3463             :   {
    3464           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_ProcExpr" << std::endl;
    3465           0 :     return false;
    3466             :   }
    3467             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    3468             : 
    3469             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    3470           0 :   return true;
    3471             : }
    3472             : 
    3473             : // Exists()
    3474             : template <typename Term>
    3475       95254 : bool check_term_Exists(const Term& t)
    3476             : {
    3477       95254 :   utilities::mcrl2_unused(t);
    3478             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    3479             :   // check the type of the term
    3480       95254 :   const atermpp::aterm& term(t);
    3481       95254 :   if (!term.type_is_appl())
    3482             :   {
    3483           0 :     return false;
    3484             :   }
    3485       95254 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    3486       95254 :   if (a.function() != core::detail::function_symbols::Exists)
    3487             :   {
    3488       94367 :     return false;
    3489             :   }
    3490             : 
    3491             :   // check the children
    3492         887 :   if (a.size() != 0)
    3493             :   {
    3494           0 :     return false;
    3495             :   }
    3496             : 
    3497             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    3498         887 :   return true;
    3499             : }
    3500             : 
    3501             : // Sync(ProcExpr, ProcExpr)
    3502             : template <typename Term>
    3503     1491639 : bool check_term_Sync(const Term& t)
    3504             : {
    3505     1491639 :   utilities::mcrl2_unused(t);
    3506             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    3507             :   // check the type of the term
    3508     1491639 :   const atermpp::aterm& term(t);
    3509     1491639 :   if (!term.type_is_appl())
    3510             :   {
    3511           0 :     return false;
    3512             :   }
    3513     1491639 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    3514     1491639 :   if (a.function() != core::detail::function_symbols::Sync)
    3515             :   {
    3516     1429944 :     return false;
    3517             :   }
    3518             : 
    3519             :   // check the children
    3520       61695 :   if (a.size() != 2)
    3521             :   {
    3522           0 :     return false;
    3523             :   }
    3524             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    3525       61695 :   if (!check_term_argument(a[0], check_rule_ProcExpr<atermpp::aterm>))
    3526             :   {
    3527           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_ProcExpr" << std::endl;
    3528           0 :     return false;
    3529             :   }
    3530       61695 :   if (!check_term_argument(a[1], check_rule_ProcExpr<atermpp::aterm>))
    3531             :   {
    3532           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_ProcExpr" << std::endl;
    3533           0 :     return false;
    3534             :   }
    3535             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    3536             : 
    3537             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    3538       61695 :   return true;
    3539             : }
    3540             : 
    3541             : // ActExists(DataVarId+, ActFrm)
    3542             : template <typename Term>
    3543        8299 : bool check_term_ActExists(const Term& t)
    3544             : {
    3545        8299 :   utilities::mcrl2_unused(t);
    3546             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    3547             :   // check the type of the term
    3548        8299 :   const atermpp::aterm& term(t);
    3549        8299 :   if (!term.type_is_appl())
    3550             :   {
    3551           0 :     return false;
    3552             :   }
    3553        8299 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    3554        8299 :   if (a.function() != core::detail::function_symbols::ActExists)
    3555             :   {
    3556        8250 :     return false;
    3557             :   }
    3558             : 
    3559             :   // check the children
    3560          49 :   if (a.size() != 2)
    3561             :   {
    3562           0 :     return false;
    3563             :   }
    3564             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    3565          49 :   if (!check_list_argument(a[0], check_rule_DataVarId<atermpp::aterm>, 1))
    3566             :   {
    3567           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_DataVarId" << std::endl;
    3568           0 :     return false;
    3569             :   }
    3570          49 :   if (!check_term_argument(a[1], check_rule_ActFrm<atermpp::aterm>))
    3571             :   {
    3572           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_ActFrm" << std::endl;
    3573           0 :     return false;
    3574             :   }
    3575             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    3576             : 
    3577             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    3578          49 :   return true;
    3579             : }
    3580             : 
    3581             : // ProcSpec(DataSpec, ActSpec, GlobVarSpec, ProcEqnSpec, ProcInit)
    3582             : template <typename Term>
    3583           0 : bool check_term_ProcSpec(const Term& t)
    3584             : {
    3585           0 :   utilities::mcrl2_unused(t);
    3586             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    3587             :   // check the type of the term
    3588           0 :   const atermpp::aterm& term(t);
    3589           0 :   if (!term.type_is_appl())
    3590             :   {
    3591           0 :     return false;
    3592             :   }
    3593           0 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    3594           0 :   if (a.function() != core::detail::function_symbols::ProcSpec)
    3595             :   {
    3596           0 :     return false;
    3597             :   }
    3598             : 
    3599             :   // check the children
    3600           0 :   if (a.size() != 5)
    3601             :   {
    3602           0 :     return false;
    3603             :   }
    3604             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    3605           0 :   if (!check_term_argument(a[0], check_rule_DataSpec<atermpp::aterm>))
    3606             :   {
    3607           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_DataSpec" << std::endl;
    3608           0 :     return false;
    3609             :   }
    3610           0 :   if (!check_term_argument(a[1], check_rule_ActSpec<atermpp::aterm>))
    3611             :   {
    3612           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_ActSpec" << std::endl;
    3613           0 :     return false;
    3614             :   }
    3615           0 :   if (!check_term_argument(a[2], check_rule_GlobVarSpec<atermpp::aterm>))
    3616             :   {
    3617           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_GlobVarSpec" << std::endl;
    3618           0 :     return false;
    3619             :   }
    3620           0 :   if (!check_term_argument(a[3], check_rule_ProcEqnSpec<atermpp::aterm>))
    3621             :   {
    3622           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_ProcEqnSpec" << std::endl;
    3623           0 :     return false;
    3624             :   }
    3625           0 :   if (!check_term_argument(a[4], check_rule_ProcInit<atermpp::aterm>))
    3626             :   {
    3627           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_ProcInit" << std::endl;
    3628           0 :     return false;
    3629             :   }
    3630             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    3631             : 
    3632             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    3633           0 :   return true;
    3634             : }
    3635             : 
    3636             : // UntypedSortsPossible(SortExpr+)
    3637             : template <typename Term>
    3638      122635 : bool check_term_UntypedSortsPossible(const Term& t)
    3639             : {
    3640      122635 :   utilities::mcrl2_unused(t);
    3641             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    3642             :   // check the type of the term
    3643      122635 :   const atermpp::aterm& term(t);
    3644      122635 :   if (!term.type_is_appl())
    3645             :   {
    3646           0 :     return false;
    3647             :   }
    3648      122635 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    3649      122635 :   if (a.function() != core::detail::function_symbols::UntypedSortsPossible)
    3650             :   {
    3651        1748 :     return false;
    3652             :   }
    3653             : 
    3654             :   // check the children
    3655      120887 :   if (a.size() != 1)
    3656             :   {
    3657           0 :     return false;
    3658             :   }
    3659             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    3660      120887 :   if (!check_list_argument(a[0], check_rule_SortExpr<atermpp::aterm>, 1))
    3661             :   {
    3662           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_SortExpr" << std::endl;
    3663           0 :     return false;
    3664             :   }
    3665             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    3666             : 
    3667             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    3668      120887 :   return true;
    3669             : }
    3670             : 
    3671             : // StateMu(String, DataVarIdInit*, StateFrm)
    3672             : template <typename Term>
    3673        3417 : bool check_term_StateMu(const Term& t)
    3674             : {
    3675        3417 :   utilities::mcrl2_unused(t);
    3676             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    3677             :   // check the type of the term
    3678        3417 :   const atermpp::aterm& term(t);
    3679        3417 :   if (!term.type_is_appl())
    3680             :   {
    3681           0 :     return false;
    3682             :   }
    3683        3417 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    3684        3417 :   if (a.function() != core::detail::function_symbols::StateMu)
    3685             :   {
    3686        1132 :     return false;
    3687             :   }
    3688             : 
    3689             :   // check the children
    3690        2285 :   if (a.size() != 3)
    3691             :   {
    3692           0 :     return false;
    3693             :   }
    3694             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    3695        2285 :   if (!check_term_argument(a[0], check_rule_String<atermpp::aterm>))
    3696             :   {
    3697           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_String" << std::endl;
    3698           0 :     return false;
    3699             :   }
    3700        2285 :   if (!check_list_argument(a[1], check_rule_DataVarIdInit<atermpp::aterm>, 0))
    3701             :   {
    3702           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_DataVarIdInit" << std::endl;
    3703           0 :     return false;
    3704             :   }
    3705        2285 :   if (!check_term_argument(a[2], check_rule_StateFrm<atermpp::aterm>))
    3706             :   {
    3707           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_StateFrm" << std::endl;
    3708           0 :     return false;
    3709             :   }
    3710             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    3711             : 
    3712             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    3713        2285 :   return true;
    3714             : }
    3715             : 
    3716             : // BddIf(String, BddExpression, BddExpression)
    3717             : template <typename Term>
    3718           9 : bool check_term_BddIf(const Term& t)
    3719             : {
    3720           9 :   utilities::mcrl2_unused(t);
    3721             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    3722             :   // check the type of the term
    3723           9 :   const atermpp::aterm& term(t);
    3724           9 :   if (!term.type_is_appl())
    3725             :   {
    3726           0 :     return false;
    3727             :   }
    3728           9 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    3729           9 :   if (a.function() != core::detail::function_symbols::BddIf)
    3730             :   {
    3731           0 :     return false;
    3732             :   }
    3733             : 
    3734             :   // check the children
    3735           9 :   if (a.size() != 3)
    3736             :   {
    3737           0 :     return false;
    3738             :   }
    3739             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    3740           9 :   if (!check_term_argument(a[0], check_rule_String<atermpp::aterm>))
    3741             :   {
    3742           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_String" << std::endl;
    3743           0 :     return false;
    3744             :   }
    3745           9 :   if (!check_term_argument(a[1], check_rule_BddExpression<atermpp::aterm>))
    3746             :   {
    3747           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_BddExpression" << std::endl;
    3748           0 :     return false;
    3749             :   }
    3750           9 :   if (!check_term_argument(a[2], check_rule_BddExpression<atermpp::aterm>))
    3751             :   {
    3752           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_BddExpression" << std::endl;
    3753           0 :     return false;
    3754             :   }
    3755             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    3756             : 
    3757             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    3758           9 :   return true;
    3759             : }
    3760             : 
    3761             : // StateFalse()
    3762             : template <typename Term>
    3763       26038 : bool check_term_StateFalse(const Term& t)
    3764             : {
    3765       26038 :   utilities::mcrl2_unused(t);
    3766             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    3767             :   // check the type of the term
    3768       26038 :   const atermpp::aterm& term(t);
    3769       26038 :   if (!term.type_is_appl())
    3770             :   {
    3771           0 :     return false;
    3772             :   }
    3773       26038 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    3774       26038 :   if (a.function() != core::detail::function_symbols::StateFalse)
    3775             :   {
    3776       24836 :     return false;
    3777             :   }
    3778             : 
    3779             :   // check the children
    3780        1202 :   if (a.size() != 0)
    3781             :   {
    3782           0 :     return false;
    3783             :   }
    3784             : 
    3785             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    3786        1202 :   return true;
    3787             : }
    3788             : 
    3789             : // PBESFalse()
    3790             : template <typename Term>
    3791      177529 : bool check_term_PBESFalse(const Term& t)
    3792             : {
    3793      177529 :   utilities::mcrl2_unused(t);
    3794             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    3795             :   // check the type of the term
    3796      177529 :   const atermpp::aterm& term(t);
    3797      177529 :   if (!term.type_is_appl())
    3798             :   {
    3799           0 :     return false;
    3800             :   }
    3801      177529 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    3802      177529 :   if (a.function() != core::detail::function_symbols::PBESFalse)
    3803             :   {
    3804      177529 :     return false;
    3805             :   }
    3806             : 
    3807             :   // check the children
    3808           0 :   if (a.size() != 0)
    3809             :   {
    3810           0 :     return false;
    3811             :   }
    3812             : 
    3813             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    3814           0 :   return true;
    3815             : }
    3816             : 
    3817             : // PBESForall(DataVarId+, PBExpr)
    3818             : template <typename Term>
    3819       93562 : bool check_term_PBESForall(const Term& t)
    3820             : {
    3821       93562 :   utilities::mcrl2_unused(t);
    3822             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    3823             :   // check the type of the term
    3824       93562 :   const atermpp::aterm& term(t);
    3825       93562 :   if (!term.type_is_appl())
    3826             :   {
    3827           0 :     return false;
    3828             :   }
    3829       93562 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    3830       93562 :   if (a.function() != core::detail::function_symbols::PBESForall)
    3831             :   {
    3832       86866 :     return false;
    3833             :   }
    3834             : 
    3835             :   // check the children
    3836        6696 :   if (a.size() != 2)
    3837             :   {
    3838           0 :     return false;
    3839             :   }
    3840             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    3841        6696 :   if (!check_list_argument(a[0], check_rule_DataVarId<atermpp::aterm>, 1))
    3842             :   {
    3843           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_DataVarId" << std::endl;
    3844           0 :     return false;
    3845             :   }
    3846        6696 :   if (!check_term_argument(a[1], check_rule_PBExpr<atermpp::aterm>))
    3847             :   {
    3848           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_PBExpr" << std::endl;
    3849           0 :     return false;
    3850             :   }
    3851             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    3852             : 
    3853             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    3854        6696 :   return true;
    3855             : }
    3856             : 
    3857             : // StateTrue()
    3858             : template <typename Term>
    3859       29334 : bool check_term_StateTrue(const Term& t)
    3860             : {
    3861       29334 :   utilities::mcrl2_unused(t);
    3862             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    3863             :   // check the type of the term
    3864       29334 :   const atermpp::aterm& term(t);
    3865       29334 :   if (!term.type_is_appl())
    3866             :   {
    3867           0 :     return false;
    3868             :   }
    3869       29334 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    3870       29334 :   if (a.function() != core::detail::function_symbols::StateTrue)
    3871             :   {
    3872       26038 :     return false;
    3873             :   }
    3874             : 
    3875             :   // check the children
    3876        3296 :   if (a.size() != 0)
    3877             :   {
    3878           0 :     return false;
    3879             :   }
    3880             : 
    3881             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    3882        3296 :   return true;
    3883             : }
    3884             : 
    3885             : // BInit(ProcExpr, ProcExpr)
    3886             : template <typename Term>
    3887      372358 : bool check_term_BInit(const Term& t)
    3888             : {
    3889      372358 :   utilities::mcrl2_unused(t);
    3890             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    3891             :   // check the type of the term
    3892      372358 :   const atermpp::aterm& term(t);
    3893      372358 :   if (!term.type_is_appl())
    3894             :   {
    3895           0 :     return false;
    3896             :   }
    3897      372358 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    3898      372358 :   if (a.function() != core::detail::function_symbols::BInit)
    3899             :   {
    3900      372358 :     return false;
    3901             :   }
    3902             : 
    3903             :   // check the children
    3904           0 :   if (a.size() != 2)
    3905             :   {
    3906           0 :     return false;
    3907             :   }
    3908             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    3909           0 :   if (!check_term_argument(a[0], check_rule_ProcExpr<atermpp::aterm>))
    3910             :   {
    3911           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_ProcExpr" << std::endl;
    3912           0 :     return false;
    3913             :   }
    3914           0 :   if (!check_term_argument(a[1], check_rule_ProcExpr<atermpp::aterm>))
    3915             :   {
    3916           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_ProcExpr" << std::endl;
    3917           0 :     return false;
    3918             :   }
    3919             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    3920             : 
    3921             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    3922           0 :   return true;
    3923             : }
    3924             : 
    3925             : // UntypedSortUnknown()
    3926             : template <typename Term>
    3927    11449332 : bool check_term_UntypedSortUnknown(const Term& t)
    3928             : {
    3929    11449332 :   utilities::mcrl2_unused(t);
    3930             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    3931             :   // check the type of the term
    3932    11449332 :   const atermpp::aterm& term(t);
    3933    11449332 :   if (!term.type_is_appl())
    3934             :   {
    3935           0 :     return false;
    3936             :   }
    3937    11449332 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    3938    11449332 :   if (a.function() != core::detail::function_symbols::UntypedSortUnknown)
    3939             :   {
    3940      122635 :     return false;
    3941             :   }
    3942             : 
    3943             :   // check the children
    3944    11326697 :   if (a.size() != 0)
    3945             :   {
    3946           0 :     return false;
    3947             :   }
    3948             : 
    3949             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    3950    11326697 :   return true;
    3951             : }
    3952             : 
    3953             : // RegTrans(RegFrm)
    3954             : template <typename Term>
    3955         355 : bool check_term_RegTrans(const Term& t)
    3956             : {
    3957         355 :   utilities::mcrl2_unused(t);
    3958             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    3959             :   // check the type of the term
    3960         355 :   const atermpp::aterm& term(t);
    3961         355 :   if (!term.type_is_appl())
    3962             :   {
    3963           0 :     return false;
    3964             :   }
    3965         355 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    3966         355 :   if (a.function() != core::detail::function_symbols::RegTrans)
    3967             :   {
    3968         355 :     return false;
    3969             :   }
    3970             : 
    3971             :   // check the children
    3972           0 :   if (a.size() != 1)
    3973             :   {
    3974           0 :     return false;
    3975             :   }
    3976             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    3977           0 :   if (!check_term_argument(a[0], check_rule_RegFrm<atermpp::aterm>))
    3978             :   {
    3979           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_RegFrm" << std::endl;
    3980           0 :     return false;
    3981             :   }
    3982             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    3983             : 
    3984             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    3985           0 :   return true;
    3986             : }
    3987             : 
    3988             : // StateDelayTimed(DataExpr)
    3989             : template <typename Term>
    3990        9862 : bool check_term_StateDelayTimed(const Term& t)
    3991             : {
    3992        9862 :   utilities::mcrl2_unused(t);
    3993             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    3994             :   // check the type of the term
    3995        9862 :   const atermpp::aterm& term(t);
    3996        9862 :   if (!term.type_is_appl())
    3997             :   {
    3998           0 :     return false;
    3999             :   }
    4000        9862 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    4001        9862 :   if (a.function() != core::detail::function_symbols::StateDelayTimed)
    4002             :   {
    4003        9842 :     return false;
    4004             :   }
    4005             : 
    4006             :   // check the children
    4007          20 :   if (a.size() != 1)
    4008             :   {
    4009           0 :     return false;
    4010             :   }
    4011             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    4012          20 :   if (!check_term_argument(a[0], check_rule_DataExpr<atermpp::aterm>))
    4013             :   {
    4014           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_DataExpr" << std::endl;
    4015           0 :     return false;
    4016             :   }
    4017             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    4018             : 
    4019             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    4020          20 :   return true;
    4021             : }
    4022             : 
    4023             : // Nu()
    4024             : template <typename Term>
    4025         829 : bool check_term_Nu(const Term& t)
    4026             : {
    4027         829 :   utilities::mcrl2_unused(t);
    4028             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    4029             :   // check the type of the term
    4030         829 :   const atermpp::aterm& term(t);
    4031         829 :   if (!term.type_is_appl())
    4032             :   {
    4033           0 :     return false;
    4034             :   }
    4035         829 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    4036         829 :   if (a.function() != core::detail::function_symbols::Nu)
    4037             :   {
    4038           0 :     return false;
    4039             :   }
    4040             : 
    4041             :   // check the children
    4042         829 :   if (a.size() != 0)
    4043             :   {
    4044           0 :     return false;
    4045             :   }
    4046             : 
    4047             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    4048         829 :   return true;
    4049             : }
    4050             : 
    4051             : // SortStruct(StructCons+)
    4052             : template <typename Term>
    4053   114846240 : bool check_term_SortStruct(const Term& t)
    4054             : {
    4055   114846240 :   utilities::mcrl2_unused(t);
    4056             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    4057             :   // check the type of the term
    4058   114846240 :   const atermpp::aterm& term(t);
    4059   114846240 :   if (!term.type_is_appl())
    4060             :   {
    4061           0 :     return false;
    4062             :   }
    4063   114846240 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    4064   114846240 :   if (a.function() != core::detail::function_symbols::SortStruct)
    4065             :   {
    4066   112108342 :     return false;
    4067             :   }
    4068             : 
    4069             :   // check the children
    4070     2737898 :   if (a.size() != 1)
    4071             :   {
    4072           0 :     return false;
    4073             :   }
    4074             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    4075     2737898 :   if (!check_list_argument(a[0], check_rule_StructCons<atermpp::aterm>, 1))
    4076             :   {
    4077           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_StructCons" << std::endl;
    4078           0 :     return false;
    4079             :   }
    4080             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    4081             : 
    4082             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    4083     2737898 :   return true;
    4084             : }
    4085             : 
    4086             : // AtTime(ProcExpr, DataExpr)
    4087             : template <typename Term>
    4088     1436639 : bool check_term_AtTime(const Term& t)
    4089             : {
    4090     1436639 :   utilities::mcrl2_unused(t);
    4091             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    4092             :   // check the type of the term
    4093     1436639 :   const atermpp::aterm& term(t);
    4094     1436639 :   if (!term.type_is_appl())
    4095             :   {
    4096           0 :     return false;
    4097             :   }
    4098     1436639 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    4099     1436639 :   if (a.function() != core::detail::function_symbols::AtTime)
    4100             :   {
    4101     1377109 :     return false;
    4102             :   }
    4103             : 
    4104             :   // check the children
    4105       59530 :   if (a.size() != 2)
    4106             :   {
    4107           0 :     return false;
    4108             :   }
    4109             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    4110       59530 :   if (!check_term_argument(a[0], check_rule_ProcExpr<atermpp::aterm>))
    4111             :   {
    4112           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_ProcExpr" << std::endl;
    4113           0 :     return false;
    4114             :   }
    4115       59530 :   if (!check_term_argument(a[1], check_rule_DataExpr<atermpp::aterm>))
    4116             :   {
    4117           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_DataExpr" << std::endl;
    4118           0 :     return false;
    4119             :   }
    4120             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    4121             : 
    4122             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    4123       59530 :   return true;
    4124             : }
    4125             : 
    4126             : // ActOr(ActFrm, ActFrm)
    4127             : template <typename Term>
    4128        8485 : bool check_term_ActOr(const Term& t)
    4129             : {
    4130        8485 :   utilities::mcrl2_unused(t);
    4131             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    4132             :   // check the type of the term
    4133        8485 :   const atermpp::aterm& term(t);
    4134        8485 :   if (!term.type_is_appl())
    4135             :   {
    4136           0 :     return false;
    4137             :   }
    4138        8485 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    4139        8485 :   if (a.function() != core::detail::function_symbols::ActOr)
    4140             :   {
    4141        8401 :     return false;
    4142             :   }
    4143             : 
    4144             :   // check the children
    4145          84 :   if (a.size() != 2)
    4146             :   {
    4147           0 :     return false;
    4148             :   }
    4149             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    4150          84 :   if (!check_term_argument(a[0], check_rule_ActFrm<atermpp::aterm>))
    4151             :   {
    4152           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_ActFrm" << std::endl;
    4153           0 :     return false;
    4154             :   }
    4155          84 :   if (!check_term_argument(a[1], check_rule_ActFrm<atermpp::aterm>))
    4156             :   {
    4157           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_ActFrm" << std::endl;
    4158           0 :     return false;
    4159             :   }
    4160             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    4161             : 
    4162             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    4163          84 :   return true;
    4164             : }
    4165             : 
    4166             : // Comm(CommExpr*, ProcExpr)
    4167             : template <typename Term>
    4168     1580407 : bool check_term_Comm(const Term& t)
    4169             : {
    4170     1580407 :   utilities::mcrl2_unused(t);
    4171             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    4172             :   // check the type of the term
    4173     1580407 :   const atermpp::aterm& term(t);
    4174     1580407 :   if (!term.type_is_appl())
    4175             :   {
    4176           0 :     return false;
    4177             :   }
    4178     1580407 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    4179     1580407 :   if (a.function() != core::detail::function_symbols::Comm)
    4180             :   {
    4181     1573659 :     return false;
    4182             :   }
    4183             : 
    4184             :   // check the children
    4185        6748 :   if (a.size() != 2)
    4186             :   {
    4187           0 :     return false;
    4188             :   }
    4189             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    4190        6748 :   if (!check_list_argument(a[0], check_rule_CommExpr<atermpp::aterm>, 0))
    4191             :   {
    4192           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_CommExpr" << std::endl;
    4193           0 :     return false;
    4194             :   }
    4195        6748 :   if (!check_term_argument(a[1], check_rule_ProcExpr<atermpp::aterm>))
    4196             :   {
    4197           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_ProcExpr" << std::endl;
    4198           0 :     return false;
    4199             :   }
    4200             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    4201             : 
    4202             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    4203        6748 :   return true;
    4204             : }
    4205             : 
    4206             : // BooleanNot(BooleanExpression)
    4207             : template <typename Term>
    4208         190 : bool check_term_BooleanNot(const Term& t)
    4209             : {
    4210         190 :   utilities::mcrl2_unused(t);
    4211             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    4212             :   // check the type of the term
    4213         190 :   const atermpp::aterm& term(t);
    4214         190 :   if (!term.type_is_appl())
    4215             :   {
    4216           0 :     return false;
    4217             :   }
    4218         190 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    4219         190 :   if (a.function() != core::detail::function_symbols::BooleanNot)
    4220             :   {
    4221         189 :     return false;
    4222             :   }
    4223             : 
    4224             :   // check the children
    4225           1 :   if (a.size() != 1)
    4226             :   {
    4227           0 :     return false;
    4228             :   }
    4229             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    4230           1 :   if (!check_term_argument(a[0], check_rule_BooleanExpression<atermpp::aterm>))
    4231             :   {
    4232           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_BooleanExpression" << std::endl;
    4233           0 :     return false;
    4234             :   }
    4235             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    4236             : 
    4237             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    4238           1 :   return true;
    4239             : }
    4240             : 
    4241             : // Delta()
    4242             : template <typename Term>
    4243     1722694 : bool check_term_Delta(const Term& t)
    4244             : {
    4245     1722694 :   utilities::mcrl2_unused(t);
    4246             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    4247             :   // check the type of the term
    4248     1722694 :   const atermpp::aterm& term(t);
    4249     1722694 :   if (!term.type_is_appl())
    4250             :   {
    4251           0 :     return false;
    4252             :   }
    4253     1722694 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    4254     1722694 :   if (a.function() != core::detail::function_symbols::Delta)
    4255             :   {
    4256     1678175 :     return false;
    4257             :   }
    4258             : 
    4259             :   // check the children
    4260       44519 :   if (a.size() != 0)
    4261             :   {
    4262           0 :     return false;
    4263             :   }
    4264             : 
    4265             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    4266       44519 :   return true;
    4267             : }
    4268             : 
    4269             : // ActMultAct(Action*)
    4270             : template <typename Term>
    4271        8250 : bool check_term_ActMultAct(const Term& t)
    4272             : {
    4273        8250 :   utilities::mcrl2_unused(t);
    4274             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    4275             :   // check the type of the term
    4276        8250 :   const atermpp::aterm& term(t);
    4277        8250 :   if (!term.type_is_appl())
    4278             :   {
    4279           0 :     return false;
    4280             :   }
    4281        8250 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    4282        8250 :   if (a.function() != core::detail::function_symbols::ActMultAct)
    4283             :   {
    4284        1749 :     return false;
    4285             :   }
    4286             : 
    4287             :   // check the children
    4288        6501 :   if (a.size() != 1)
    4289             :   {
    4290           0 :     return false;
    4291             :   }
    4292             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    4293        6501 :   if (!check_list_argument(a[0], check_rule_Action<atermpp::aterm>, 0))
    4294             :   {
    4295           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_Action" << std::endl;
    4296           0 :     return false;
    4297             :   }
    4298             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    4299             : 
    4300             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    4301        6501 :   return true;
    4302             : }
    4303             : 
    4304             : // StateAnd(StateFrm, StateFrm)
    4305             : template <typename Term>
    4306       23697 : bool check_term_StateAnd(const Term& t)
    4307             : {
    4308       23697 :   utilities::mcrl2_unused(t);
    4309             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    4310             :   // check the type of the term
    4311       23697 :   const atermpp::aterm& term(t);
    4312       23697 :   if (!term.type_is_appl())
    4313             :   {
    4314           0 :     return false;
    4315             :   }
    4316       23697 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    4317       23697 :   if (a.function() != core::detail::function_symbols::StateAnd)
    4318             :   {
    4319       20549 :     return false;
    4320             :   }
    4321             : 
    4322             :   // check the children
    4323        3148 :   if (a.size() != 2)
    4324             :   {
    4325           0 :     return false;
    4326             :   }
    4327             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    4328        3148 :   if (!check_term_argument(a[0], check_rule_StateFrm<atermpp::aterm>))
    4329             :   {
    4330           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_StateFrm" << std::endl;
    4331           0 :     return false;
    4332             :   }
    4333        3148 :   if (!check_term_argument(a[1], check_rule_StateFrm<atermpp::aterm>))
    4334             :   {
    4335           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_StateFrm" << std::endl;
    4336           0 :     return false;
    4337             :   }
    4338             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    4339             : 
    4340             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    4341        3148 :   return true;
    4342             : }
    4343             : 
    4344             : // LMerge(ProcExpr, ProcExpr)
    4345             : template <typename Term>
    4346      326649 : bool check_term_LMerge(const Term& t)
    4347             : {
    4348      326649 :   utilities::mcrl2_unused(t);
    4349             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    4350             :   // check the type of the term
    4351      326649 :   const atermpp::aterm& term(t);
    4352      326649 :   if (!term.type_is_appl())
    4353             :   {
    4354           0 :     return false;
    4355             :   }
    4356      326649 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    4357      326649 :   if (a.function() != core::detail::function_symbols::LMerge)
    4358             :   {
    4359      326649 :     return false;
    4360             :   }
    4361             : 
    4362             :   // check the children
    4363           0 :   if (a.size() != 2)
    4364             :   {
    4365           0 :     return false;
    4366             :   }
    4367             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    4368           0 :   if (!check_term_argument(a[0], check_rule_ProcExpr<atermpp::aterm>))
    4369             :   {
    4370           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_ProcExpr" << std::endl;
    4371           0 :     return false;
    4372             :   }
    4373           0 :   if (!check_term_argument(a[1], check_rule_ProcExpr<atermpp::aterm>))
    4374             :   {
    4375           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_ProcExpr" << std::endl;
    4376           0 :     return false;
    4377             :   }
    4378             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    4379             : 
    4380             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    4381           0 :   return true;
    4382             : }
    4383             : 
    4384             : // SetComp()
    4385             : template <typename Term>
    4386       94367 : bool check_term_SetComp(const Term& t)
    4387             : {
    4388       94367 :   utilities::mcrl2_unused(t);
    4389             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    4390             :   // check the type of the term
    4391       94367 :   const atermpp::aterm& term(t);
    4392       94367 :   if (!term.type_is_appl())
    4393             :   {
    4394           0 :     return false;
    4395             :   }
    4396       94367 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    4397       94367 :   if (a.function() != core::detail::function_symbols::SetComp)
    4398             :   {
    4399       94226 :     return false;
    4400             :   }
    4401             : 
    4402             :   // check the children
    4403         141 :   if (a.size() != 0)
    4404             :   {
    4405           0 :     return false;
    4406             :   }
    4407             : 
    4408             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    4409         141 :   return true;
    4410             : }
    4411             : 
    4412             : // ActForall(DataVarId+, ActFrm)
    4413             : template <typename Term>
    4414        8401 : bool check_term_ActForall(const Term& t)
    4415             : {
    4416        8401 :   utilities::mcrl2_unused(t);
    4417             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    4418             :   // check the type of the term
    4419        8401 :   const atermpp::aterm& term(t);
    4420        8401 :   if (!term.type_is_appl())
    4421             :   {
    4422           0 :     return false;
    4423             :   }
    4424        8401 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    4425        8401 :   if (a.function() != core::detail::function_symbols::ActForall)
    4426             :   {
    4427        8299 :     return false;
    4428             :   }
    4429             : 
    4430             :   // check the children
    4431         102 :   if (a.size() != 2)
    4432             :   {
    4433           0 :     return false;
    4434             :   }
    4435             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    4436         102 :   if (!check_list_argument(a[0], check_rule_DataVarId<atermpp::aterm>, 1))
    4437             :   {
    4438           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_DataVarId" << std::endl;
    4439           0 :     return false;
    4440             :   }
    4441         102 :   if (!check_term_argument(a[1], check_rule_ActFrm<atermpp::aterm>))
    4442             :   {
    4443           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_ActFrm" << std::endl;
    4444           0 :     return false;
    4445             :   }
    4446             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    4447             : 
    4448             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    4449         102 :   return true;
    4450             : }
    4451             : 
    4452             : // RenameExpr(String, String)
    4453             : template <typename Term>
    4454           0 : bool check_term_RenameExpr(const Term& t)
    4455             : {
    4456           0 :   utilities::mcrl2_unused(t);
    4457             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    4458             :   // check the type of the term
    4459           0 :   const atermpp::aterm& term(t);
    4460           0 :   if (!term.type_is_appl())
    4461             :   {
    4462           0 :     return false;
    4463             :   }
    4464           0 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    4465           0 :   if (a.function() != core::detail::function_symbols::RenameExpr)
    4466             :   {
    4467           0 :     return false;
    4468             :   }
    4469             : 
    4470             :   // check the children
    4471           0 :   if (a.size() != 2)
    4472             :   {
    4473           0 :     return false;
    4474             :   }
    4475             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    4476           0 :   if (!check_term_argument(a[0], check_rule_String<atermpp::aterm>))
    4477             :   {
    4478           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_String" << std::endl;
    4479           0 :     return false;
    4480             :   }
    4481           0 :   if (!check_term_argument(a[1], check_rule_String<atermpp::aterm>))
    4482             :   {
    4483           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_String" << std::endl;
    4484           0 :     return false;
    4485             :   }
    4486             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    4487             : 
    4488             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    4489           0 :   return true;
    4490             : }
    4491             : 
    4492             : // Merge(ProcExpr, ProcExpr)
    4493             : template <typename Term>
    4494      378938 : bool check_term_Merge(const Term& t)
    4495             : {
    4496      378938 :   utilities::mcrl2_unused(t);
    4497             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    4498             :   // check the type of the term
    4499      378938 :   const atermpp::aterm& term(t);
    4500      378938 :   if (!term.type_is_appl())
    4501             :   {
    4502           0 :     return false;
    4503             :   }
    4504      378938 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    4505      378938 :   if (a.function() != core::detail::function_symbols::Merge)
    4506             :   {
    4507      326649 :     return false;
    4508             :   }
    4509             : 
    4510             :   // check the children
    4511       52289 :   if (a.size() != 2)
    4512             :   {
    4513           0 :     return false;
    4514             :   }
    4515             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    4516       52289 :   if (!check_term_argument(a[0], check_rule_ProcExpr<atermpp::aterm>))
    4517             :   {
    4518           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_ProcExpr" << std::endl;
    4519           0 :     return false;
    4520             :   }
    4521       52289 :   if (!check_term_argument(a[1], check_rule_ProcExpr<atermpp::aterm>))
    4522             :   {
    4523           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_ProcExpr" << std::endl;
    4524           0 :     return false;
    4525             :   }
    4526             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    4527             : 
    4528             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    4529       52289 :   return true;
    4530             : }
    4531             : 
    4532             : // ActSpec(ActId*)
    4533             : template <typename Term>
    4534           5 : bool check_term_ActSpec(const Term& t)
    4535             : {
    4536           5 :   utilities::mcrl2_unused(t);
    4537             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    4538             :   // check the type of the term
    4539           5 :   const atermpp::aterm& term(t);
    4540           5 :   if (!term.type_is_appl())
    4541             :   {
    4542           0 :     return false;
    4543             :   }
    4544           5 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    4545           5 :   if (a.function() != core::detail::function_symbols::ActSpec)
    4546             :   {
    4547           0 :     return false;
    4548             :   }
    4549             : 
    4550             :   // check the children
    4551           5 :   if (a.size() != 1)
    4552             :   {
    4553           0 :     return false;
    4554             :   }
    4555             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    4556           5 :   if (!check_list_argument(a[0], check_rule_ActId<atermpp::aterm>, 0))
    4557             :   {
    4558           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_ActId" << std::endl;
    4559           0 :     return false;
    4560             :   }
    4561             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    4562             : 
    4563             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    4564           5 :   return true;
    4565             : }
    4566             : 
    4567             : // BooleanVariable(String, Number)
    4568             : template <typename Term>
    4569        1134 : bool check_term_BooleanVariable(const Term& t)
    4570             : {
    4571        1134 :   utilities::mcrl2_unused(t);
    4572             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    4573             :   // check the type of the term
    4574        1134 :   const atermpp::aterm& term(t);
    4575        1134 :   if (!term.type_is_appl())
    4576             :   {
    4577           0 :     return false;
    4578             :   }
    4579        1134 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    4580        1134 :   if (a.function() != core::detail::function_symbols::BooleanVariable)
    4581             :   {
    4582         190 :     return false;
    4583             :   }
    4584             : 
    4585             :   // check the children
    4586         944 :   if (a.size() != 2)
    4587             :   {
    4588           0 :     return false;
    4589             :   }
    4590             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    4591         944 :   if (!check_term_argument(a[0], check_rule_String<atermpp::aterm>))
    4592             :   {
    4593           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_String" << std::endl;
    4594           0 :     return false;
    4595             :   }
    4596         944 :   if (!check_term_argument(a[1], check_rule_Number<atermpp::aterm>))
    4597             :   {
    4598           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_Number" << std::endl;
    4599           0 :     return false;
    4600             :   }
    4601             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    4602             : 
    4603             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    4604         944 :   return true;
    4605             : }
    4606             : 
    4607             : // Action(ActId, DataExpr*)
    4608             : template <typename Term>
    4609     3629299 : bool check_term_Action(const Term& t)
    4610             : {
    4611     3629299 :   utilities::mcrl2_unused(t);
    4612             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    4613             :   // check the type of the term
    4614     3629299 :   const atermpp::aterm& term(t);
    4615     3629299 :   if (!term.type_is_appl())
    4616             :   {
    4617           0 :     return false;
    4618             :   }
    4619     3629299 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    4620     3629299 :   if (a.function() != core::detail::function_symbols::Action)
    4621             :   {
    4622     2609901 :     return false;
    4623             :   }
    4624             : 
    4625             :   // check the children
    4626     1019398 :   if (a.size() != 2)
    4627             :   {
    4628           0 :     return false;
    4629             :   }
    4630             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    4631     1019398 :   if (!check_term_argument(a[0], check_rule_ActId<atermpp::aterm>))
    4632             :   {
    4633           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_ActId" << std::endl;
    4634           0 :     return false;
    4635             :   }
    4636     1019398 :   if (!check_list_argument(a[1], check_rule_DataExpr<atermpp::aterm>, 0))
    4637             :   {
    4638           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_DataExpr" << std::endl;
    4639           0 :     return false;
    4640             :   }
    4641             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    4642             : 
    4643             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    4644     1019398 :   return true;
    4645             : }
    4646             : 
    4647             : // PBESAnd(PBExpr, PBExpr)
    4648             : template <typename Term>
    4649      173105 : bool check_term_PBESAnd(const Term& t)
    4650             : {
    4651      173105 :   utilities::mcrl2_unused(t);
    4652             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    4653             :   // check the type of the term
    4654      173105 :   const atermpp::aterm& term(t);
    4655      173105 :   if (!term.type_is_appl())
    4656             :   {
    4657           0 :     return false;
    4658             :   }
    4659      173105 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    4660      173105 :   if (a.function() != core::detail::function_symbols::PBESAnd)
    4661             :   {
    4662      129058 :     return false;
    4663             :   }
    4664             : 
    4665             :   // check the children
    4666       44047 :   if (a.size() != 2)
    4667             :   {
    4668           0 :     return false;
    4669             :   }
    4670             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    4671       44047 :   if (!check_term_argument(a[0], check_rule_PBExpr<atermpp::aterm>))
    4672             :   {
    4673           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_PBExpr" << std::endl;
    4674           0 :     return false;
    4675             :   }
    4676       44047 :   if (!check_term_argument(a[1], check_rule_PBExpr<atermpp::aterm>))
    4677             :   {
    4678           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_PBExpr" << std::endl;
    4679           0 :     return false;
    4680             :   }
    4681             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    4682             : 
    4683             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    4684       44047 :   return true;
    4685             : }
    4686             : 
    4687             : // Lambda()
    4688             : template <typename Term>
    4689       94178 : bool check_term_Lambda(const Term& t)
    4690             : {
    4691       94178 :   utilities::mcrl2_unused(t);
    4692             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    4693             :   // check the type of the term
    4694       94178 :   const atermpp::aterm& term(t);
    4695       94178 :   if (!term.type_is_appl())
    4696             :   {
    4697           0 :     return false;
    4698             :   }
    4699       94178 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    4700       94178 :   if (a.function() != core::detail::function_symbols::Lambda)
    4701             :   {
    4702         108 :     return false;
    4703             :   }
    4704             : 
    4705             :   // check the children
    4706       94070 :   if (a.size() != 0)
    4707             :   {
    4708           0 :     return false;
    4709             :   }
    4710             : 
    4711             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    4712       94070 :   return true;
    4713             : }
    4714             : 
    4715             : // StateMust(RegFrm, StateFrm)
    4716             : template <typename Term>
    4717       18122 : bool check_term_StateMust(const Term& t)
    4718             : {
    4719       18122 :   utilities::mcrl2_unused(t);
    4720             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    4721             :   // check the type of the term
    4722       18122 :   const atermpp::aterm& term(t);
    4723       18122 :   if (!term.type_is_appl())
    4724             :   {
    4725           0 :     return false;
    4726             :   }
    4727       18122 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    4728       18122 :   if (a.function() != core::detail::function_symbols::StateMust)
    4729             :   {
    4730       13022 :     return false;
    4731             :   }
    4732             : 
    4733             :   // check the children
    4734        5100 :   if (a.size() != 2)
    4735             :   {
    4736           0 :     return false;
    4737             :   }
    4738             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    4739        5100 :   if (!check_term_argument(a[0], check_rule_RegFrm<atermpp::aterm>))
    4740             :   {
    4741           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_RegFrm" << std::endl;
    4742           0 :     return false;
    4743             :   }
    4744        5100 :   if (!check_term_argument(a[1], check_rule_StateFrm<atermpp::aterm>))
    4745             :   {
    4746           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_StateFrm" << std::endl;
    4747           0 :     return false;
    4748             :   }
    4749             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    4750             : 
    4751             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    4752        5100 :   return true;
    4753             : }
    4754             : 
    4755             : // Seq(ProcExpr, ProcExpr)
    4756             : template <typename Term>
    4757     1486159 : bool check_term_Seq(const Term& t)
    4758             : {
    4759     1486159 :   utilities::mcrl2_unused(t);
    4760             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    4761             :   // check the type of the term
    4762     1486159 :   const atermpp::aterm& term(t);
    4763     1486159 :   if (!term.type_is_appl())
    4764             :   {
    4765           0 :     return false;
    4766             :   }
    4767     1486159 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    4768     1486159 :   if (a.function() != core::detail::function_symbols::Seq)
    4769             :   {
    4770      687336 :     return false;
    4771             :   }
    4772             : 
    4773             :   // check the children
    4774      798823 :   if (a.size() != 2)
    4775             :   {
    4776           0 :     return false;
    4777             :   }
    4778             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    4779      798823 :   if (!check_term_argument(a[0], check_rule_ProcExpr<atermpp::aterm>))
    4780             :   {
    4781           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_ProcExpr" << std::endl;
    4782           0 :     return false;
    4783             :   }
    4784      798823 :   if (!check_term_argument(a[1], check_rule_ProcExpr<atermpp::aterm>))
    4785             :   {
    4786           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_ProcExpr" << std::endl;
    4787           0 :     return false;
    4788             :   }
    4789             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    4790             : 
    4791             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    4792      798823 :   return true;
    4793             : }
    4794             : 
    4795             : // DataVarIdInit(DataVarId, DataExpr)
    4796             : template <typename Term>
    4797      967589 : bool check_term_DataVarIdInit(const Term& t)
    4798             : {
    4799      967589 :   utilities::mcrl2_unused(t);
    4800             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    4801             :   // check the type of the term
    4802      967589 :   const atermpp::aterm& term(t);
    4803      967589 :   if (!term.type_is_appl())
    4804             :   {
    4805           0 :     return false;
    4806             :   }
    4807      967589 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    4808      967589 :   if (a.function() != core::detail::function_symbols::DataVarIdInit)
    4809             :   {
    4810        2468 :     return false;
    4811             :   }
    4812             : 
    4813             :   // check the children
    4814      965121 :   if (a.size() != 2)
    4815             :   {
    4816           0 :     return false;
    4817             :   }
    4818             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    4819      965121 :   if (!check_term_argument(a[0], check_rule_DataVarId<atermpp::aterm>))
    4820             :   {
    4821           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_DataVarId" << std::endl;
    4822           0 :     return false;
    4823             :   }
    4824      965121 :   if (!check_term_argument(a[1], check_rule_DataExpr<atermpp::aterm>))
    4825             :   {
    4826           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_DataExpr" << std::endl;
    4827           0 :     return false;
    4828             :   }
    4829             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    4830             : 
    4831             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    4832      965121 :   return true;
    4833             : }
    4834             : 
    4835             : // Process(ProcVarId, DataExpr*)
    4836             : template <typename Term>
    4837     2611659 : bool check_term_Process(const Term& t)
    4838             : {
    4839     2611659 :   utilities::mcrl2_unused(t);
    4840             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    4841             :   // check the type of the term
    4842     2611659 :   const atermpp::aterm& term(t);
    4843     2611659 :   if (!term.type_is_appl())
    4844             :   {
    4845           0 :     return false;
    4846             :   }
    4847     2611659 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    4848     2611659 :   if (a.function() != core::detail::function_symbols::Process)
    4849             :   {
    4850     2512641 :     return false;
    4851             :   }
    4852             : 
    4853             :   // check the children
    4854       99018 :   if (a.size() != 2)
    4855             :   {
    4856           0 :     return false;
    4857             :   }
    4858             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    4859       99018 :   if (!check_term_argument(a[0], check_rule_ProcVarId<atermpp::aterm>))
    4860             :   {
    4861           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_ProcVarId" << std::endl;
    4862           0 :     return false;
    4863             :   }
    4864       99018 :   if (!check_list_argument(a[1], check_rule_DataExpr<atermpp::aterm>, 0))
    4865             :   {
    4866           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_DataExpr" << std::endl;
    4867           0 :     return false;
    4868             :   }
    4869             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    4870             : 
    4871             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    4872       99018 :   return true;
    4873             : }
    4874             : 
    4875             : // TimedMultAct(Action*, DataExpr)
    4876             : template <typename Term>
    4877             : bool check_term_TimedMultAct(const Term& t)
    4878             : {
    4879             :   utilities::mcrl2_unused(t);
    4880             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    4881             :   // check the type of the term
    4882             :   const atermpp::aterm& term(t);
    4883             :   if (!term.type_is_appl())
    4884             :   {
    4885             :     return false;
    4886             :   }
    4887             :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    4888             :   if (a.function() != core::detail::function_symbols::TimedMultAct)
    4889             :   {
    4890             :     return false;
    4891             :   }
    4892             : 
    4893             :   // check the children
    4894             :   if (a.size() != 2)
    4895             :   {
    4896             :     return false;
    4897             :   }
    4898             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    4899             :   if (!check_list_argument(a[0], check_rule_Action<atermpp::aterm>, 0))
    4900             :   {
    4901             :     mCRL2log(log::debug, "soundness_checks") << "check_rule_Action" << std::endl;
    4902             :     return false;
    4903             :   }
    4904             :   if (!check_term_argument(a[1], check_rule_DataExpr<atermpp::aterm>))
    4905             :   {
    4906             :     mCRL2log(log::debug, "soundness_checks") << "check_rule_DataExpr" << std::endl;
    4907             :     return false;
    4908             :   }
    4909             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    4910             : 
    4911             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    4912             :   return true;
    4913             : }
    4914             : 
    4915             : // ActionRenameSpec(DataSpec, ActSpec, ActionRenameRules)
    4916             : template <typename Term>
    4917             : bool check_term_ActionRenameSpec(const Term& t)
    4918             : {
    4919             :   utilities::mcrl2_unused(t);
    4920             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    4921             :   // check the type of the term
    4922             :   const atermpp::aterm& term(t);
    4923             :   if (!term.type_is_appl())
    4924             :   {
    4925             :     return false;
    4926             :   }
    4927             :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    4928             :   if (a.function() != core::detail::function_symbols::ActionRenameSpec)
    4929             :   {
    4930             :     return false;
    4931             :   }
    4932             : 
    4933             :   // check the children
    4934             :   if (a.size() != 3)
    4935             :   {
    4936             :     return false;
    4937             :   }
    4938             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    4939             :   if (!check_term_argument(a[0], check_rule_DataSpec<atermpp::aterm>))
    4940             :   {
    4941             :     mCRL2log(log::debug, "soundness_checks") << "check_rule_DataSpec" << std::endl;
    4942             :     return false;
    4943             :   }
    4944             :   if (!check_term_argument(a[1], check_rule_ActSpec<atermpp::aterm>))
    4945             :   {
    4946             :     mCRL2log(log::debug, "soundness_checks") << "check_rule_ActSpec" << std::endl;
    4947             :     return false;
    4948             :   }
    4949             :   if (!check_term_argument(a[2], check_rule_ActionRenameRules<atermpp::aterm>))
    4950             :   {
    4951             :     mCRL2log(log::debug, "soundness_checks") << "check_rule_ActionRenameRules" << std::endl;
    4952             :     return false;
    4953             :   }
    4954             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    4955             : 
    4956             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    4957             :   return true;
    4958             : }
    4959             : 
    4960             : // PBES(DataSpec, GlobVarSpec, PBEqnSpec, PBInit)
    4961             : template <typename Term>
    4962         171 : bool check_term_PBES(const Term& t)
    4963             : {
    4964         171 :   utilities::mcrl2_unused(t);
    4965             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    4966             :   // check the type of the term
    4967         171 :   const atermpp::aterm& term(t);
    4968         171 :   if (!term.type_is_appl())
    4969             :   {
    4970           0 :     return false;
    4971             :   }
    4972         171 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    4973         171 :   if (a.function() != core::detail::function_symbols::PBES)
    4974             :   {
    4975           0 :     return false;
    4976             :   }
    4977             : 
    4978             :   // check the children
    4979         171 :   if (a.size() != 4)
    4980             :   {
    4981           0 :     return false;
    4982             :   }
    4983             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    4984         171 :   if (!check_term_argument(a[0], check_rule_DataSpec<atermpp::aterm>))
    4985             :   {
    4986           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_DataSpec" << std::endl;
    4987           0 :     return false;
    4988             :   }
    4989         171 :   if (!check_term_argument(a[1], check_rule_GlobVarSpec<atermpp::aterm>))
    4990             :   {
    4991           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_GlobVarSpec" << std::endl;
    4992           0 :     return false;
    4993             :   }
    4994         171 :   if (!check_term_argument(a[2], check_rule_PBEqnSpec<atermpp::aterm>))
    4995             :   {
    4996           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_PBEqnSpec" << std::endl;
    4997           0 :     return false;
    4998             :   }
    4999         171 :   if (!check_term_argument(a[3], check_rule_PBInit<atermpp::aterm>))
    5000             :   {
    5001           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_PBInit" << std::endl;
    5002           0 :     return false;
    5003             :   }
    5004             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    5005             : 
    5006             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    5007         171 :   return true;
    5008             : }
    5009             : 
    5010             : // StateVar(String, DataExpr*)
    5011             : template <typename Term>
    5012        9842 : bool check_term_StateVar(const Term& t)
    5013             : {
    5014        9842 :   utilities::mcrl2_unused(t);
    5015             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    5016             :   // check the type of the term
    5017        9842 :   const atermpp::aterm& term(t);
    5018        9842 :   if (!term.type_is_appl())
    5019             :   {
    5020           0 :     return false;
    5021             :   }
    5022        9842 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    5023        9842 :   if (a.function() != core::detail::function_symbols::StateVar)
    5024             :   {
    5025        4726 :     return false;
    5026             :   }
    5027             : 
    5028             :   // check the children
    5029        5116 :   if (a.size() != 2)
    5030             :   {
    5031           0 :     return false;
    5032             :   }
    5033             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    5034        5116 :   if (!check_term_argument(a[0], check_rule_String<atermpp::aterm>))
    5035             :   {
    5036           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_String" << std::endl;
    5037           0 :     return false;
    5038             :   }
    5039        5116 :   if (!check_list_argument(a[1], check_rule_DataExpr<atermpp::aterm>, 0))
    5040             :   {
    5041           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_DataExpr" << std::endl;
    5042           0 :     return false;
    5043             :   }
    5044             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    5045             : 
    5046             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    5047        5116 :   return true;
    5048             : }
    5049             : 
    5050             : // ActionRenameRule(DataVarId*, DataExpr, ParamIdOrAction, ActionRenameRuleRHS)
    5051             : template <typename Term>
    5052             : bool check_term_ActionRenameRule(const Term& t)
    5053             : {
    5054             :   utilities::mcrl2_unused(t);
    5055             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    5056             :   // check the type of the term
    5057             :   const atermpp::aterm& term(t);
    5058             :   if (!term.type_is_appl())
    5059             :   {
    5060             :     return false;
    5061             :   }
    5062             :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    5063             :   if (a.function() != core::detail::function_symbols::ActionRenameRule)
    5064             :   {
    5065             :     return false;
    5066             :   }
    5067             : 
    5068             :   // check the children
    5069             :   if (a.size() != 4)
    5070             :   {
    5071             :     return false;
    5072             :   }
    5073             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    5074             :   if (!check_list_argument(a[0], check_rule_DataVarId<atermpp::aterm>, 0))
    5075             :   {
    5076             :     mCRL2log(log::debug, "soundness_checks") << "check_rule_DataVarId" << std::endl;
    5077             :     return false;
    5078             :   }
    5079             :   if (!check_term_argument(a[1], check_rule_DataExpr<atermpp::aterm>))
    5080             :   {
    5081             :     mCRL2log(log::debug, "soundness_checks") << "check_rule_DataExpr" << std::endl;
    5082             :     return false;
    5083             :   }
    5084             :   if (!check_term_argument(a[2], check_rule_ParamIdOrAction<atermpp::aterm>))
    5085             :   {
    5086             :     mCRL2log(log::debug, "soundness_checks") << "check_rule_ParamIdOrAction" << std::endl;
    5087             :     return false;
    5088             :   }
    5089             :   if (!check_term_argument(a[3], check_rule_ActionRenameRuleRHS<atermpp::aterm>))
    5090             :   {
    5091             :     mCRL2log(log::debug, "soundness_checks") << "check_rule_ActionRenameRuleRHS" << std::endl;
    5092             :     return false;
    5093             :   }
    5094             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    5095             : 
    5096             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    5097             :   return true;
    5098             : }
    5099             : 
    5100             : // RegSeq(RegFrm, RegFrm)
    5101             : template <typename Term>
    5102         385 : bool check_term_RegSeq(const Term& t)
    5103             : {
    5104         385 :   utilities::mcrl2_unused(t);
    5105             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    5106             :   // check the type of the term
    5107         385 :   const atermpp::aterm& term(t);
    5108         385 :   if (!term.type_is_appl())
    5109             :   {
    5110           0 :     return false;
    5111             :   }
    5112         385 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    5113         385 :   if (a.function() != core::detail::function_symbols::RegSeq)
    5114             :   {
    5115         355 :     return false;
    5116             :   }
    5117             : 
    5118             :   // check the children
    5119          30 :   if (a.size() != 2)
    5120             :   {
    5121           0 :     return false;
    5122             :   }
    5123             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    5124          30 :   if (!check_term_argument(a[0], check_rule_RegFrm<atermpp::aterm>))
    5125             :   {
    5126           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_RegFrm" << std::endl;
    5127           0 :     return false;
    5128             :   }
    5129          30 :   if (!check_term_argument(a[1], check_rule_RegFrm<atermpp::aterm>))
    5130             :   {
    5131           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_RegFrm" << std::endl;
    5132           0 :     return false;
    5133             :   }
    5134             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    5135             : 
    5136             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    5137          30 :   return true;
    5138             : }
    5139             : 
    5140             : // ActNot(ActFrm)
    5141             : template <typename Term>
    5142       10814 : bool check_term_ActNot(const Term& t)
    5143             : {
    5144       10814 :   utilities::mcrl2_unused(t);
    5145             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    5146             :   // check the type of the term
    5147       10814 :   const atermpp::aterm& term(t);
    5148       10814 :   if (!term.type_is_appl())
    5149             :   {
    5150           0 :     return false;
    5151             :   }
    5152       10814 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    5153       10814 :   if (a.function() != core::detail::function_symbols::ActNot)
    5154             :   {
    5155        8828 :     return false;
    5156             :   }
    5157             : 
    5158             :   // check the children
    5159        1986 :   if (a.size() != 1)
    5160             :   {
    5161           0 :     return false;
    5162             :   }
    5163             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    5164        1986 :   if (!check_term_argument(a[0], check_rule_ActFrm<atermpp::aterm>))
    5165             :   {
    5166           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_ActFrm" << std::endl;
    5167           0 :     return false;
    5168             :   }
    5169             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    5170             : 
    5171             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    5172        1986 :   return true;
    5173             : }
    5174             : 
    5175             : // LinearProcess(DataVarId*, LinearProcessSummand*)
    5176             : template <typename Term>
    5177          10 : bool check_term_LinearProcess(const Term& t)
    5178             : {
    5179          10 :   utilities::mcrl2_unused(t);
    5180             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    5181             :   // check the type of the term
    5182          10 :   const atermpp::aterm& term(t);
    5183          10 :   if (!term.type_is_appl())
    5184             :   {
    5185           0 :     return false;
    5186             :   }
    5187          10 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    5188          10 :   if (a.function() != core::detail::function_symbols::LinearProcess)
    5189             :   {
    5190           0 :     return false;
    5191             :   }
    5192             : 
    5193             :   // check the children
    5194          10 :   if (a.size() != 2)
    5195             :   {
    5196           0 :     return false;
    5197             :   }
    5198             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    5199          10 :   if (!check_list_argument(a[0], check_rule_DataVarId<atermpp::aterm>, 0))
    5200             :   {
    5201           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_DataVarId" << std::endl;
    5202           0 :     return false;
    5203             :   }
    5204          10 :   if (!check_list_argument(a[1], check_rule_LinearProcessSummand<atermpp::aterm>, 0))
    5205             :   {
    5206           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_LinearProcessSummand" << std::endl;
    5207           0 :     return false;
    5208             :   }
    5209             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    5210             : 
    5211             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    5212          10 :   return true;
    5213             : }
    5214             : 
    5215             : // ActAt(ActFrm, DataExpr)
    5216             : template <typename Term>
    5217        8250 : bool check_term_ActAt(const Term& t)
    5218             : {
    5219        8250 :   utilities::mcrl2_unused(t);
    5220             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    5221             :   // check the type of the term
    5222        8250 :   const atermpp::aterm& term(t);
    5223        8250 :   if (!term.type_is_appl())
    5224             :   {
    5225           0 :     return false;
    5226             :   }
    5227        8250 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    5228        8250 :   if (a.function() != core::detail::function_symbols::ActAt)
    5229             :   {
    5230        8250 :     return false;
    5231             :   }
    5232             : 
    5233             :   // check the children
    5234           0 :   if (a.size() != 2)
    5235             :   {
    5236           0 :     return false;
    5237             :   }
    5238             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    5239           0 :   if (!check_term_argument(a[0], check_rule_ActFrm<atermpp::aterm>))
    5240             :   {
    5241           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_ActFrm" << std::endl;
    5242           0 :     return false;
    5243             :   }
    5244           0 :   if (!check_term_argument(a[1], check_rule_DataExpr<atermpp::aterm>))
    5245             :   {
    5246           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_DataExpr" << std::endl;
    5247           0 :     return false;
    5248             :   }
    5249             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    5250             : 
    5251             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    5252           0 :   return true;
    5253             : }
    5254             : 
    5255             : // DataEqn(DataVarId*, DataExpr, DataExpr, DataExpr)
    5256             : template <typename Term>
    5257         125 : bool check_term_DataEqn(const Term& t)
    5258             : {
    5259         125 :   utilities::mcrl2_unused(t);
    5260             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    5261             :   // check the type of the term
    5262         125 :   const atermpp::aterm& term(t);
    5263         125 :   if (!term.type_is_appl())
    5264             :   {
    5265           0 :     return false;
    5266             :   }
    5267         125 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    5268         125 :   if (a.function() != core::detail::function_symbols::DataEqn)
    5269             :   {
    5270           0 :     return false;
    5271             :   }
    5272             : 
    5273             :   // check the children
    5274         125 :   if (a.size() != 4)
    5275             :   {
    5276           0 :     return false;
    5277             :   }
    5278             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    5279         125 :   if (!check_list_argument(a[0], check_rule_DataVarId<atermpp::aterm>, 0))
    5280             :   {
    5281           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_DataVarId" << std::endl;
    5282           0 :     return false;
    5283             :   }
    5284         125 :   if (!check_term_argument(a[1], check_rule_DataExpr<atermpp::aterm>))
    5285             :   {
    5286           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_DataExpr" << std::endl;
    5287           0 :     return false;
    5288             :   }
    5289         125 :   if (!check_term_argument(a[2], check_rule_DataExpr<atermpp::aterm>))
    5290             :   {
    5291           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_DataExpr" << std::endl;
    5292           0 :     return false;
    5293             :   }
    5294         125 :   if (!check_term_argument(a[3], check_rule_DataExpr<atermpp::aterm>))
    5295             :   {
    5296           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_DataExpr" << std::endl;
    5297           0 :     return false;
    5298             :   }
    5299             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    5300             : 
    5301             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    5302         125 :   return true;
    5303             : }
    5304             : 
    5305             : // PBESNot(PBExpr)
    5306             : template <typename Term>
    5307      177529 : bool check_term_PBESNot(const Term& t)
    5308             : {
    5309      177529 :   utilities::mcrl2_unused(t);
    5310             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    5311             :   // check the type of the term
    5312      177529 :   const atermpp::aterm& term(t);
    5313      177529 :   if (!term.type_is_appl())
    5314             :   {
    5315           0 :     return false;
    5316             :   }
    5317      177529 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    5318      177529 :   if (a.function() != core::detail::function_symbols::PBESNot)
    5319             :   {
    5320      173105 :     return false;
    5321             :   }
    5322             : 
    5323             :   // check the children
    5324        4424 :   if (a.size() != 1)
    5325             :   {
    5326           0 :     return false;
    5327             :   }
    5328             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    5329        4424 :   if (!check_term_argument(a[0], check_rule_PBExpr<atermpp::aterm>))
    5330             :   {
    5331           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_PBExpr" << std::endl;
    5332           0 :     return false;
    5333             :   }
    5334             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    5335             : 
    5336             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    5337        4424 :   return true;
    5338             : }
    5339             : 
    5340             : // StateExists(DataVarId+, StateFrm)
    5341             : template <typename Term>
    5342       17987 : bool check_term_StateExists(const Term& t)
    5343             : {
    5344       17987 :   utilities::mcrl2_unused(t);
    5345             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    5346             :   // check the type of the term
    5347       17987 :   const atermpp::aterm& term(t);
    5348       17987 :   if (!term.type_is_appl())
    5349             :   {
    5350           0 :     return false;
    5351             :   }
    5352       17987 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    5353       17987 :   if (a.function() != core::detail::function_symbols::StateExists)
    5354             :   {
    5355       17848 :     return false;
    5356             :   }
    5357             : 
    5358             :   // check the children
    5359         139 :   if (a.size() != 2)
    5360             :   {
    5361           0 :     return false;
    5362             :   }
    5363             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    5364         139 :   if (!check_list_argument(a[0], check_rule_DataVarId<atermpp::aterm>, 1))
    5365             :   {
    5366           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_DataVarId" << std::endl;
    5367           0 :     return false;
    5368             :   }
    5369         139 :   if (!check_term_argument(a[1], check_rule_StateFrm<atermpp::aterm>))
    5370             :   {
    5371           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_StateFrm" << std::endl;
    5372           0 :     return false;
    5373             :   }
    5374             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    5375             : 
    5376             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    5377         139 :   return true;
    5378             : }
    5379             : 
    5380             : // StateMay(RegFrm, StateFrm)
    5381             : template <typename Term>
    5382       13178 : bool check_term_StateMay(const Term& t)
    5383             : {
    5384       13178 :   utilities::mcrl2_unused(t);
    5385             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    5386             :   // check the type of the term
    5387       13178 :   const atermpp::aterm& term(t);
    5388       13178 :   if (!term.type_is_appl())
    5389             :   {
    5390           0 :     return false;
    5391             :   }
    5392       13178 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    5393       13178 :   if (a.function() != core::detail::function_symbols::StateMay)
    5394             :   {
    5395        9874 :     return false;
    5396             :   }
    5397             : 
    5398             :   // check the children
    5399        3304 :   if (a.size() != 2)
    5400             :   {
    5401           0 :     return false;
    5402             :   }
    5403             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    5404        3304 :   if (!check_term_argument(a[0], check_rule_RegFrm<atermpp::aterm>))
    5405             :   {
    5406           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_RegFrm" << std::endl;
    5407           0 :     return false;
    5408             :   }
    5409        3304 :   if (!check_term_argument(a[1], check_rule_StateFrm<atermpp::aterm>))
    5410             :   {
    5411           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_StateFrm" << std::endl;
    5412           0 :     return false;
    5413             :   }
    5414             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    5415             : 
    5416             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    5417        3304 :   return true;
    5418             : }
    5419             : 
    5420             : // PBESTrue()
    5421             : template <typename Term>
    5422      177529 : bool check_term_PBESTrue(const Term& t)
    5423             : {
    5424      177529 :   utilities::mcrl2_unused(t);
    5425             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    5426             :   // check the type of the term
    5427      177529 :   const atermpp::aterm& term(t);
    5428      177529 :   if (!term.type_is_appl())
    5429             :   {
    5430           0 :     return false;
    5431             :   }
    5432      177529 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    5433      177529 :   if (a.function() != core::detail::function_symbols::PBESTrue)
    5434             :   {
    5435      177529 :     return false;
    5436             :   }
    5437             : 
    5438             :   // check the children
    5439           0 :   if (a.size() != 0)
    5440             :   {
    5441           0 :     return false;
    5442             :   }
    5443             : 
    5444             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    5445           0 :   return true;
    5446             : }
    5447             : 
    5448             : // MultActName(String+)
    5449             : template <typename Term>
    5450      354233 : bool check_term_MultActName(const Term& t)
    5451             : {
    5452      354233 :   utilities::mcrl2_unused(t);
    5453             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    5454             :   // check the type of the term
    5455      354233 :   const atermpp::aterm& term(t);
    5456      354233 :   if (!term.type_is_appl())
    5457             :   {
    5458           0 :     return false;
    5459             :   }
    5460      354233 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    5461      354233 :   if (a.function() != core::detail::function_symbols::MultActName)
    5462             :   {
    5463           0 :     return false;
    5464             :   }
    5465             : 
    5466             :   // check the children
    5467      354233 :   if (a.size() != 1)
    5468             :   {
    5469           0 :     return false;
    5470             :   }
    5471             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    5472      354233 :   if (!check_list_argument(a[0], check_rule_String<atermpp::aterm>, 1))
    5473             :   {
    5474           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_String" << std::endl;
    5475           0 :     return false;
    5476             :   }
    5477             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    5478             : 
    5479             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    5480      354233 :   return true;
    5481             : }
    5482             : 
    5483             : // IfThenElse(DataExpr, ProcExpr, ProcExpr)
    5484             : template <typename Term>
    5485      411951 : bool check_term_IfThenElse(const Term& t)
    5486             : {
    5487      411951 :   utilities::mcrl2_unused(t);
    5488             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    5489             :   // check the type of the term
    5490      411951 :   const atermpp::aterm& term(t);
    5491      411951 :   if (!term.type_is_appl())
    5492             :   {
    5493           0 :     return false;
    5494             :   }
    5495      411951 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    5496      411951 :   if (a.function() != core::detail::function_symbols::IfThenElse)
    5497             :   {
    5498      372358 :     return false;
    5499             :   }
    5500             : 
    5501             :   // check the children
    5502       39593 :   if (a.size() != 3)
    5503             :   {
    5504           0 :     return false;
    5505             :   }
    5506             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    5507       39593 :   if (!check_term_argument(a[0], check_rule_DataExpr<atermpp::aterm>))
    5508             :   {
    5509           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_DataExpr" << std::endl;
    5510           0 :     return false;
    5511             :   }
    5512       39593 :   if (!check_term_argument(a[1], check_rule_ProcExpr<atermpp::aterm>))
    5513             :   {
    5514           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_ProcExpr" << std::endl;
    5515           0 :     return false;
    5516             :   }
    5517       39593 :   if (!check_term_argument(a[2], check_rule_ProcExpr<atermpp::aterm>))
    5518             :   {
    5519           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_ProcExpr" << std::endl;
    5520           0 :     return false;
    5521             :   }
    5522             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    5523             : 
    5524             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    5525       39593 :   return true;
    5526             : }
    5527             : 
    5528             : // UntypedSortVariable(Number)
    5529             : template <typename Term>
    5530        1748 : bool check_term_UntypedSortVariable(const Term& t)
    5531             : {
    5532        1748 :   utilities::mcrl2_unused(t);
    5533             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    5534             :   // check the type of the term
    5535        1748 :   const atermpp::aterm& term(t);
    5536        1748 :   if (!term.type_is_appl())
    5537             :   {
    5538           0 :     return false;
    5539             :   }
    5540        1748 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    5541        1748 :   if (a.function() != core::detail::function_symbols::UntypedSortVariable)
    5542             :   {
    5543           0 :     return false;
    5544             :   }
    5545             : 
    5546             :   // check the children
    5547        1748 :   if (a.size() != 1)
    5548             :   {
    5549           0 :     return false;
    5550             :   }
    5551             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    5552        1748 :   if (!check_term_argument(a[0], check_rule_Number<atermpp::aterm>))
    5553             :   {
    5554           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_Number" << std::endl;
    5555           0 :     return false;
    5556             :   }
    5557             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    5558             : 
    5559             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    5560        1748 :   return true;
    5561             : }
    5562             : 
    5563             : // StateOr(StateFrm, StateFrm)
    5564             : template <typename Term>
    5565       20589 : bool check_term_StateOr(const Term& t)
    5566             : {
    5567       20589 :   utilities::mcrl2_unused(t);
    5568             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    5569             :   // check the type of the term
    5570       20589 :   const atermpp::aterm& term(t);
    5571       20589 :   if (!term.type_is_appl())
    5572             :   {
    5573           0 :     return false;
    5574             :   }
    5575       20589 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    5576       20589 :   if (a.function() != core::detail::function_symbols::StateOr)
    5577             :   {
    5578       19559 :     return false;
    5579             :   }
    5580             : 
    5581             :   // check the children
    5582        1030 :   if (a.size() != 2)
    5583             :   {
    5584           0 :     return false;
    5585             :   }
    5586             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    5587        1030 :   if (!check_term_argument(a[0], check_rule_StateFrm<atermpp::aterm>))
    5588             :   {
    5589           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_StateFrm" << std::endl;
    5590           0 :     return false;
    5591             :   }
    5592        1030 :   if (!check_term_argument(a[1], check_rule_StateFrm<atermpp::aterm>))
    5593             :   {
    5594           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_StateFrm" << std::endl;
    5595           0 :     return false;
    5596             :   }
    5597             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    5598             : 
    5599             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    5600        1030 :   return true;
    5601             : }
    5602             : 
    5603             : // StructProj(StringOrEmpty, SortExpr)
    5604             : template <typename Term>
    5605     1113807 : bool check_term_StructProj(const Term& t)
    5606             : {
    5607     1113807 :   utilities::mcrl2_unused(t);
    5608             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    5609             :   // check the type of the term
    5610     1113807 :   const atermpp::aterm& term(t);
    5611     1113807 :   if (!term.type_is_appl())
    5612             :   {
    5613           0 :     return false;
    5614             :   }
    5615     1113807 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    5616     1113807 :   if (a.function() != core::detail::function_symbols::StructProj)
    5617             :   {
    5618           0 :     return false;
    5619             :   }
    5620             : 
    5621             :   // check the children
    5622     1113807 :   if (a.size() != 2)
    5623             :   {
    5624           0 :     return false;
    5625             :   }
    5626             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    5627     1113807 :   if (!check_term_argument(a[0], check_rule_StringOrEmpty<atermpp::aterm>))
    5628             :   {
    5629           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_StringOrEmpty" << std::endl;
    5630           0 :     return false;
    5631             :   }
    5632     1113807 :   if (!check_term_argument(a[1], check_rule_SortExpr<atermpp::aterm>))
    5633             :   {
    5634           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_SortExpr" << std::endl;
    5635           0 :     return false;
    5636             :   }
    5637             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    5638             : 
    5639             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    5640     1113807 :   return true;
    5641             : }
    5642             : 
    5643             : // PBEqn(FixPoint, PropVarDecl, PBExpr)
    5644             : template <typename Term>
    5645         550 : bool check_term_PBEqn(const Term& t)
    5646             : {
    5647         550 :   utilities::mcrl2_unused(t);
    5648             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    5649             :   // check the type of the term
    5650         550 :   const atermpp::aterm& term(t);
    5651         550 :   if (!term.type_is_appl())
    5652             :   {
    5653           0 :     return false;
    5654             :   }
    5655         550 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    5656         550 :   if (a.function() != core::detail::function_symbols::PBEqn)
    5657             :   {
    5658           0 :     return false;
    5659             :   }
    5660             : 
    5661             :   // check the children
    5662         550 :   if (a.size() != 3)
    5663             :   {
    5664           0 :     return false;
    5665             :   }
    5666             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    5667         550 :   if (!check_term_argument(a[0], check_rule_FixPoint<atermpp::aterm>))
    5668             :   {
    5669           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_FixPoint" << std::endl;
    5670           0 :     return false;
    5671             :   }
    5672         550 :   if (!check_term_argument(a[1], check_rule_PropVarDecl<atermpp::aterm>))
    5673             :   {
    5674           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_PropVarDecl" << std::endl;
    5675           0 :     return false;
    5676             :   }
    5677         550 :   if (!check_term_argument(a[2], check_rule_PBExpr<atermpp::aterm>))
    5678             :   {
    5679           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_PBExpr" << std::endl;
    5680           0 :     return false;
    5681             :   }
    5682             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    5683             : 
    5684             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    5685         550 :   return true;
    5686             : }
    5687             : 
    5688             : // Whr(DataExpr, WhrDecl+)
    5689             : template <typename Term>
    5690      488052 : bool check_term_Whr(const Term& t)
    5691             : {
    5692      488052 :   utilities::mcrl2_unused(t);
    5693             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    5694             :   // check the type of the term
    5695      488052 :   const atermpp::aterm& term(t);
    5696      488052 :   if (!term.type_is_appl())
    5697             :   {
    5698           0 :     return false;
    5699             :   }
    5700      488052 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    5701      488052 :   if (a.function() != core::detail::function_symbols::Whr)
    5702             :   {
    5703      487543 :     return false;
    5704             :   }
    5705             : 
    5706             :   // check the children
    5707         509 :   if (a.size() != 2)
    5708             :   {
    5709           0 :     return false;
    5710             :   }
    5711             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    5712         509 :   if (!check_term_argument(a[0], check_rule_DataExpr<atermpp::aterm>))
    5713             :   {
    5714           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_DataExpr" << std::endl;
    5715           0 :     return false;
    5716             :   }
    5717         509 :   if (!check_list_argument(a[1], check_rule_WhrDecl<atermpp::aterm>, 1))
    5718             :   {
    5719           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_WhrDecl" << std::endl;
    5720           0 :     return false;
    5721             :   }
    5722             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    5723             : 
    5724             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    5725         509 :   return true;
    5726             : }
    5727             : 
    5728             : // OpId(String, SortExpr, Number)
    5729             : template <typename Term>
    5730   125855339 : bool check_term_OpId(const Term& t)
    5731             : {
    5732   125855339 :   utilities::mcrl2_unused(t);
    5733             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    5734             :   // check the type of the term
    5735   125855339 :   const atermpp::aterm& term(t);
    5736   125855339 :   if (!term.type_is_appl())
    5737             :   {
    5738           0 :     return false;
    5739             :   }
    5740   125855339 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    5741   125855339 :   if (a.function() != core::detail::function_symbols::OpId)
    5742             :   {
    5743    45349440 :     return false;
    5744             :   }
    5745             : 
    5746             :   // check the children
    5747    80505899 :   if (a.size() != 3)
    5748             :   {
    5749           0 :     return false;
    5750             :   }
    5751             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    5752    80505899 :   if (!check_term_argument(a[0], check_rule_String<atermpp::aterm>))
    5753             :   {
    5754           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_String" << std::endl;
    5755           0 :     return false;
    5756             :   }
    5757    80505899 :   if (!check_term_argument(a[1], check_rule_SortExpr<atermpp::aterm>))
    5758             :   {
    5759           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_SortExpr" << std::endl;
    5760           0 :     return false;
    5761             :   }
    5762    80505899 :   if (!check_term_argument(a[2], check_rule_Number<atermpp::aterm>))
    5763             :   {
    5764           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_Number" << std::endl;
    5765           0 :     return false;
    5766             :   }
    5767             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    5768             : 
    5769             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    5770    80505899 :   return true;
    5771             : }
    5772             : 
    5773             : // SortSet()
    5774             : template <typename Term>
    5775    10542514 : bool check_term_SortSet(const Term& t)
    5776             : {
    5777    10542514 :   utilities::mcrl2_unused(t);
    5778             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    5779             :   // check the type of the term
    5780    10542514 :   const atermpp::aterm& term(t);
    5781    10542514 :   if (!term.type_is_appl())
    5782             :   {
    5783           0 :     return false;
    5784             :   }
    5785    10542514 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    5786    10542514 :   if (a.function() != core::detail::function_symbols::SortSet)
    5787             :   {
    5788     8054623 :     return false;
    5789             :   }
    5790             : 
    5791             :   // check the children
    5792     2487891 :   if (a.size() != 0)
    5793             :   {
    5794           0 :     return false;
    5795             :   }
    5796             : 
    5797             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    5798     2487891 :   return true;
    5799             : }
    5800             : 
    5801             : // ActFalse()
    5802             : template <typename Term>
    5803       10814 : bool check_term_ActFalse(const Term& t)
    5804             : {
    5805       10814 :   utilities::mcrl2_unused(t);
    5806             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    5807             :   // check the type of the term
    5808       10814 :   const atermpp::aterm& term(t);
    5809       10814 :   if (!term.type_is_appl())
    5810             :   {
    5811           0 :     return false;
    5812             :   }
    5813       10814 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    5814       10814 :   if (a.function() != core::detail::function_symbols::ActFalse)
    5815             :   {
    5816       10814 :     return false;
    5817             :   }
    5818             : 
    5819             :   // check the children
    5820           0 :   if (a.size() != 0)
    5821             :   {
    5822           0 :     return false;
    5823             :   }
    5824             : 
    5825             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    5826           0 :   return true;
    5827             : }
    5828             : 
    5829             : // ActId(String, SortExpr*)
    5830             : template <typename Term>
    5831     1019450 : bool check_term_ActId(const Term& t)
    5832             : {
    5833     1019450 :   utilities::mcrl2_unused(t);
    5834             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    5835             :   // check the type of the term
    5836     1019450 :   const atermpp::aterm& term(t);
    5837     1019450 :   if (!term.type_is_appl())
    5838             :   {
    5839           0 :     return false;
    5840             :   }
    5841     1019450 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    5842     1019450 :   if (a.function() != core::detail::function_symbols::ActId)
    5843             :   {
    5844           0 :     return false;
    5845             :   }
    5846             : 
    5847             :   // check the children
    5848     1019450 :   if (a.size() != 2)
    5849             :   {
    5850           0 :     return false;
    5851             :   }
    5852             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    5853     1019450 :   if (!check_term_argument(a[0], check_rule_String<atermpp::aterm>))
    5854             :   {
    5855           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_String" << std::endl;
    5856           0 :     return false;
    5857             :   }
    5858     1019450 :   if (!check_list_argument(a[1], check_rule_SortExpr<atermpp::aterm>, 0))
    5859             :   {
    5860           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_SortExpr" << std::endl;
    5861           0 :     return false;
    5862             :   }
    5863             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    5864             : 
    5865             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    5866     1019450 :   return true;
    5867             : }
    5868             : 
    5869             : // StateYaled()
    5870             : template <typename Term>
    5871        9874 : bool check_term_StateYaled(const Term& t)
    5872             : {
    5873        9874 :   utilities::mcrl2_unused(t);
    5874             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    5875             :   // check the type of the term
    5876        9874 :   const atermpp::aterm& term(t);
    5877        9874 :   if (!term.type_is_appl())
    5878             :   {
    5879           0 :     return false;
    5880             :   }
    5881        9874 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    5882        9874 :   if (a.function() != core::detail::function_symbols::StateYaled)
    5883             :   {
    5884        9874 :     return false;
    5885             :   }
    5886             : 
    5887             :   // check the children
    5888           0 :   if (a.size() != 0)
    5889             :   {
    5890           0 :     return false;
    5891             :   }
    5892             : 
    5893             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    5894           0 :   return true;
    5895             : }
    5896             : 
    5897             : // PBESOr(PBExpr, PBExpr)
    5898             : template <typename Term>
    5899      129278 : bool check_term_PBESOr(const Term& t)
    5900             : {
    5901      129278 :   utilities::mcrl2_unused(t);
    5902             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    5903             :   // check the type of the term
    5904      129278 :   const atermpp::aterm& term(t);
    5905      129278 :   if (!term.type_is_appl())
    5906             :   {
    5907           0 :     return false;
    5908             :   }
    5909      129278 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    5910      129278 :   if (a.function() != core::detail::function_symbols::PBESOr)
    5911             :   {
    5912       99789 :     return false;
    5913             :   }
    5914             : 
    5915             :   // check the children
    5916       29489 :   if (a.size() != 2)
    5917             :   {
    5918           0 :     return false;
    5919             :   }
    5920             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    5921       29489 :   if (!check_term_argument(a[0], check_rule_PBExpr<atermpp::aterm>))
    5922             :   {
    5923           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_PBExpr" << std::endl;
    5924           0 :     return false;
    5925             :   }
    5926       29489 :   if (!check_term_argument(a[1], check_rule_PBExpr<atermpp::aterm>))
    5927             :   {
    5928           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_PBExpr" << std::endl;
    5929           0 :     return false;
    5930             :   }
    5931             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    5932             : 
    5933             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    5934       29489 :   return true;
    5935             : }
    5936             : 
    5937             : // BddTrue()
    5938             : template <typename Term>
    5939          24 : bool check_term_BddTrue(const Term& t)
    5940             : {
    5941          24 :   utilities::mcrl2_unused(t);
    5942             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    5943             :   // check the type of the term
    5944          24 :   const atermpp::aterm& term(t);
    5945          24 :   if (!term.type_is_appl())
    5946             :   {
    5947           0 :     return false;
    5948             :   }
    5949          24 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    5950          24 :   if (a.function() != core::detail::function_symbols::BddTrue)
    5951             :   {
    5952          16 :     return false;
    5953             :   }
    5954             : 
    5955             :   // check the children
    5956           8 :   if (a.size() != 0)
    5957             :   {
    5958           0 :     return false;
    5959             :   }
    5960             : 
    5961             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    5962           8 :   return true;
    5963             : }
    5964             : 
    5965             : // UntypedProcessAssignment(String, UntypedIdentifierAssignment*)
    5966             : template <typename Term>
    5967       41992 : bool check_term_UntypedProcessAssignment(const Term& t)
    5968             : {
    5969       41992 :   utilities::mcrl2_unused(t);
    5970             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    5971             :   // check the type of the term
    5972       41992 :   const atermpp::aterm& term(t);
    5973       41992 :   if (!term.type_is_appl())
    5974             :   {
    5975           0 :     return false;
    5976             :   }
    5977       41992 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    5978       41992 :   if (a.function() != core::detail::function_symbols::UntypedProcessAssignment)
    5979             :   {
    5980       34166 :     return false;
    5981             :   }
    5982             : 
    5983             :   // check the children
    5984        7826 :   if (a.size() != 2)
    5985             :   {
    5986           0 :     return false;
    5987             :   }
    5988             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    5989        7826 :   if (!check_term_argument(a[0], check_rule_String<atermpp::aterm>))
    5990             :   {
    5991           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_String" << std::endl;
    5992           0 :     return false;
    5993             :   }
    5994        7826 :   if (!check_list_argument(a[1], check_rule_UntypedIdentifierAssignment<atermpp::aterm>, 0))
    5995             :   {
    5996           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_UntypedIdentifierAssignment" << std::endl;
    5997           0 :     return false;
    5998             :   }
    5999             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    6000             : 
    6001             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    6002        7826 :   return true;
    6003             : }
    6004             : 
    6005             : // SortFBag()
    6006             : template <typename Term>
    6007     1566228 : bool check_term_SortFBag(const Term& t)
    6008             : {
    6009     1566228 :   utilities::mcrl2_unused(t);
    6010             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    6011             :   // check the type of the term
    6012     1566228 :   const atermpp::aterm& term(t);
    6013     1566228 :   if (!term.type_is_appl())
    6014             :   {
    6015           0 :     return false;
    6016             :   }
    6017     1566228 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    6018     1566228 :   if (a.function() != core::detail::function_symbols::SortFBag)
    6019             :   {
    6020           0 :     return false;
    6021             :   }
    6022             : 
    6023             :   // check the children
    6024     1566228 :   if (a.size() != 0)
    6025             :   {
    6026           0 :     return false;
    6027             :   }
    6028             : 
    6029             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    6030     1566228 :   return true;
    6031             : }
    6032             : 
    6033             : // Allow(MultActName*, ProcExpr)
    6034             : template <typename Term>
    6035     1580143 : bool check_term_Allow(const Term& t)
    6036             : {
    6037     1580143 :   utilities::mcrl2_unused(t);
    6038             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    6039             :   // check the type of the term
    6040     1580143 :   const atermpp::aterm& term(t);
    6041     1580143 :   if (!term.type_is_appl())
    6042             :   {
    6043           0 :     return false;
    6044             :   }
    6045     1580143 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    6046     1580143 :   if (a.function() != core::detail::function_symbols::Allow)
    6047             :   {
    6048     1485453 :     return false;
    6049             :   }
    6050             : 
    6051             :   // check the children
    6052       94690 :   if (a.size() != 2)
    6053             :   {
    6054           0 :     return false;
    6055             :   }
    6056             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    6057       94690 :   if (!check_list_argument(a[0], check_rule_MultActName<atermpp::aterm>, 0))
    6058             :   {
    6059           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_MultActName" << std::endl;
    6060           0 :     return false;
    6061             :   }
    6062       94690 :   if (!check_term_argument(a[1], check_rule_ProcExpr<atermpp::aterm>))
    6063             :   {
    6064           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_ProcExpr" << std::endl;
    6065           0 :     return false;
    6066             :   }
    6067             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    6068             : 
    6069             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    6070       94690 :   return true;
    6071             : }
    6072             : 
    6073             : // PropVarDecl(String, DataVarId*)
    6074             : template <typename Term>
    6075         559 : bool check_term_PropVarDecl(const Term& t)
    6076             : {
    6077         559 :   utilities::mcrl2_unused(t);
    6078             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    6079             :   // check the type of the term
    6080         559 :   const atermpp::aterm& term(t);
    6081         559 :   if (!term.type_is_appl())
    6082             :   {
    6083           0 :     return false;
    6084             :   }
    6085         559 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    6086         559 :   if (a.function() != core::detail::function_symbols::PropVarDecl)
    6087             :   {
    6088           0 :     return false;
    6089             :   }
    6090             : 
    6091             :   // check the children
    6092         559 :   if (a.size() != 2)
    6093             :   {
    6094           0 :     return false;
    6095             :   }
    6096             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    6097         559 :   if (!check_term_argument(a[0], check_rule_String<atermpp::aterm>))
    6098             :   {
    6099           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_String" << std::endl;
    6100           0 :     return false;
    6101             :   }
    6102         559 :   if (!check_list_argument(a[1], check_rule_DataVarId<atermpp::aterm>, 0))
    6103             :   {
    6104           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_DataVarId" << std::endl;
    6105           0 :     return false;
    6106             :   }
    6107             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    6108             : 
    6109             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    6110         559 :   return true;
    6111             : }
    6112             : 
    6113             : // ActImp(ActFrm, ActFrm)
    6114             : template <typename Term>
    6115        8401 : bool check_term_ActImp(const Term& t)
    6116             : {
    6117        8401 :   utilities::mcrl2_unused(t);
    6118             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    6119             :   // check the type of the term
    6120        8401 :   const atermpp::aterm& term(t);
    6121        8401 :   if (!term.type_is_appl())
    6122             :   {
    6123           0 :     return false;
    6124             :   }
    6125        8401 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    6126        8401 :   if (a.function() != core::detail::function_symbols::ActImp)
    6127             :   {
    6128        8401 :     return false;
    6129             :   }
    6130             : 
    6131             :   // check the children
    6132           0 :   if (a.size() != 2)
    6133             :   {
    6134           0 :     return false;
    6135             :   }
    6136             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    6137           0 :   if (!check_term_argument(a[0], check_rule_ActFrm<atermpp::aterm>))
    6138             :   {
    6139           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_ActFrm" << std::endl;
    6140           0 :     return false;
    6141             :   }
    6142           0 :   if (!check_term_argument(a[1], check_rule_ActFrm<atermpp::aterm>))
    6143             :   {
    6144           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_ActFrm" << std::endl;
    6145           0 :     return false;
    6146             :   }
    6147             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    6148             : 
    6149             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    6150           0 :   return true;
    6151             : }
    6152             : 
    6153             : // SortBag()
    6154             : template <typename Term>
    6155     8054913 : bool check_term_SortBag(const Term& t)
    6156             : {
    6157     8054913 :   utilities::mcrl2_unused(t);
    6158             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    6159             :   // check the type of the term
    6160     8054913 :   const atermpp::aterm& term(t);
    6161     8054913 :   if (!term.type_is_appl())
    6162             :   {
    6163           0 :     return false;
    6164             :   }
    6165     8054913 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    6166     8054913 :   if (a.function() != core::detail::function_symbols::SortBag)
    6167             :   {
    6168     7007130 :     return false;
    6169             :   }
    6170             : 
    6171             :   // check the children
    6172     1047783 :   if (a.size() != 0)
    6173             :   {
    6174           0 :     return false;
    6175             :   }
    6176             : 
    6177             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    6178     1047783 :   return true;
    6179             : }
    6180             : 
    6181             : // PBInit(PropVarInst)
    6182             : template <typename Term>
    6183         171 : bool check_term_PBInit(const Term& t)
    6184             : {
    6185         171 :   utilities::mcrl2_unused(t);
    6186             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    6187             :   // check the type of the term
    6188         171 :   const atermpp::aterm& term(t);
    6189         171 :   if (!term.type_is_appl())
    6190             :   {
    6191           0 :     return false;
    6192             :   }
    6193         171 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    6194         171 :   if (a.function() != core::detail::function_symbols::PBInit)
    6195             :   {
    6196           0 :     return false;
    6197             :   }
    6198             : 
    6199             :   // check the children
    6200         171 :   if (a.size() != 1)
    6201             :   {
    6202           0 :     return false;
    6203             :   }
    6204             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    6205         171 :   if (!check_term_argument(a[0], check_rule_PropVarInst<atermpp::aterm>))
    6206             :   {
    6207           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_PropVarInst" << std::endl;
    6208           0 :     return false;
    6209             :   }
    6210             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    6211             : 
    6212             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    6213         171 :   return true;
    6214             : }
    6215             : 
    6216             : // ActTrue()
    6217             : template <typename Term>
    6218       12790 : bool check_term_ActTrue(const Term& t)
    6219             : {
    6220       12790 :   utilities::mcrl2_unused(t);
    6221             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    6222             :   // check the type of the term
    6223       12790 :   const atermpp::aterm& term(t);
    6224       12790 :   if (!term.type_is_appl())
    6225             :   {
    6226           0 :     return false;
    6227             :   }
    6228       12790 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    6229       12790 :   if (a.function() != core::detail::function_symbols::ActTrue)
    6230             :   {
    6231       10814 :     return false;
    6232             :   }
    6233             : 
    6234             :   // check the children
    6235        1976 :   if (a.size() != 0)
    6236             :   {
    6237           0 :     return false;
    6238             :   }
    6239             : 
    6240             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    6241        1976 :   return true;
    6242             : }
    6243             : 
    6244             : // RegTransOrNil(RegFrm)
    6245             : template <typename Term>
    6246         376 : bool check_term_RegTransOrNil(const Term& t)
    6247             : {
    6248         376 :   utilities::mcrl2_unused(t);
    6249             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    6250             :   // check the type of the term
    6251         376 :   const atermpp::aterm& term(t);
    6252         376 :   if (!term.type_is_appl())
    6253             :   {
    6254           0 :     return false;
    6255             :   }
    6256         376 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    6257         376 :   if (a.function() != core::detail::function_symbols::RegTransOrNil)
    6258             :   {
    6259          12 :     return false;
    6260             :   }
    6261             : 
    6262             :   // check the children
    6263         364 :   if (a.size() != 1)
    6264             :   {
    6265           0 :     return false;
    6266             :   }
    6267             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    6268         364 :   if (!check_term_argument(a[0], check_rule_RegFrm<atermpp::aterm>))
    6269             :   {
    6270           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_RegFrm" << std::endl;
    6271           0 :     return false;
    6272             :   }
    6273             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    6274             : 
    6275             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    6276         364 :   return true;
    6277             : }
    6278             : 
    6279             : // UntypedMultiAction(UntypedDataParameter*)
    6280             : template <typename Term>
    6281        1749 : bool check_term_UntypedMultiAction(const Term& t)
    6282             : {
    6283        1749 :   utilities::mcrl2_unused(t);
    6284             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    6285             :   // check the type of the term
    6286        1749 :   const atermpp::aterm& term(t);
    6287        1749 :   if (!term.type_is_appl())
    6288             :   {
    6289           0 :     return false;
    6290             :   }
    6291        1749 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    6292        1749 :   if (a.function() != core::detail::function_symbols::UntypedMultiAction)
    6293             :   {
    6294         379 :     return false;
    6295             :   }
    6296             : 
    6297             :   // check the children
    6298        1370 :   if (a.size() != 1)
    6299             :   {
    6300           0 :     return false;
    6301             :   }
    6302             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    6303        1370 :   if (!check_list_argument(a[0], check_rule_UntypedDataParameter<atermpp::aterm>, 0))
    6304             :   {
    6305           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_UntypedDataParameter" << std::endl;
    6306           0 :     return false;
    6307             :   }
    6308             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    6309             : 
    6310             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    6311        1370 :   return true;
    6312             : }
    6313             : 
    6314             : // GlobVarSpec(DataVarId*)
    6315             : template <typename Term>
    6316         176 : bool check_term_GlobVarSpec(const Term& t)
    6317             : {
    6318         176 :   utilities::mcrl2_unused(t);
    6319             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    6320             :   // check the type of the term
    6321         176 :   const atermpp::aterm& term(t);
    6322         176 :   if (!term.type_is_appl())
    6323             :   {
    6324           0 :     return false;
    6325             :   }
    6326         176 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    6327         176 :   if (a.function() != core::detail::function_symbols::GlobVarSpec)
    6328             :   {
    6329           0 :     return false;
    6330             :   }
    6331             : 
    6332             :   // check the children
    6333         176 :   if (a.size() != 1)
    6334             :   {
    6335           0 :     return false;
    6336             :   }
    6337             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    6338         176 :   if (!check_list_argument(a[0], check_rule_DataVarId<atermpp::aterm>, 0))
    6339             :   {
    6340           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_DataVarId" << std::endl;
    6341           0 :     return false;
    6342             :   }
    6343             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    6344             : 
    6345             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    6346         176 :   return true;
    6347             : }
    6348             : 
    6349             : // UntypedIdentifierAssignment(String, DataExpr)
    6350             : template <typename Term>
    6351       22736 : bool check_term_UntypedIdentifierAssignment(const Term& t)
    6352             : {
    6353       22736 :   utilities::mcrl2_unused(t);
    6354             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    6355             :   // check the type of the term
    6356       22736 :   const atermpp::aterm& term(t);
    6357       22736 :   if (!term.type_is_appl())
    6358             :   {
    6359           0 :     return false;
    6360             :   }
    6361       22736 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    6362       22736 :   if (a.function() != core::detail::function_symbols::UntypedIdentifierAssignment)
    6363             :   {
    6364           0 :     return false;
    6365             :   }
    6366             : 
    6367             :   // check the children
    6368       22736 :   if (a.size() != 2)
    6369             :   {
    6370           0 :     return false;
    6371             :   }
    6372             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    6373       22736 :   if (!check_term_argument(a[0], check_rule_String<atermpp::aterm>))
    6374             :   {
    6375           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_String" << std::endl;
    6376           0 :     return false;
    6377             :   }
    6378       22736 :   if (!check_term_argument(a[1], check_rule_DataExpr<atermpp::aterm>))
    6379             :   {
    6380           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_DataExpr" << std::endl;
    6381           0 :     return false;
    6382             :   }
    6383             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    6384             : 
    6385             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    6386       22736 :   return true;
    6387             : }
    6388             : 
    6389             : // UntypedDataParameter(String, DataExpr*)
    6390             : template <typename Term>
    6391       41987 : bool check_term_UntypedDataParameter(const Term& t)
    6392             : {
    6393       41987 :   utilities::mcrl2_unused(t);
    6394             : #ifndef MCRL2_NO_SOUNDNESS_CHECKS
    6395             :   // check the type of the term
    6396       41987 :   const atermpp::aterm& term(t);
    6397       41987 :   if (!term.type_is_appl())
    6398             :   {
    6399           0 :     return false;
    6400             :   }
    6401       41987 :   const atermpp::aterm_appl& a = atermpp::down_cast<atermpp::aterm_appl>(term);
    6402       41987 :   if (a.function() != core::detail::function_symbols::UntypedDataParameter)
    6403             :   {
    6404        1749 :     return false;
    6405             :   }
    6406             : 
    6407             :   // check the children
    6408       40238 :   if (a.size() != 2)
    6409             :   {
    6410           0 :     return false;
    6411             :   }
    6412             : #ifndef MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    6413       40238 :   if (!check_term_argument(a[0], check_rule_String<atermpp::aterm>))
    6414             :   {
    6415           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_String" << std::endl;
    6416           0 :     return false;
    6417             :   }
    6418       40238 :   if (!check_list_argument(a[1], check_rule_DataExpr<atermpp::aterm>, 0))
    6419             :   {
    6420           0 :     mCRL2log(log::debug, "soundness_checks") << "check_rule_DataExpr" << std::endl;
    6421           0 :     return false;
    6422             :   }
    6423             : #endif // MCRL2_NO_RECURSIVE_SOUNDNESS_CHECKS
    6424             : 
    6425             : #endif // MCRL2_NO_SOUNDNESS_CHECKS
    6426       40238 :   return true;
    6427             : }
    6428             : //--- end generated code ---//
    6429             : 
    6430             : } // namespace detail
    6431             : 
    6432             : } // namespace core
    6433             : 
    6434             : } // namespace mcrl2
    6435             : #endif // MCRL2_CORE_DETAIL_SOUNDNESS_CHECKS_H

Generated by: LCOV version 1.12