[Imprint][Data Privacy Statement][E-Mail]

Back to the index. View project statistic. View project symbols. View KIV symbols to check that all symbols are available.

All project symbols

symbol specification entry
#traceCfunction, cstatestream → natinf
#traceCfunction, cstatelist → nat
#traceAfunction, astatestream → natinf
#traceAfunction, astatelist → nat
#IOstatestreamfunction, statestream → natinf
#IOstatestreamfunction, statelist → nat
#actionstreamfunction, actionstream → natinf
#actionstreamfunction, actionlist → nat
#streamfunction, stream → natinf
#list-datafunction, list → nat
#reflistfunction, reflist → nat
#Node-heapfunction, heap → nat
#storefunction, store → nat
#retval-heapfunction, rvSet → nat
#retval-heapfunction, rvHeap → nat
#set-basicfunction, set → nat
#statesetfunction, stateset → nat
#astatesetfunction, astateset → nat
#Koenigs-Lemma-gen-bwactfunction, pairastatenat-set → nat
#Koenigs-Lemma-gen-bwactfunction, pairastatenat-stream → natinf
#Koenigs-Lemma-gen-bwactfunction, pairastatenat-list → nat
#DurQtrace-absActionfunction, astatestream → natinf
#DurQtrace-absActionfunction, astatelist → nat
#DQctrace-absActionfunction, cstatestream → natinf
#DQctrace-absActionfunction, cstatelist → nat
#tidsetfunction, tidset → nat
#DMSQtrace-absActionfunction, cstatestream → natinf
#DMSQtrace-absActionfunction, cstatelist → nat
#DQ-refines-DurQ-renfunction, bstatestream → natinf
#DQ-refines-DurQ-renfunction, bstatelist → nat
#DMSQ-refines-DQ-renfunction, bstatestream → natinf
#DMSQ-refines-DQ-renfunction, bstatelist → nat
#DQatrace-absActionfunction, astatestream → natinf
#DQatrace-absActionfunction, astatelist → nat
'traceCfunction, cstate → cstatelist
'traceAfunction, astate → astatelist
'IOstatestreamfunction, state → statelist
'actionstreamfunction, action → actionlist
'listfunction, elem → list
'reflistfunction, Ref → reflist
'Koenigs-Lemma-gen-bwactfunction, pairastatenat → pairastatenat-list
'DurQtrace-absActionfunction, DurQState → astatelist
'DurQtrace-absActionfunction, absAction → actionlist
'DQctrace-absActionfunction, DQState → cstatelist
'DQctrace-absActionfunction, absAction → actionlist
'DMSQtrace-absActionfunction, DMSQState → cstatelist
'DMSQtrace-absActionfunction, absAction → actionlist
'DQ-refines-DurQ-renfunction, DQState → bstatelist
'DMSQ-refines-DQ-renfunction, DQState → bstatelist
'DMSQ-DQ-refine-instancefunction, DMSQState → cstatelist
'DQatrace-absActionfunction, DQState → astatelist
'DQatrace-absActionfunction, absAction → actionlist
+traceCfunction, cstatestream × cstatestream → cstatestream
+traceCfunction, cstate × cstatestream → cstatestream
+traceCfunction, cstatelist × cstate → cstatelist
+traceCfunction, cstatelist × cstatelist → cstatelist
+traceCfunction, cstate × cstatelist → cstatelist
+traceAfunction, astatestream × astatestream → astatestream
+traceAfunction, astate × astatestream → astatestream
+traceAfunction, astatelist × astate → astatelist
+traceAfunction, astatelist × astatelist → astatelist
+traceAfunction, astate × astatelist → astatelist
+IOstatestreamfunction, statestream × statestream → statestream
+IOstatestreamfunction, state × statestream → statestream
+IOstatestreamfunction, statelist × state → statelist
+IOstatestreamfunction, statelist × statelist → statelist
+IOstatestreamfunction, state × statelist → statelist
+actionstreamfunction, actionstream × actionstream → actionstream
+actionstreamfunction, action × actionstream → actionstream
+actionstreamfunction, actionlist × action → actionlist
+actionstreamfunction, actionlist × actionlist → actionlist
+actionstreamfunction, action × actionlist → actionlist
+streamfunction, stream × stream → stream
+streamfunction, elem × stream → stream
+nat-inffunction, natinf × natinf → natinf
+nat-basicfunction, nat × nat → nat
+list-datafunction, elem × list → list
+listfunction, list × elem → list
+listfunction, list × list → list
+reflistfunction, reflist × Ref → reflist
+reflistfunction, reflist × reflist → reflist
+reflistfunction, Ref × reflist → reflist
+Koenigs-Lemma-gen-bwactfunction, pairastatenat-stream × pairastatenat-stream → pairastatenat-stream
+Koenigs-Lemma-gen-bwactfunction, pairastatenat × pairastatenat-stream → pairastatenat-stream
+Koenigs-Lemma-gen-bwactfunction, pairastatenat-list × pairastatenat → pairastatenat-list
+Koenigs-Lemma-gen-bwactfunction, pairastatenat-list × pairastatenat-list → pairastatenat-list
+Koenigs-Lemma-gen-bwactfunction, pairastatenat × pairastatenat-list → pairastatenat-list
+DurQtrace-absActionfunction, astatestream × astatestream → astatestream
+DurQtrace-absActionfunction, DurQState × astatestream → astatestream
+DurQtrace-absActionfunction, astatelist × DurQState → astatelist
+DurQtrace-absActionfunction, astatelist × astatelist → astatelist
+DurQtrace-absActionfunction, DurQState × astatelist → astatelist
+DurQtrace-absActionfunction, absAction × actionstream → actionstream
+DurQtrace-absActionfunction, actionlist × absAction → actionlist
+DurQtrace-absActionfunction, absAction × actionlist → actionlist
+DQctrace-absActionfunction, cstatestream × cstatestream → cstatestream
+DQctrace-absActionfunction, DQState × cstatestream → cstatestream
+DQctrace-absActionfunction, cstatelist × DQState → cstatelist
+DQctrace-absActionfunction, cstatelist × cstatelist → cstatelist
+DQctrace-absActionfunction, DQState × cstatelist → cstatelist
+DQctrace-absActionfunction, absAction × actionstream → actionstream
+DQctrace-absActionfunction, actionlist × absAction → actionlist
+DQctrace-absActionfunction, absAction × actionlist → actionlist
+DMSQtrace-absActionfunction, cstatestream × cstatestream → cstatestream
+DMSQtrace-absActionfunction, DMSQState × cstatestream → cstatestream
+DMSQtrace-absActionfunction, cstatelist × DMSQState → cstatelist
+DMSQtrace-absActionfunction, cstatelist × cstatelist → cstatelist
+DMSQtrace-absActionfunction, DMSQState × cstatelist → cstatelist
+DMSQtrace-absActionfunction, absAction × actionstream → actionstream
+DMSQtrace-absActionfunction, actionlist × absAction → actionlist
+DMSQtrace-absActionfunction, absAction × actionlist → actionlist
+DQ-refines-DurQ-renfunction, bstatestream × bstatestream → bstatestream
+DQ-refines-DurQ-renfunction, DQState × bstatestream → bstatestream
+DQ-refines-DurQ-renfunction, bstatelist × DQState → bstatelist
+DQ-refines-DurQ-renfunction, bstatelist × bstatelist → bstatelist
+DQ-refines-DurQ-renfunction, DQState × bstatelist → bstatelist
+DMSQ-refines-DQ-renfunction, bstatestream × bstatestream → bstatestream
+DMSQ-refines-DQ-renfunction, DQState × bstatestream → bstatestream
+DMSQ-refines-DQ-renfunction, bstatelist × DQState → bstatelist
+DMSQ-refines-DQ-renfunction, bstatelist × bstatelist → bstatelist
+DMSQ-refines-DQ-renfunction, DQState × bstatelist → bstatelist
+DMSQ-DQ-refine-instancefunction, DMSQState × cstatestream → cstatestream
+DMSQ-DQ-refine-instancefunction, cstatelist × DMSQState → cstatelist
+DMSQ-DQ-refine-instancefunction, DMSQState × cstatelist → cstatelist
+DQatrace-absActionfunction, astatestream × astatestream → astatestream
+DQatrace-absActionfunction, DQState × astatestream → astatestream
+DQatrace-absActionfunction, astatelist × DQState → astatelist
+DQatrace-absActionfunction, astatelist × astatelist → astatelist
+DQatrace-absActionfunction, DQState × astatelist → astatelist
+DQatrace-absActionfunction, absAction × actionstream → actionstream
+DQatrace-absActionfunction, actionlist × absAction → actionlist
+DQatrace-absActionfunction, absAction × actionlist → actionlist
++traceCfunction, cstatelist × cstate → cstatelist
++traceAfunction, astatelist × astate → astatelist
++IOstatestreamfunction, statelist × state → statelist
++actionstreamfunction, actionlist × action → actionlist
++list-dupfunction, list × elem → list
++reflistfunction, reflist × Ref → reflist
++retval-heapfunction, rvSet × rvRef → rvSet
++set-basicfunction, set × elem → set
++statesetfunction, stateset × state → stateset
++astatesetfunction, astateset × astate → astateset
++Koenigs-Lemma-gen-bwactfunction, pairastatenat-set × pairastatenat → pairastatenat-set
++Koenigs-Lemma-gen-bwactfunction, pairastatenat-list × pairastatenat → pairastatenat-list
++DQ-refines-DurQ-instancefunction, astateset × DurQState → astateset
++DurQtrace-absActionfunction, astatelist × DurQState → astatelist
++DurQtrace-absActionfunction, actionlist × absAction → actionlist
++DQctrace-absActionfunction, cstatelist × DQState → cstatelist
++DQctrace-absActionfunction, actionlist × absAction → actionlist
++tidsetfunction, tidset × Tid → tidset
++DMSQtrace-absActionfunction, cstatelist × DMSQState → cstatelist
++DMSQtrace-absActionfunction, actionlist × absAction → actionlist
++DQ-refines-DurQ-renfunction, bstatelist × DQState → bstatelist
++DMSQ-refines-DQ-renfunction, bstatelist × DQState → bstatelist
++DMSQ-DQ-refine-instancefunction, cstatelist × DMSQState → cstatelist
++DQatrace-absActionfunction, astatelist × DQState → astatelist
++DQatrace-absActionfunction, actionlist × absAction → actionlist
+1nat-basicfunction, nat → nat
+2listfunction, elem × elem → list
+2reflistfunction, Ref × Ref → reflist
+2Koenigs-Lemma-gen-bwactfunction, pairastatenat × pairastatenat → pairastatenat-list
+ltraceCfunction, cstate × cstate → cstatelist
+ltraceAfunction, astate × astate → astatelist
+lIOstatestreamfunction, state × state → statelist
+lactionstreamfunction, action × action → actionlist
+lDurQtrace-absActionfunction, DurQState × DurQState → astatelist
+lDurQtrace-absActionfunction, absAction × absAction → actionlist
+lDQctrace-absActionfunction, DQState × DQState → cstatelist
+lDQctrace-absActionfunction, absAction × absAction → actionlist
+lDMSQtrace-absActionfunction, DMSQState × DMSQState → cstatelist
+lDMSQtrace-absActionfunction, absAction × absAction → actionlist
+lDQ-refines-DurQ-renfunction, DQState × DQState → bstatelist
+lDMSQ-refines-DQ-renfunction, DQState × DQState → bstatelist
+lDMSQ-DQ-refine-instancefunction, DMSQState × DMSQState → cstatelist
+lDQatrace-absActionfunction, DQState × DQState → astatelist
+lDQatrace-absActionfunction, absAction × absAction → actionlist
-natpartial function, nat × nat → nat
--Node-heapfunction, heap × Ref → heap
--storefunction, store × elem → store
--retval-heapfunction, rvSet × rvRef → rvSet
--retval-heapfunction, rvHeap × rvRef → rvHeap
--set-unionfunction, set × elem → set
--statesetfunction, stateset × state → stateset
--astatesetfunction, astateset × astate → astateset
--Koenigs-Lemma-gen-bwactfunction, pairastatenat-set × pairastatenat → pairastatenat-set
--DQ-refines-DurQ-instancefunction, astateset × DurQState → astateset
--tidsetfunction, tidset × Tid → tidset
-1nat-basicpartial function, nat → nat
-1ltraceCfunction, cstatelist × cstate → cstatelist
-1ltraceAfunction, astatelist × astate → astatelist
-1lIOstatestreamfunction, statelist × state → statelist
-1lactionstreamfunction, actionlist × action → actionlist
-1llist-delfunction, list × elem → list
-1lKoenigs-Lemma-gen-bwactfunction, pairastatenat-list × pairastatenat → pairastatenat-list
-1lDurQtrace-absActionfunction, astatelist × DurQState → astatelist
-1lDurQtrace-absActionfunction, actionlist × absAction → actionlist
-1lDQctrace-absActionfunction, cstatelist × DQState → cstatelist
-1lDQctrace-absActionfunction, actionlist × absAction → actionlist
-1lDMSQtrace-absActionfunction, cstatelist × DMSQState → cstatelist
-1lDMSQtrace-absActionfunction, actionlist × absAction → actionlist
-1lDQ-refines-DurQ-renfunction, bstatelist × DQState → bstatelist
-1lDMSQ-refines-DQ-renfunction, bstatelist × DQState → bstatelist
-1lDMSQ-DQ-refine-instancefunction, cstatelist × DMSQState → cstatelist
-1lDQatrace-absActionfunction, astatelist × DQState → astatelist
-1lDQatrace-absActionfunction, actionlist × absAction → actionlist
-ltraceCfunction, cstatelist × cstate → cstatelist
-ltraceAfunction, astatelist × astate → astatelist
-lIOstatestreamfunction, statelist × state → statelist
-lactionstreamfunction, actionlist × action → actionlist
-llist-delfunction, list × elem → list
-lKoenigs-Lemma-gen-bwactfunction, pairastatenat-list × pairastatenat → pairastatenat-list
-lDurQtrace-absActionfunction, astatelist × DurQState → astatelist
-lDurQtrace-absActionfunction, actionlist × absAction → actionlist
-lDQctrace-absActionfunction, cstatelist × DQState → cstatelist
-lDQctrace-absActionfunction, actionlist × absAction → actionlist
-lDMSQtrace-absActionfunction, cstatelist × DMSQState → cstatelist
-lDMSQtrace-absActionfunction, actionlist × absAction → actionlist
-lDQ-refines-DurQ-renfunction, bstatelist × DQState → bstatelist
-lDMSQ-refines-DQ-renfunction, bstatelist × DQState → bstatelist
-lDMSQ-DQ-refine-instancefunction, cstatelist × DMSQState → cstatelist
-lDQatrace-absActionfunction, astatelist × DQState → astatelist
-lDQatrace-absActionfunction, actionlist × absAction → actionlist
-ptraceCfunction, cstatelist × nat → cstatelist
-ptraceAfunction, astatelist × nat → astatelist
-pIOstatestreamfunction, statelist × nat → statelist
-pactionstreamfunction, actionlist × nat → actionlist
-plist-delfunction, list × nat → list
-pKoenigs-Lemma-gen-bwactfunction, pairastatenat-list × nat → pairastatenat-list
-pDurQtrace-absActionfunction, astatelist × nat → astatelist
-pDQctrace-absActionfunction, cstatelist × nat → cstatelist
-pDMSQtrace-absActionfunction, cstatelist × nat → cstatelist
-pDQ-refines-DurQ-renfunction, bstatelist × nat → bstatelist
-pDMSQ-refines-DQ-renfunction, bstatelist × nat → bstatelist
-pDQatrace-absActionfunction, astatelist × nat → astatelist
.1pair-astate-natfunction, pairastatenat → astate
.1DQ-refines-DurQ-instancefunction, pairastatenat → DurQState
.2pair-astate-natfunction, pairastatenat → nat
.addrDMSQfunction, DMSQLState → rvRef
.addr:=DMSQfunction, DMSQLState × rvRef → DMSQLState
.butlasttraceCpartial function, cstatelist → cstatelist
.butlasttraceApartial function, astatelist → astatelist
.butlastIOstatestreampartial function, statelist → statelist
.butlastactionstreampartial function, actionlist → actionlist
.butlastlist-lastpartial function, list → list
.butlastreflistpartial function, reflist → reflist
.butlastKoenigs-Lemma-gen-bwactpartial function, pairastatenat-list → pairastatenat-list
.butlastDurQtrace-absActionpartial function, astatelist → astatelist
.butlastDQctrace-absActionpartial function, cstatelist → cstatelist
.butlastDMSQtrace-absActionpartial function, cstatelist → cstatelist
.butlastDQ-refines-DurQ-renpartial function, bstatelist → bstatelist
.butlastDMSQ-refines-DQ-renpartial function, bstatelist → bstatelist
.butlastDQatrace-absActionpartial function, astatelist → astatelist
.deqIDNodefunction, Node → OptTid
.deqID:=Nodefunction, Node × OptTid → Node
.ftraceCpartial function, cstatestream → nat → cstate
.ftraceApartial function, astatestream → nat → astate
.fIOstatestreampartial function, statestream → nat → state
.factionstreampartial function, actionstream → nat → action
.fstream-basicpartial function, stream → nat → elem
.fKoenigs-Lemma-gen-bwactpartial function, pairastatenat-stream → nat → pairastatenat
.fDurQtrace-absActionpartial function, astatestream → nat → DurQState
.fDurQtrace-absActionpartial function, actionstream → nat → absAction
.fDQctrace-absActionpartial function, cstatestream → nat → DQState
.fDQctrace-absActionpartial function, actionstream → nat → absAction
.fDMSQtrace-absActionpartial function, cstatestream → nat → DMSQState
.fDMSQtrace-absActionpartial function, actionstream → nat → absAction
.fDQ-refines-DurQ-renpartial function, bstatestream → nat → DQState
.fDMSQ-refines-DQ-renpartial function, bstatestream → nat → DQState
.fDMSQ-DQ-refine-instancepartial function, cstatestream → nat → DMSQState
.fDQatrace-absActionpartial function, astatestream → nat → DQState
.fDQatrace-absActionpartial function, actionstream → nat → absAction
.firstDMSQfunction, DMSQLState → Ref
.first:=DMSQfunction, DMSQLState × Ref → DMSQLState
.gstateDQfunction, DQState → DQGState
.gstateDMSQfunction, DMSQState → DMSQGState
.gstateDurQfunction, DurQState → DurQGState
.gstate:=DQfunction, DQState × DQGState → DQState
.gstate:=DMSQfunction, DMSQState × DMSQGState → DMSQState
.gstate:=DurQfunction, DurQState × DurQGState → DurQState
.headlist-datapartial function, list → elem
.headreflistpartial function, reflist → Ref
.headKoenigs-Lemma-gen-bwactpartial function, pairastatenat-list → pairastatenat
.invENQvalueDMSQpartial function, DMSQAction → elem
.invFLUSHVALrDMSQpartial function, DMSQAction → Ref
.ivalDQfunction, DQLState → elem
.ivalDurQfunction, DurQLState → elem
.ival:=DQfunction, DQLState × elem → DQLState
.ival:=DurQfunction, DurQLState × elem → DurQLState
.ltraceCpartial function, cstatestream → cstatelist
.ltraceApartial function, astatestream → astatelist
.lIOstatestreampartial function, statestream → statelist
.lactionstreampartial function, actionstream → actionlist
.lstream-basicpartial function, stream → list
.lKoenigs-Lemma-gen-bwactpartial function, pairastatenat-stream → pairastatenat-list
.lDurQtrace-absActionpartial function, astatestream → astatelist
.lDQctrace-absActionpartial function, cstatestream → cstatelist
.lDMSQtrace-absActionpartial function, cstatestream → cstatelist
.lDQ-refines-DurQ-renpartial function, bstatestream → bstatelist
.lDMSQ-refines-DQ-renpartial function, bstatestream → bstatelist
.lDQatrace-absActionpartial function, astatestream → astatelist
.lasttraceCpartial function, cstatelist → cstate
.lasttraceApartial function, astatelist → astate
.lastIOstatestreampartial function, statelist → state
.lastactionstreampartial function, actionlist → action
.lastlist-lastpartial function, list → elem
.lastreflistpartial function, reflist → Ref
.lastKoenigs-Lemma-gen-bwactpartial function, pairastatenat-list → pairastatenat
.lastDurQtrace-absActionpartial function, astatelist → DurQState
.lastDurQtrace-absActionpartial function, actionlist → absAction
.lastDQctrace-absActionpartial function, cstatelist → DQState
.lastDQctrace-absActionpartial function, actionlist → absAction
.lastDMSQtrace-absActionpartial function, cstatelist → DMSQState
.lastDMSQtrace-absActionpartial function, actionlist → absAction
.lastDQ-refines-DurQ-renpartial function, bstatelist → DQState
.lastDMSQ-refines-DQ-renpartial function, bstatelist → DQState
.lastDMSQ-DQ-refine-instancepartial function, cstatelist → DMSQState
.lastDQatrace-absActionpartial function, astatelist → DQState
.lastDQatrace-absActionpartial function, actionlist → absAction
.lsfDQfunction, DQState → Tid → DQLState
.lsfDMSQfunction, DMSQState → Tid → DMSQLState
.lsfDurQfunction, DurQState → Tid → DurQLState
.lsf:=DQfunction, DQState × Tid → DQLState → DQState
.lsf:=DMSQfunction, DMSQState × Tid → DMSQLState → DMSQState
.lsf:=DurQfunction, DurQState × Tid → DurQLState → DurQState
.lstDMSQfunction, DMSQLState → Ref
.lst:=DMSQfunction, DMSQLState × Ref → DMSQLState
.nnat-infpartial function, natinf → nat
.ndDMSQpartial function, DMSQAction → Node
.ndDMSQfunction, DMSQLState → Node
.nd:=DMSQfunction, DMSQLState × Node → DMSQLState
.nextNodefunction, Node → Ref
.next:=Nodefunction, Node × Ref → Node
.nodeDMSQpartial function, DMSQAction → Ref
.nodeDMSQfunction, DMSQLState → Ref
.node:=DMSQfunction, DMSQLState × Ref → DMSQLState
.nxtDMSQfunction, DMSQLState → Ref
.nxt:=DMSQfunction, DMSQLState × Ref → DMSQLState
.obsEmptyDQpredicate, DQLState
.obsEmpty:=DQfunction, DQLState × bool → DQLState
.optvalDQpartial function, DQAction → OptElem
.optvalDQfunction, DQLState → OptElem
.optvalDMSQfunction, DMSQLState → OptElem
.optvalDurQpartial function, DurQAction → OptElem
.optvalDurQfunction, DurQLState → OptElem
.optvalabsActionpartial function, absAction → OptElem
.optval0DMSQpartial function, DMSQAction → OptElem
.optval0DMSQfunction, DMSQLState → OptElem
.optval0:=DMSQfunction, DMSQLState × OptElem → DMSQLState
.optval:=DQfunction, DQLState × OptElem → DQLState
.optval:=DMSQfunction, DMSQLState × OptElem → DMSQLState
.optval:=DurQfunction, DurQLState × OptElem → DurQLState
.orlDMSQfunction, DMSQGState → reflist
.orl:=DMSQfunction, DMSQGState × reflist → DMSQGState
.othertidDMSQfunction, DMSQLState → Tid
.othertid:=DMSQfunction, DMSQLState × Tid → DMSQLState
.ovalDQfunction, DQLState → OptElem
.ovalDurQfunction, DurQLState → OptElem
.oval:=DQfunction, DQLState × OptElem → DQLState
.oval:=DurQfunction, DurQLState × OptElem → DurQLState
.ownsDMSQfunction, DMSQGState → Ref → OptTid
.owns:=DMSQfunction, DMSQGState × Ref → OptTid → DMSQGState
.pcfDQfunction, DQState → Tid → DQPC
.pcfDMSQfunction, DMSQState → Tid → DMSQPC
.pcfDurQfunction, DurQState → Tid → DurQPC
.pcf:=DQfunction, DQState × Tid → DQPC → DQState
.pcf:=DMSQfunction, DMSQState × Tid → DMSQPC → DMSQState
.pcf:=DurQfunction, DurQState × Tid → DurQPC → DurQState
.pending?rvownerpredicate, rvOwner
.pheadDMSQfunction, DMSQGState → Ref
.phead:=DMSQfunction, DMSQGState × Ref → DMSQGState
.pretRefsDMSQfunction, DMSQGState → Tid → rvRef
.pretRefs:=DMSQfunction, DMSQGState × Tid → rvRef → DMSQGState
.prvHpDMSQfunction, DMSQGState → rvHeap
.prvHp:=DMSQfunction, DMSQGState × rvHeap → DMSQGState
.psDMSQfunction, DMSQGState → heap
.ps:=DMSQfunction, DMSQGState × heap → DMSQGState
.qrlDMSQfunction, DMSQGState → reflist
.qrl:=DMSQfunction, DMSQGState × reflist → DMSQGState
.queueDQfunction, DQGState → list
.queueDurQfunction, DurQGState → list
.queue:=DQfunction, DQGState × list → DQGState
.queue:=DurQfunction, DurQGState × list → DurQGState
.retDEQoptvalDMSQpartial function, DMSQAction → OptElem
.rvownsDMSQfunction, DMSQGState → rvRef → rvOwner
.rvowns:=DMSQfunction, DMSQGState × rvRef → rvOwner → DMSQGState
.rvrefDMSQpartial function, DMSQAction → rvRef
.rvrefDMSQfunction, DMSQLState → rvRef
.rvref:=DMSQfunction, DMSQLState × rvRef → DMSQLState
.startC-IO-Automatonfunction, CIOAutomaton → cstate → bool
.starttraceCfunction, CIOAutomaton → cstate → bool
.starttraceAfunction, AIOAutomaton → astate → bool
.startIO-Aut-datafunction, IOAutomaton → state → bool
.startDurQtrace-absActionfunction, AIOAutomaton → DurQState → bool
.startDQctrace-absActionfunction, CIOAutomaton → DQState → bool
.startDMSQtrace-absActionfunction, CIOAutomaton → DMSQState → bool
.startDQ-refines-DurQ-renfunction, BIOAutomaton → DQState → bool
.startDMSQ-refines-DQ-renfunction, BIOAutomaton → DQState → bool
.startDMSQ-Automaton-absActionfunction, CIOAutomaton → DMSQState → bool
.startDQatrace-absActionfunction, AIOAutomaton → DQState → bool
.stepC-IO-Automatonfunction, CIOAutomaton → cstate × action × cstate → bool
.steptraceCfunction, CIOAutomaton → cstate × action × cstate → bool
.steptraceAfunction, AIOAutomaton → astate × action × astate → bool
.stepIO-Aut-datafunction, IOAutomaton → state × action × state → bool
.stepDurQtrace-absActionfunction, AIOAutomaton → DurQState × absAction × DurQState → bool
.stepDQctrace-absActionfunction, CIOAutomaton → DQState × absAction × DQState → bool
.stepDMSQtrace-absActionfunction, CIOAutomaton → DMSQState × absAction × DMSQState → bool
.stepDQ-refines-DurQ-renfunction, BIOAutomaton → DQState × absAction × DQState → bool
.stepDMSQ-refines-DQ-renfunction, BIOAutomaton → DQState × absAction × DQState → bool
.stepDMSQ-Automaton-absActionfunction, CIOAutomaton → DMSQState × absAction × DMSQState → bool
.stepDQatrace-absActionfunction, AIOAutomaton → DQState × absAction × DQState → bool
.successDMSQpartial predicate, DMSQAction
.successDMSQpredicate, DMSQLState
.success:=DMSQfunction, DMSQLState × bool → DMSQLState
.taillist-datapartial function, list → list
.tailreflistpartial function, reflist → reflist
.tailKoenigs-Lemma-gen-bwactpartial function, pairastatenat-list → pairastatenat-list
.tidopttidpartial function, OptTid → Tid
.tidrvownerfunction, rvOwner → Tid
.tidDQpartial function, DQAction → Tid
.tidDQfunction, DQLState → Tid
.tidDMSQpartial function, DMSQAction → Tid
.tidDMSQfunction, DMSQLState → Tid
.tidDurQpartial function, DurQAction → Tid
.tidDurQfunction, DurQLState → Tid
.tidabsActionpartial function, absAction → Tid
.tid:=opttidpartial function, OptTid × Tid → OptTid
.tid:=DQfunction, DQLState × Tid → DQLState
.tid:=DMSQfunction, DMSQLState × Tid → DMSQLState
.tid:=DurQfunction, DurQLState × Tid → DurQLState
.valNodefunction, Node → elem
.valoptelempartial function, OptElem → elem
.valrvownerpartial function, rvOwner → elem
.valDQpartial function, DQAction → elem
.valDurQpartial function, DurQAction → elem
.valabsActionpartial function, absAction → elem
.val:=Nodefunction, Node × elem → Node
.valueDQfunction, DQLState → elem
.valueDMSQfunction, DMSQLState → elem
.valueDurQfunction, DurQLState → elem
.value:=DQfunction, DQLState × elem → DQLState
.value:=DMSQfunction, DMSQLState × elem → DMSQLState
.value:=DurQfunction, DurQLState × elem → DurQLState
.vheadDMSQfunction, DMSQGState → Ref
.vhead:=DMSQfunction, DMSQGState × Ref → DMSQGState
.vretRefsDMSQfunction, DMSQGState → Tid → rvRef
.vretRefs:=DMSQfunction, DMSQGState × Tid → rvRef → DMSQGState
.vrvHpDMSQfunction, DMSQGState → rvHeap
.vrvHp:=DMSQfunction, DMSQGState × rvHeap → DMSQGState
.vsDMSQfunction, DMSQGState → heap
.vs:=DMSQfunction, DMSQGState × heap → DMSQGState
.vtailDMSQfunction, DMSQGState → Ref
.vtail:=DMSQfunction, DMSQGState × Ref → DMSQGState
<traceCpredicate, cstatelist × cstatelist
<traceApredicate, astatelist × astatelist
<IOstatestreampredicate, statelist × statelist
<actionstreampredicate, actionlist × actionlist
<nat-infpredicate, natinf × natinf
<nat-basicpredicate, nat × nat
<list-datapredicate, list × list
<reflistpredicate, reflist × reflist
<Koenigs-Lemma-gen-bwactpredicate, pairastatenat-list × pairastatenat-list
<DurQtrace-absActionpredicate, astatelist × astatelist
<DQctrace-absActionpredicate, cstatelist × cstatelist
<DMSQtrace-absActionpredicate, cstatelist × cstatelist
<DQ-refines-DurQ-renpredicate, bstatelist × bstatelist
<DMSQ-refines-DQ-renpredicate, bstatelist × bstatelist
<DQatrace-absActionpredicate, astatelist × astatelist
>natpredicate, nat × nat
ACrashDurQprocedure, : (Tid → DurQPC)
ADODEQDurQprocedure, : OptElem × list
ADOENQDurQprocedure, elem : list
ADoDeqDurQfunction, Tid → DurQAction
ADoEnqDurQfunction, Tid → DurQAction
AINVDEQDurQprocedure, :
AINVENQDurQprocedure, elem : elem
AIOAuttraceAfunction, astate → bool × astate × action × astate → bool → AIOAutomaton
AIOAutDurQtrace-absActionfunction, DurQState → bool × DurQState × absAction × DurQState → bool → AIOAutomaton
AIOAutDQatrace-absActionfunction, DQState → bool × DQState × absAction × DQState → bool → AIOAutomaton
AIOAut?traceApredicate, AIOAutomaton
AIOAut?DurQtrace-absActionpredicate, AIOAutomaton
AIOAut?DQatrace-absActionpredicate, AIOAutomaton
AIOAutomatontraceAsort,
AIOAutomatonDurQtrace-absActionsort,
AIOAutomatonDQatrace-absActionsort,
AInvDeqDurQfunction, Tid → DurQAction
AInvEnqDurQfunction, Tid × elem → DurQAction
ARETDEQDurQprocedure, OptElem : : OptElem
ARETENQDurQprocedure, :
ARetDeqDurQfunction, Tid × OptElem → DurQAction
ARetEnqDurQfunction, Tid → DurQAction
ARunDurQprocedure, :
A_≤*T_CIOrefine-defpredicate, AIOAutomaton × CIOAutomaton
A_≤*T_CDQ-refines-DurQ-renpredicate, AIOAutomaton × BIOAutomaton
A_≤*T_CDMSQ-refines-DQ-renpredicate, BIOAutomaton × CIOAutomaton
A_≤T_CIOrefine-defpredicate, AIOAutomaton × CIOAutomaton
A_≤T_CDQ-refines-DurQ-renpredicate, AIOAutomaton × BIOAutomaton
A_≤T_CDMSQ-refines-DQ-renpredicate, BIOAutomaton × CIOAutomaton
A_≤ωT_CIOrefine-defpredicate, AIOAutomaton × CIOAutomaton
A_≤ωT_CDQ-refines-DurQ-renpredicate, AIOAutomaton × BIOAutomaton
A_≤ωT_CDMSQ-refines-DQ-renpredicate, BIOAutomaton × CIOAutomaton
BIOAutDQ-refines-DurQ-renfunction, DQState → bool × DQState × absAction × DQState → bool → BIOAutomaton
BIOAutDMSQ-refines-DQ-renfunction, DQState → bool × DQState × absAction × DQState → bool → BIOAutomaton
BIOAut?DQ-refines-DurQ-renpredicate, BIOAutomaton
BIOAut?DMSQ-refines-DQ-renpredicate, BIOAutomaton
BIOAutomatonDQ-refines-DurQ-rensort,
BIOAutomatonDMSQ-refines-DQ-rensort,
CHECKEMPDQprocedure, list : bool
CIOAutC-IO-Automatonfunction, cstate → bool × cstate × action × cstate → bool → CIOAutomaton
CIOAuttraceCfunction, cstate → bool × cstate × action × cstate → bool → CIOAutomaton
CIOAutDQctrace-absActionfunction, DQState → bool × DQState × absAction × DQState → bool → CIOAutomaton
CIOAutDMSQtrace-absActionfunction, DMSQState → bool × DMSQState × absAction × DMSQState → bool → CIOAutomaton
CIOAutDMSQ-Automaton-absActionfunction, DMSQState → bool × DMSQState × absAction × DMSQState → bool → CIOAutomaton
CIOAut?C-IO-Automatonpredicate, CIOAutomaton
CIOAut?traceCpredicate, CIOAutomaton
CIOAut?DQctrace-absActionpredicate, CIOAutomaton
CIOAut?DMSQtrace-absActionpredicate, CIOAutomaton
CIOAut?DMSQ-Automaton-absActionpredicate, CIOAutomaton
CIOAutomatonC-IO-Automatonsort,
CIOAutomatontraceCsort,
CIOAutomatonDQctrace-absActionsort,
CIOAutomatonDMSQtrace-absActionsort,
CIOAutomatonDMSQ-Automaton-absActionsort,
CRASHDMSQprocedure, heap × Ref × (Tid → rvRef) × rvHeap : heap × Ref × Ref × (Tid → rvRef) × rvHeap × (Ref → OptTid) × (Tid → DMSQPC)
C_≡*T_AIOrefine-defpredicate, CIOAutomaton × AIOAutomaton
C_≡*T_ADQ-refines-DurQ-renpredicate, BIOAutomaton × AIOAutomaton
C_≡*T_ADMSQ-refines-DQ-renpredicate, CIOAutomaton × BIOAutomaton
C_≡T_AIOrefine-defpredicate, CIOAutomaton × AIOAutomaton
C_≡T_ADQ-refines-DurQ-renpredicate, BIOAutomaton × AIOAutomaton
C_≡T_ADMSQ-refines-DQ-renpredicate, CIOAutomaton × BIOAutomaton
C_≡ωT_AIOrefine-defpredicate, CIOAutomaton × AIOAutomaton
C_≡ωT_ADQ-refines-DurQ-renpredicate, BIOAutomaton × AIOAutomaton
C_≡ωT_ADMSQ-refines-DQ-renpredicate, CIOAutomaton × BIOAutomaton
C_≤*T_AIOrefine-defpredicate, CIOAutomaton × AIOAutomaton
C_≤*T_ADQ-refines-DurQ-renpredicate, BIOAutomaton × AIOAutomaton
C_≤*T_ADMSQ-refines-DQ-renpredicate, CIOAutomaton × BIOAutomaton
C_≤T_AIOrefine-defpredicate, CIOAutomaton × AIOAutomaton
C_≤T_ADQ-refines-DurQ-renpredicate, BIOAutomaton × AIOAutomaton
C_≤T_ADMSQ-refines-DQ-renpredicate, CIOAutomaton × BIOAutomaton
C_≤ωT_AIOrefine-defpredicate, CIOAutomaton × AIOAutomaton
C_≤ωT_ADQ-refines-DurQ-renpredicate, BIOAutomaton × AIOAutomaton
C_≤ωT_ADMSQ-refines-DQ-renpredicate, CIOAutomaton × BIOAutomaton
CallRUNabsActionfunction, Tid → absAction
CheckEmpDQfunction, Tid → DQAction
Claimedrvownerfunction, Tid × elem → rvOwner
CrashDQprocedure, : (Tid → DQPC)
D1DMSQconstant, DMSQPC
D10DMSQconstant, DMSQPC
D11DMSQconstant, DMSQPC
D12DMSQconstant, DMSQPC
D13DMSQconstant, DMSQPC
D14DMSQconstant, DMSQPC
D15DMSQconstant, DMSQPC
D16DMSQconstant, DMSQPC
D17DMSQconstant, DMSQPC
D18DMSQconstant, DMSQPC
D19DMSQconstant, DMSQPC
D2DMSQconstant, DMSQPC
D20DMSQconstant, DMSQPC
D21DMSQconstant, DMSQPC
D22DMSQconstant, DMSQPC
D23DMSQconstant, DMSQPC
D24DMSQconstant, DMSQPC
D25DMSQconstant, DMSQPC
D26DMSQconstant, DMSQPC
D27DMSQconstant, DMSQPC
D28DMSQconstant, DMSQPC
D29DMSQconstant, DMSQPC
D3DMSQconstant, DMSQPC
D30DMSQconstant, DMSQPC
D31DMSQconstant, DMSQPC
D32DMSQconstant, DMSQPC
D33DMSQconstant, DMSQPC
D34DMSQconstant, DMSQPC
D4DMSQconstant, DMSQPC
D5DMSQconstant, DMSQPC
D6DMSQconstant, DMSQPC
D7DMSQconstant, DMSQPC
D8DMSQconstant, DMSQPC
D9DMSQconstant, DMSQPC
DMSQActionDMSQsort,
DMSQGInvDMSQpredicate, DMSQGState
DMSQGStateDMSQsort,
DMSQInvDMSQpredicate, DMSQGState × Tid → DMSQLState × Tid → DMSQPC
DMSQLInvDMSQpredicate, DMSQGState × DMSQLState × DMSQPC
DMSQLStateDMSQsort,
DMSQPCDMSQsort,
DMSQRelyDMSQpredicate, DMSQGState × Tid × DMSQGState
DMSQStateDMSQsort,
DMSQastepabspredicate, DMSQState × DQAction × DMSQState
DMSQinitabspredicate, DMSQState
DMSQstepDMSQpredicate, DMSQState × DMSQAction × DMSQState
DMSQstepDMSQ-refines-DQpredicate, DMSQState × absAction × DMSQState
DODEQDQprocedure, : OptElem × list
DODEQEMPTYDQprocedure, bool : OptElem
DOENQDQprocedure, elem : list
DQActionDQsort,
DQGInvDQpredicate, DQGState
DQGStateDQsort,
DQINVDQ-refines-DurQpredicate, DQState
DQInvDQpredicate, DQGState × Tid → DQLState × Tid → DQPC
DQLInvDQpredicate, DQGState × DQLState × DQPC
DQLStateDQsort,
DQPCDQsort,
DQStateDQsort,
DQinitabspredicate, DQState
DQinitDQ-refines-DurQpredicate, DQState
DQstepDQpredicate, DQState × DQAction × DQState
DQstepDQ-refines-DurQpredicate, DQState × absAction × DQState
DQstepDMSQ-refines-DQpredicate, DQState × absAction × DQState
DoDeqDQfunction, Tid → DQAction
DoDeqEmptyDQfunction, Tid → DQAction
DoEnqDQfunction, Tid → DQAction
DurQActionDurQsort,
DurQGInvDurQpredicate, DurQGState
DurQGStateDurQsort,
DurQInvDurQpredicate, DurQGState × Tid → DurQLState × Tid → DurQPC
DurQLInvDurQpredicate, DurQGState × DurQLState × DurQPC
DurQLStateDurQsort,
DurQPCDurQsort,
DurQStateDurQsort,
DurQinitDQ-refines-DurQpredicate, DurQState
DurQstepDurQpredicate, DurQState × DurQAction × DurQState
DurQstepDQ-refines-DurQpredicate, DurQState × absAction × DurQState
E1DMSQconstant, DMSQPC
E10DMSQconstant, DMSQPC
E11DMSQconstant, DMSQPC
E12DMSQconstant, DMSQPC
E13DMSQconstant, DMSQPC
E14DMSQconstant, DMSQPC
E15DMSQconstant, DMSQPC
E16DMSQconstant, DMSQPC
E17DMSQconstant, DMSQPC
E2DMSQconstant, DMSQPC
E3DMSQconstant, DMSQPC
E4DMSQconstant, DMSQPC
E5DMSQconstant, DMSQPC
E6DMSQconstant, DMSQPC
E7DMSQconstant, DMSQPC
E8DMSQconstant, DMSQPC
E9DMSQconstant, DMSQPC
Emptyoptelemconstant, OptElem
FLUSHHEADDMSQprocedure, Ref : Ref
FLUSHNEXTDMSQprocedure, Ref × heap × reflist : heap × reflist × (Ref → OptTid)
FLUSHOPTTIDDMSQprocedure, Ref × heap : heap × reflist × reflist
FLUSHRETREFDMSQprocedure, Tid × (Tid → rvRef) : (Tid → rvRef)
FLUSHRVHPDMSQprocedure, rvRef × rvHeap : rvHeap
FLUSHVALDMSQprocedure, Ref × heap : heap
INVDEQDQprocedure, : bool
INVENQDQprocedure, elem : elem
IOAutIO-Aut-datafunction, state → bool × state × action × state → bool → IOAutomaton
IOAut?IO-Automatonpredicate, IOAutomaton
IOAutomatonIO-Aut-datasort,
InvDEQabsActionfunction, Tid → absAction
InvDeqDQfunction, Tid → DQAction
InvENQabsActionfunction, Tid × elem → absAction
InvEnqDQfunction, Tid × elem → DQAction
NodeNodesort,
Noneopttidconstant, OptTid
OptElemoptelemsort,
OptTidopttidsort,
Pendingrvownerfunction, Tid → rvOwner
RETDEQDQprocedure, OptElem : : OptElem
RETENQDQprocedure, :
RUNDMSQprocedure, :
RefRefsort,
ResDEQabsActionfunction, Tid × OptElem → absAction
ResENQabsActionfunction, Tid → absAction
RetDeqDQfunction, Tid × OptElem → DQAction
RetEnqDQfunction, Tid → DQAction
RunDQprocedure, :
Someopttidfunction, Tid → OptTid
Tidtidsort,
Valoptelemfunction, elem → OptElem
Weakopttidfunction, Tid → OptTid
[]traceCconstant, cstatestream
[]traceCconstant, cstatelist
[]traceAconstant, astatestream
[]traceAconstant, astatelist
[]IOstatestreamconstant, statestream
[]IOstatestreamconstant, statelist
[]actionstreamconstant, actionstream
[]actionstreamconstant, actionlist
[]streamconstant, stream
[]list-dataconstant, list
[]reflistconstant, reflist
[]Koenigs-Lemma-gen-bwactconstant, pairastatenat-stream
[]Koenigs-Lemma-gen-bwactconstant, pairastatenat-list
[]DurQtrace-absActionconstant, astatestream
[]DurQtrace-absActionconstant, astatelist
[]DQctrace-absActionconstant, cstatestream
[]DQctrace-absActionconstant, cstatelist
[]DMSQtrace-absActionconstant, cstatestream
[]DMSQtrace-absActionconstant, cstatelist
[]DQ-refines-DurQ-renconstant, bstatestream
[]DQ-refines-DurQ-renconstant, bstatelist
[]DMSQ-refines-DQ-renconstant, bstatestream
[]DMSQ-refines-DQ-renconstant, bstatelist
[]DQatrace-absActionconstant, astatestream
[]DQatrace-absActionconstant, astatelist
\retval-heapfunction, rvHeap × rvSet → rvHeap
\retval-heapfunction, rvSet × rvSet → rvSet
\set-unionfunction, set × set → set
\store+setfunction, store × set → store
\statesetfunction, stateset × stateset → stateset
\astatesetfunction, astateset × astateset → astateset
\Koenigs-Lemma-gen-bwactfunction, pairastatenat-set × pairastatenat-set → pairastatenat-set
\tidsetfunction, tidset × tidset → tidset
]traceCpartial function, cstatestream × nat × cstate → cstatestream
]traceCpartial function, cstatestream × nat → cstate
]traceCpartial function, cstatelist × nat × cstate → cstatelist
]traceCpartial function, cstatelist × nat → cstate
]traceApartial function, astatestream × nat × astate → astatestream
]traceApartial function, astatestream × nat → astate
]traceApartial function, astatelist × nat × astate → astatelist
]traceApartial function, astatelist × nat → astate
]IOstatestreampartial function, statestream × nat × state → statestream
]IOstatestreampartial function, statestream × nat → state
]IOstatestreampartial function, statelist × nat × state → statelist
]IOstatestreampartial function, statelist × nat → state
]actionstreampartial function, actionstream × nat × action → actionstream
]actionstreampartial function, actionstream × nat → action
]actionstreampartial function, actionlist × nat × action → actionlist
]actionstreampartial function, actionlist × nat → action
]streampartial function, stream × nat × elem → stream
]streampartial function, stream × nat → elem
]Node-heappartial function, heap × Ref → Node
]Node-heapfunction, heap × Ref × Node → heap
]storepartial function, store × elem → data
]storefunction, store × elem × data → store
]list-getputpartial function, list × nat × elem → list
]list-getputpartial function, list × nat → elem
]retval-heappartial function, rvHeap × rvRef → OptElem
]retval-heapfunction, rvHeap × rvRef × OptElem → rvHeap
]Koenigs-Lemma-gen-bwactpartial function, pairastatenat-stream × nat × pairastatenat → pairastatenat-stream
]Koenigs-Lemma-gen-bwactpartial function, pairastatenat-stream × nat → pairastatenat
]Koenigs-Lemma-gen-bwactpartial function, pairastatenat-list × nat × pairastatenat → pairastatenat-list
]Koenigs-Lemma-gen-bwactpartial function, pairastatenat-list × nat → pairastatenat
]DurQtrace-absActionpartial function, astatestream × nat × DurQState → astatestream
]DurQtrace-absActionpartial function, astatestream × nat → DurQState
]DurQtrace-absActionpartial function, astatelist × nat × DurQState → astatelist
]DurQtrace-absActionpartial function, astatelist × nat → DurQState
]DurQtrace-absActionpartial function, actionstream × nat × absAction → actionstream
]DurQtrace-absActionpartial function, actionstream × nat → absAction
]DurQtrace-absActionpartial function, actionlist × nat × absAction → actionlist
]DurQtrace-absActionpartial function, actionlist × nat → absAction
]DQctrace-absActionpartial function, cstatestream × nat × DQState → cstatestream
]DQctrace-absActionpartial function, cstatestream × nat → DQState
]DQctrace-absActionpartial function, cstatelist × nat × DQState → cstatelist
]DQctrace-absActionpartial function, cstatelist × nat → DQState
]DQctrace-absActionpartial function, actionstream × nat × absAction → actionstream
]DQctrace-absActionpartial function, actionstream × nat → absAction
]DQctrace-absActionpartial function, actionlist × nat × absAction → actionlist
]DQctrace-absActionpartial function, actionlist × nat → absAction
]DMSQtrace-absActionpartial function, cstatestream × nat × DMSQState → cstatestream
]DMSQtrace-absActionpartial function, cstatestream × nat → DMSQState
]DMSQtrace-absActionpartial function, cstatelist × nat × DMSQState → cstatelist
]DMSQtrace-absActionpartial function, cstatelist × nat → DMSQState
]DMSQtrace-absActionpartial function, actionstream × nat × absAction → actionstream
]DMSQtrace-absActionpartial function, actionstream × nat → absAction
]DMSQtrace-absActionpartial function, actionlist × nat × absAction → actionlist
]DMSQtrace-absActionpartial function, actionlist × nat → absAction
]DQ-refines-DurQ-renpartial function, bstatestream × nat × DQState → bstatestream
]DQ-refines-DurQ-renpartial function, bstatestream × nat → DQState
]DQ-refines-DurQ-renpartial function, bstatelist × nat × DQState → bstatelist
]DQ-refines-DurQ-renpartial function, bstatelist × nat → DQState
]DMSQ-refines-DQ-renpartial function, bstatestream × nat × DQState → bstatestream
]DMSQ-refines-DQ-renpartial function, bstatestream × nat → DQState
]DMSQ-refines-DQ-renpartial function, bstatelist × nat × DQState → bstatelist
]DMSQ-refines-DQ-renpartial function, bstatelist × nat → DQState
]DMSQ-DQ-refine-instancepartial function, cstatestream × nat × DMSQState → cstatestream
]DMSQ-DQ-refine-instancepartial function, cstatestream × nat → DMSQState
]DMSQ-DQ-refine-instancepartial function, cstatelist × nat × DMSQState → cstatelist
]DMSQ-DQ-refine-instancepartial function, cstatelist × nat → DMSQState
]DQatrace-absActionpartial function, astatestream × nat × DQState → astatestream
]DQatrace-absActionpartial function, astatestream × nat → DQState
]DQatrace-absActionpartial function, astatelist × nat × DQState → astatelist
]DQatrace-absActionpartial function, astatelist × nat → DQState
]DQatrace-absActionpartial function, actionstream × nat × absAction → actionstream
]DQatrace-absActionpartial function, actionstream × nat → absAction
]DQatrace-absActionpartial function, actionlist × nat × absAction → actionlist
]DQatrace-absActionpartial function, actionlist × nat → absAction
^remtaufunction, actionstream → actionstream
^Koenigs-Lemma-genfunction, list → list × nat → list → list
^^Koenigs-Lemma-gen-bwactfunction, pairastatenat-list → pairastatenat-list × nat → pairastatenat-list → pairastatenat-list
aIOforward-is-leqrefinevariable, action
aremtauvariable, action
aactionvariable, action
ainfinite-appendvariable, elem
astreamvariable, elem
alist-delvariable, elem
alist-lastvariable, elem
alist-dupvariable, elem
aelemvariable, elem
alist-datavariable, elem
alistvariable, elem
alist-getputvariable, elem
astore+setvariable, elem
aDQvariable, DQAction
aDMSQvariable, DMSQAction
aDMSQ-proofsvariable, DMSQAction
aDQ-proofsvariable, DQAction
aDurQvariable, DurQAction
aIObackwardvariable, action
aimfinIObackwardvariable, action
aIObackward-INVvariable, action
aimfinIObackward-INVvariable, action
aIObackward-INV-is-leqstarrefinevariable, action
aimfinIObackward-is-refinevariable, action
aDurQ-proofsvariable, DurQAction
aDurQ-renvariable, DurQAction
aDQ-refines-DurQvariable, DurQAction
aDMSQ-refines-DurQvariable, DQAction
aDQ-refines-DurQ-renvariable, DurQAction
aDMSQ-refines-DQ-renvariable, DQAction
aDMSQ-refines-DQvariable, DQAction
aINVIObackward-INVvariable, astate → bool
aINVimfinIObackward-INVvariable, astate → bool
aaabsvariable, DQAction
aaDQ-refines-DurQvariable, absAction
aaabsActionvariable, absAction
aaDMSQ-refines-DurQvariable, absAction
aaDQ-refines-DurQ-renvariable, absAction
aaDMSQ-refines-DQ-renvariable, absAction
aaDMSQ-refines-DQvariable, absAction
aabsDQ-refines-DurQfunction, DurQAction → absAction
aabsaabsfunction, DQAction → absAction
absabspredicate, DMSQState × DQState
absActionabsActionsort,
absaDQ-refines-DurQfunction, DQAction × Tid → DurQPC → DurQAction
abslsabspredicate, DMSQGState × DMSQLState × DMSQPC × DQLState
abspcabsfunction, DMSQGState × DMSQLState × DMSQPC → DQPC
actionactionsort,
actionlistactionstreamsort,
actionstreamactionstreamsort,
addrDMSQvariable, rvRef
addrDMSQ-proofsvariable, rvRef
addressDMSQvariable, Ref
addressDMSQ-proofsvariable, Ref
aexectraceAfunction, AIOAutomaton → astatestream × actionstream → bool
aexecDurQtrace-absActionfunction, AIOAutomaton → astatestream × actionstream → bool
aexecDQatrace-absActionfunction, AIOAutomaton → astatestream × actionstream → bool
aexec*traceAfunction, AIOAutomaton → astatestream × actionstream → bool
aexec*DurQtrace-absActionfunction, AIOAutomaton → astatestream × actionstream → bool
aexec*DQatrace-absActionfunction, AIOAutomaton → astatestream × actionstream → bool
aexecωtraceAfunction, AIOAutomaton → astatestream × actionstream → bool
aexecωDurQtrace-absActionfunction, AIOAutomaton → astatestream × actionstream → bool
aexecωDQatrace-absActionfunction, AIOAutomaton → astatestream × actionstream → bool
aftraceCvariable, nat → action
aftraceAvariable, nat → action
afIOtracevariable, nat → action
afremtauvariable, nat → action
afrestrictedvariable, nat → action
afimfinIObackward-is-refinevariable, nat → action
afragtraceAfunction, AIOAutomaton → astatestream × actionstream → bool
afragDurQtrace-absActionfunction, AIOAutomaton → astatestream × actionstream → bool
afragDQatrace-absActionfunction, AIOAutomaton → astatestream × actionstream → bool
afrag*traceAfunction, AIOAutomaton → astatestream × actionstream → bool
afrag*DurQtrace-absActionfunction, AIOAutomaton → astatestream × actionstream → bool
afrag*DQatrace-absActionfunction, AIOAutomaton → astatestream × actionstream → bool
afragωtraceAfunction, AIOAutomaton → astatestream × actionstream → bool
afragωDurQtrace-absActionfunction, AIOAutomaton → astatestream × actionstream → bool
afragωDQatrace-absActionfunction, AIOAutomaton → astatestream × actionstream → bool
afterrestrictedfunction, IOAutomaton → actionstream × state → bool
aftervrestrictedvariable, actionstream × state → bool
agsabsvariable, DQGState
agsbwabsvariable, DurQGState
agsDQ-refines-DurQvariable, DurQGState
agsDQ-refines-DurQ-renvariable, DurQGState
agsDMSQ-refines-DQ-renvariable, DQGState
agsDMSQ-refines-DQvariable, DQGState
alIOforward-is-leqrefinevariable, actionlist
alIOrefine-defvariable, actionlist
altraceCvariable, actionlist
altraceAvariable, actionlist
alIOtracevariable, actionlist
alremtauvariable, actionlist
alIObackwardvariable, actionlist
alimfinIObackwardvariable, actionlist
alrestrictedvariable, actionlist
alIObackward-INVvariable, actionlist
alimfinIObackward-INVvariable, actionlist
alIObackward-INV-is-leqstarrefinevariable, actionlist
alimfinIObackward-is-refinevariable, actionlist
allocrvDMSQpredicate, Tid → rvRef × rvHeap
allreachableKoenigs-Lemma-genpredicate, graph
alsabsvariable, DQLState
alsbwabsvariable, DurQLState
alsDQ-refines-DurQvariable, DurQLState
alsDQ-refines-DurQ-renvariable, DurQLState
alsDMSQ-refines-DQ-renvariable, DQLState
alsDMSQ-refines-DQvariable, DQLState
alsfabsvariable, Tid → DQLState
alsfbwabsvariable, Tid → DurQLState
alsfDQ-refines-DurQvariable, Tid → DurQLState
alsfDQ-refines-DurQ-renvariable, Tid → DurQLState
alsfDMSQ-refines-DQ-renvariable, Tid → DQLState
alsfDMSQ-refines-DQvariable, Tid → DQLState
amovetraceAfunction, AIOAutomaton → astate × actionstream × astate → bool
amoveDurQtrace-absActionfunction, AIOAutomaton → DurQState × actionstream × DurQState → bool
amoveDQatrace-absActionfunction, AIOAutomaton → DQState × actionstream × DQState → bool
apcabsvariable, DQPC
apcDQ-refines-DurQvariable, DurQPC
apcDQ-refines-DurQ-renvariable, DurQPC
apcDMSQ-refines-DQ-renvariable, DQPC
apcDMSQ-refines-DQvariable, DQPC
apcfabsvariable, Tid → DQPC
apcfbwabsvariable, Tid → DurQPC
apcfDQ-refines-DurQvariable, Tid → DurQPC
apcfDQ-refines-DurQ-renvariable, Tid → DurQPC
apcfDMSQ-refines-DQ-renvariable, Tid → DQPC
apcfDMSQ-refines-DQvariable, Tid → DQPC
asIOforward-is-leqrefinevariable, astate
asIOrefine-defvariable, astate
asIObackwardvariable, astate
asimfinIObackwardvariable, astate
asIObackward-INVvariable, astate
asimfinIObackward-INVvariable, astate
asIObackward-INV-is-leqstarrefinevariable, astate
aspair-astate-natvariable, astate
asimfinIObackward-is-refinevariable, astate
asDMSQ-refines-DQ-renvariable, DQState
asDMSQ-refines-DQvariable, DQState
asfIOforward-is-leqrefinevariable, nat → astate
asfIOrefine-defvariable, nat → astate
asfIObackwardvariable, nat → astate
asfimfinIObackwardvariable, nat → astate
asfIObackward-INVvariable, nat → astate
asfimfinIObackward-INVvariable, nat → astate
asfIObackward-INV-is-leqstarrefinevariable, nat → astate
asfimfinIObackward-is-refinevariable, nat → astate
aslIOforward-is-leqrefinevariable, astatelist
aslIOrefine-defvariable, astatelist
aslIObackwardvariable, astatelist
aslimfinIObackwardvariable, astatelist
aslIObackward-INVvariable, astatelist
aslimfinIObackward-INVvariable, astatelist
aslIObackward-INV-is-leqstarrefinevariable, astatelist
aslimfinIObackward-is-refinevariable, astatelist
asnpair-astate-natvariable, pairastatenat
asnimfinIObackward-is-refinevariable, pairastatenat
asn-limfinIObackward-is-refinevariable, pairastatenat-list
assimfinIObackwardvariable, astateset
assimfinIObackward-INVvariable, astateset
astartfIOforward-is-leqrefinevariable, astate → bool
astartfIObackwardvariable, astate → bool
astartfimfinIObackwardvariable, astate → bool
astartfIObackward-INVvariable, astate → bool
astartfimfinIObackward-INVvariable, astate → bool
astartfIObackward-INV-is-leqstarrefinevariable, astate → bool
astartfimfinIObackward-is-refinevariable, astate → bool
astatetraceAsort,
astateastatesetsort,
astatelisttraceAsort,
astatelistDurQtrace-absActionsort,
astatelistDQatrace-absActionsort,
astatesetastatesetsort,
astatestreamtraceAsort,
astatestreamDurQtrace-absActionsort,
astatestreamDQatrace-absActionsort,
astepfIOforward-is-leqrefinevariable, astate × action × astate → bool
astepfIObackwardvariable, astate × action × astate → bool
astepfimfinIObackwardvariable, astate × action × astate → bool
astepfIObackward-INVvariable, astate × action × astate → bool
astepfimfinIObackward-INVvariable, astate × action × astate → bool
astepfIObackward-INV-is-leqstarrefinevariable, astate × action × astate → bool
astepfimfinIObackward-is-refinevariable, astate × action × astate → bool
atracetraceAfunction, AIOAutomaton → actionstream → bool
atraceDurQtrace-absActionfunction, AIOAutomaton → actionstream → bool
atraceDQatrace-absActionfunction, AIOAutomaton → actionstream → bool
atrace*traceAfunction, AIOAutomaton → actionstream → bool
atrace*DurQtrace-absActionfunction, AIOAutomaton → actionstream → bool
atrace*DQatrace-absActionfunction, AIOAutomaton → actionstream → bool
atraceωtraceAfunction, AIOAutomaton → actionstream → bool
atraceωDurQtrace-absActionfunction, AIOAutomaton → actionstream → bool
atraceωDQatrace-absActionfunction, AIOAutomaton → actionstream → bool
aσIOforward-is-leqrefinevariable, astatestream
aσIOrefine-defvariable, astatestream
aσIObackwardvariable, astatestream
aσimfinIObackwardvariable, astatestream
aσIObackward-INVvariable, astatestream
aσimfinIObackward-INVvariable, astatestream
aσIObackward-INV-is-leqstarrefinevariable, astatestream
aσimfinIObackward-is-refinevariable, astatestream
blist-delvariable, elem
blist-lastvariable, elem
blist-dupvariable, elem
belemvariable, elem
blistvariable, elem
blist-getputvariable, elem
bexecDQ-refines-DurQ-renfunction, BIOAutomaton → bstatestream × actionstream → bool
bexecDMSQ-refines-DQ-renfunction, BIOAutomaton → bstatestream × actionstream → bool
bexec*DQ-refines-DurQ-renfunction, BIOAutomaton → bstatestream × actionstream → bool
bexec*DMSQ-refines-DQ-renfunction, BIOAutomaton → bstatestream × actionstream → bool
bexecωDQ-refines-DurQ-renfunction, BIOAutomaton → bstatestream × actionstream → bool
bexecωDMSQ-refines-DQ-renfunction, BIOAutomaton → bstatestream × actionstream → bool
bfragDQ-refines-DurQ-renfunction, BIOAutomaton → bstatestream × actionstream → bool
bfragDMSQ-refines-DQ-renfunction, BIOAutomaton → bstatestream × actionstream → bool
bfrag*DQ-refines-DurQ-renfunction, BIOAutomaton → bstatestream × actionstream → bool
bfrag*DMSQ-refines-DQ-renfunction, BIOAutomaton → bstatestream × actionstream → bool
bfragωDQ-refines-DurQ-renfunction, BIOAutomaton → bstatestream × actionstream → bool
bfragωDMSQ-refines-DQ-renfunction, BIOAutomaton → bstatestream × actionstream → bool
bmoveDQ-refines-DurQ-renfunction, BIOAutomaton → DQState × actionstream × DQState → bool
bmoveDMSQ-refines-DQ-renfunction, BIOAutomaton → DQState × actionstream × DQState → bool
bstatelistDQ-refines-DurQ-rensort,
bstatelistDMSQ-refines-DQ-rensort,
bstatestreamDQ-refines-DurQ-rensort,
bstatestreamDMSQ-refines-DQ-rensort,
btraceDQ-refines-DurQ-renfunction, BIOAutomaton → actionstream → bool
btraceDMSQ-refines-DQ-renfunction, BIOAutomaton → actionstream → bool
btrace*DQ-refines-DurQ-renfunction, BIOAutomaton → actionstream → bool
btrace*DMSQ-refines-DQ-renfunction, BIOAutomaton → actionstream → bool
btraceωDQ-refines-DurQ-renfunction, BIOAutomaton → actionstream → bool
btraceωDMSQ-refines-DQ-renfunction, BIOAutomaton → actionstream → bool
butlastntraceCpartial function, nat × cstatelist → cstatelist
butlastntraceApartial function, nat × astatelist → astatelist
butlastnIOstatestreampartial function, nat × statelist → statelist
butlastnactionstreampartial function, nat × actionlist → actionlist
butlastnlist-lastpartial function, nat × list → list
butlastnreflistpartial function, nat × reflist → reflist
butlastnKoenigs-Lemma-gen-bwactpartial function, nat × pairastatenat-list → pairastatenat-list
butlastnDurQtrace-absActionpartial function, nat × astatelist → astatelist
butlastnDQctrace-absActionpartial function, nat × cstatelist → cstatelist
butlastnDMSQtrace-absActionpartial function, nat × cstatelist → cstatelist
butlastnDQ-refines-DurQ-renpartial function, nat × bstatelist → bstatelist
butlastnDMSQ-refines-DQ-renpartial function, nat × bstatelist → bstatelist
butlastnDQatrace-absActionpartial function, nat × astatelist → astatelist
bwabsbwabspredicate, DQState × DurQState
bwabsabwabsfunction, DQAction → DurQAction
bwabspcbwabspredicate, Tid → DQPC × Tid → DQLState × Tid → DurQPC × Tid → DurQLState
bwabspcfbwabsfunction, DQPC → DurQPC
bwlabsfbwabsfunction, DQLState → DurQLState
bwsimIObackwardpredicate, CIOAutomaton × AIOAutomaton × cstate × astate → bool
bwsimIObackward-INVpredicate, CIOAutomaton × AIOAutomaton × cstate × astate → bool
bwsimIObackward-INVpredicate, CIOAutomaton × AIOAutomaton × cstate × astate → bool × cstate → bool × astate → bool
bwsimDQ-refines-DurQ-instancepredicate, CIOAutomaton × AIOAutomaton × DQState × DurQState → bool × DQState → bool × DurQState → bool
bwsimDQ-refines-DurQ-instancepredicate, CIOAutomaton × AIOAutomaton × DQState × DurQState → bool
bwsimDQ-refines-DurQ-renpredicate, BIOAutomaton × AIOAutomaton × DQState × DurQState → bool × DQState → bool × DurQState → bool
bwsimDQ-refines-DurQ-renpredicate, BIOAutomaton × AIOAutomaton × DQState × DurQState → bool
clist-delvariable, elem
clist-lastvariable, elem
clist-dupvariable, elem
celemvariable, elem
clistvariable, elem
clist-getputvariable, elem
cINVIObackward-INVvariable, cstate → bool
cINVimfinIObackward-INVvariable, cstate → bool
caabsvariable, DMSQAction
caDQ-refines-DurQvariable, DQAction
caDQ-refines-DurQ-renvariable, DQAction
caDMSQ-refines-DQ-renvariable, DMSQAction
caDMSQ-refines-DQvariable, DMSQAction
callARunDurQfunction, Tid → DurQAction
callRUNDMSQfunction, Tid → DMSQAction
callRunDQfunction, Tid → DQAction
cexectraceCfunction, CIOAutomaton → cstatestream × actionstream → bool
cexecDQctrace-absActionfunction, CIOAutomaton → cstatestream × actionstream → bool
cexecDMSQtrace-absActionfunction, CIOAutomaton → cstatestream × actionstream → bool
cexec*traceCfunction, CIOAutomaton → cstatestream × actionstream → bool
cexec*DQctrace-absActionfunction, CIOAutomaton → cstatestream × actionstream → bool
cexec*DMSQtrace-absActionfunction, CIOAutomaton → cstatestream × actionstream → bool
cexecωtraceCfunction, CIOAutomaton → cstatestream × actionstream → bool
cexecωDQctrace-absActionfunction, CIOAutomaton → cstatestream × actionstream → bool
cexecωDMSQtrace-absActionfunction, CIOAutomaton → cstatestream × actionstream → bool
cfKoenigs-Lemma-genvariable, list → list
cfragtraceCfunction, CIOAutomaton → cstatestream × actionstream → bool
cfragDQctrace-absActionfunction, CIOAutomaton → cstatestream × actionstream → bool
cfragDMSQtrace-absActionfunction, CIOAutomaton → cstatestream × actionstream → bool
cfrag*traceCfunction, CIOAutomaton → cstatestream × actionstream → bool
cfrag*DQctrace-absActionfunction, CIOAutomaton → cstatestream × actionstream → bool
cfrag*DMSQtrace-absActionfunction, CIOAutomaton → cstatestream × actionstream → bool
cfragωtraceCfunction, CIOAutomaton → cstatestream × actionstream → bool
cfragωDQctrace-absActionfunction, CIOAutomaton → cstatestream × actionstream → bool
cfragωDMSQtrace-absActionfunction, CIOAutomaton → cstatestream × actionstream → bool
checkEmpDMSQfunction, Tid → DMSQAction
chooseD2DMSQfunction, rvRef × OptElem → DMSQAction
chooseE1DMSQfunction, Ref × Node × bool → DMSQAction
cmovetraceCfunction, CIOAutomaton → cstate × actionstream × cstate → bool
cmoveDQctrace-absActionfunction, CIOAutomaton → DQState × actionstream × DQState → bool
cmoveDMSQtrace-absActionfunction, CIOAutomaton → DMSQState × actionstream × DMSQState → bool
cmoveDMSQ-DQ-refine-instancefunction, CIOAutomaton → DMSQState × actionstream × DMSQState → bool
contentabsfunction, reflist × heap → list
crashedDQconstant, DQPC
crashedDMSQconstant, DMSQPC
crashedDurQconstant, DurQPC
csIOforward-is-leqrefinevariable, cstate
csIOrefine-defvariable, cstate
csIOforwardvariable, cstate
csabsvariable, DMSQState
csIObackwardvariable, cstate
csimfinIObackwardvariable, cstate
csIObackward-INVvariable, cstate
csimfinIObackward-INVvariable, cstate
csIObackward-INV-is-leqstarrefinevariable, cstate
csimfinIObackward-is-refinevariable, cstate
csDMSQ-refines-DurQvariable, DMSQState
csDMSQ-refines-DQ-renvariable, DMSQState
csDMSQ-refines-DQvariable, DMSQState
csfIOforward-is-leqrefinevariable, nat → cstate
csfIOrefine-defvariable, nat → cstate
csfIObackwardvariable, nat → cstate
csfimfinIObackwardvariable, nat → cstate
csfIObackward-INVvariable, nat → cstate
csfimfinIObackward-INVvariable, nat → cstate
csfIObackward-INV-is-leqstarrefinevariable, nat → cstate
csfimfinIObackward-is-refinevariable, nat → cstate
cslIOforward-is-leqrefinevariable, cstatelist
cslIOrefine-defvariable, cstatelist
cslIObackwardvariable, cstatelist
cslimfinIObackwardvariable, cstatelist
cslIObackward-INVvariable, cstatelist
cslimfinIObackward-INVvariable, cstatelist
cslIObackward-INV-is-leqstarrefinevariable, cstatelist
cslimfinIObackward-is-refinevariable, cstatelist
cstartfIOforward-is-leqrefinevariable, cstate → bool
cstartfIObackwardvariable, cstate → bool
cstartfimfinIObackwardvariable, cstate → bool
cstartfIObackward-INVvariable, cstate → bool
cstartfimfinIObackward-INVvariable, cstate → bool
cstartfIObackward-INV-is-leqstarrefinevariable, cstate → bool
cstartfimfinIObackward-is-refinevariable, cstate → bool
cstateC-IO-Automatonsort,
cstatetraceCsort,
cstatelisttraceCsort,
cstatelistDQctrace-absActionsort,
cstatelistDMSQtrace-absActionsort,
cstatestreamtraceCsort,
cstatestreamDQctrace-absActionsort,
cstatestreamDMSQtrace-absActionsort,
cstepfIOforward-is-leqrefinevariable, cstate × action × cstate → bool
cstepfIObackwardvariable, cstate × action × cstate → bool
cstepfimfinIObackwardvariable, cstate × action × cstate → bool
cstepfIObackward-INVvariable, cstate × action × cstate → bool
cstepfimfinIObackward-INVvariable, cstate × action × cstate → bool
cstepfIObackward-INV-is-leqstarrefinevariable, cstate × action × cstate → bool
cstepfimfinIObackward-is-refinevariable, cstate × action × cstate → bool
ctracetraceCfunction, CIOAutomaton → actionstream → bool
ctraceDQctrace-absActionfunction, CIOAutomaton → actionstream → bool
ctraceDMSQtrace-absActionfunction, CIOAutomaton → actionstream → bool
ctrace*traceCfunction, CIOAutomaton → actionstream → bool
ctrace*DQctrace-absActionfunction, CIOAutomaton → actionstream → bool
ctrace*DMSQtrace-absActionfunction, CIOAutomaton → actionstream → bool
ctraceωtraceCfunction, CIOAutomaton → actionstream → bool
ctraceωDQctrace-absActionfunction, CIOAutomaton → actionstream → bool
ctraceωDMSQtrace-absActionfunction, CIOAutomaton → actionstream → bool
cσIOforward-is-leqrefinevariable, cstatestream
cσIOrefine-defvariable, cstatestream
cσIObackwardvariable, cstatestream
cσimfinIObackwardvariable, cstatestream
cσIObackward-INVvariable, cstatestream
cσimfinIObackward-INVvariable, cstatestream
cσIObackward-INV-is-leqstarrefinevariable, cstatestream
cσimfinIObackward-is-refinevariable, cstatestream
ddatavariable, data
dstore+setvariable, data
datadatasort,
deqIDNodevariable, OptTid
detrestrictedpredicate, IOAutomaton
disjtraceCpredicate, cstatelist × cstatelist
disjtraceApredicate, astatelist × astatelist
disjIOstatestreampredicate, statelist × statelist
disjactionstreampredicate, actionlist × actionlist
disjlist-duppredicate, list × list
disjreflistpredicate, reflist × reflist
disjKoenigs-Lemma-gen-bwactpredicate, pairastatenat-list × pairastatenat-list
disjDurQtrace-absActionpredicate, astatelist × astatelist
disjDQctrace-absActionpredicate, cstatelist × cstatelist
disjDMSQtrace-absActionpredicate, cstatelist × cstatelist
disjDQ-refines-DurQ-renpredicate, bstatelist × bstatelist
disjDMSQ-refines-DQ-renpredicate, bstatelist × bstatelist
disjDQatrace-absActionpredicate, astatelist × astatelist
doDeqDMSQfunction, Tid → DMSQAction
doDeqEmptyDMSQfunction, Tid → DMSQAction
doEnqDMSQfunction, Tid → DMSQAction
domretval-heapfunction, rvHeap → rvSet
domstore+setfunction, store → set
dominfgraph-gen-basicfunction, graph → elem → bool
domKoenigs-Lemma-gen-bwactfunction, graph → pairastatenat → bool
dqsbwabsvariable, DQState
dqsDQ-refines-DurQvariable, DQState
dqsDQ-refines-DurQ-renvariable, DQState
dummytidtidconstant, Tid
dupstraceCpredicate, cstatelist
dupstraceApredicate, astatelist
dupsIOstatestreampredicate, statelist
dupsactionstreampredicate, actionlist
dupslist-duppredicate, list
dupsreflistpredicate, reflist
dupsKoenigs-Lemma-gen-bwactpredicate, pairastatenat-list
dupsDurQtrace-absActionpredicate, astatelist
dupsDQctrace-absActionpredicate, cstatelist
dupsDMSQtrace-absActionpredicate, cstatelist
dupsDQ-refines-DurQ-renpredicate, bstatelist
dupsDMSQ-refines-DQ-renpredicate, bstatelist
dupsDQatrace-absActionpredicate, astatelist
durqsbwabsvariable, DurQState
durqsDQ-refines-DurQvariable, DurQState
durqsDQ-refines-DurQ-renvariable, DurQState
ePinfgraph-genvariable, elem → bool
ePKoenigs-Lemma-genvariable, elem → bool
edgeinfgraph-gen-basicfunction, graph → elem × elem → bool
edgeKoenigs-Lemma-gen-bwactfunction, graph → pairastatenat × pairastatenat → bool
elemelemsort,
equalownsDMSQpredicate, heap × heap × Ref → OptTid × Tid × heap × heap × Ref → OptTid
equalrlDMSQpredicate, reflist × heap × heap × heap × heap
esinfgraph-gen-basicvariable, elem × elem → bool
execIOtracefunction, IOAutomaton → statestream × actionstream → bool
exec*IOtracefunction, IOAutomaton → statestream × actionstream → bool
execωIOtracefunction, IOAutomaton → statestream × actionstream → bool
extactionpredicate, action
fstream-basicvariable, nat → elem
fillfirsttraceCfunction, nat × cstate × cstatelist → cstatelist
fillfirsttraceAfunction, nat × astate × astatelist → astatelist
fillfirstIOstatestreamfunction, nat × state × statelist → statelist
fillfirstactionstreamfunction, nat × action × actionlist → actionlist
fillfirstlist-lastfunction, nat × elem × list → list
fillfirstreflistfunction, nat × Ref × reflist → reflist
fillfirstKoenigs-Lemma-gen-bwactfunction, nat × pairastatenat × pairastatenat-list → pairastatenat-list
fillfirstDurQtrace-absActionfunction, nat × DurQState × astatelist → astatelist
fillfirstDurQtrace-absActionfunction, nat × absAction × actionlist → actionlist
fillfirstDQctrace-absActionfunction, nat × DQState × cstatelist → cstatelist
fillfirstDQctrace-absActionfunction, nat × absAction × actionlist → actionlist
fillfirstDMSQtrace-absActionfunction, nat × DMSQState × cstatelist → cstatelist
fillfirstDMSQtrace-absActionfunction, nat × absAction × actionlist → actionlist
fillfirstDQ-refines-DurQ-renfunction, nat × DQState × bstatelist → bstatelist
fillfirstDMSQ-refines-DQ-renfunction, nat × DQState × bstatelist → bstatelist
fillfirstDMSQ-DQ-refine-instancefunction, nat × DMSQState × cstatelist → cstatelist
fillfirstDQatrace-absActionfunction, nat × DQState × astatelist → astatelist
fillfirstDQatrace-absActionfunction, nat × absAction × actionlist → actionlist
finrestrictedpredicate, IOAutomaton
fininvdeqDQ-refines-DurQpredicate, Tid → DQPC
finoutKoenigs-Lemma-genpredicate, graph
finptraceCpredicate, cstatestream
finptraceApredicate, astatestream
finpIOstatestreampredicate, statestream
finpactionstreampredicate, actionstream
finpstream-basicpredicate, stream
finpKoenigs-Lemma-gen-bwactpredicate, pairastatenat-stream
finpDurQtrace-absActionpredicate, astatestream
finpDQctrace-absActionpredicate, cstatestream
finpDMSQtrace-absActionpredicate, cstatestream
finpDQ-refines-DurQ-renpredicate, bstatestream
finpDMSQ-refines-DQ-renpredicate, bstatestream
finpDQatrace-absActionpredicate, astatestream
finrootKoenigs-Lemma-genpredicate, graph
firstDMSQvariable, Ref
firstDMSQ-proofsvariable, Ref
firstntraceCpartial function, nat × cstatelist → cstatelist
firstntraceApartial function, nat × astatelist → astatelist
firstnIOstatestreampartial function, nat × statelist → statelist
firstnactionstreampartial function, nat × actionlist → actionlist
firstnlist-delpartial function, nat × list → list
firstnKoenigs-Lemma-gen-bwactpartial function, nat × pairastatenat-list → pairastatenat-list
firstnDurQtrace-absActionpartial function, nat × astatelist → astatelist
firstnDQctrace-absActionpartial function, nat × cstatelist → cstatelist
firstnDMSQtrace-absActionpartial function, nat × cstatelist → cstatelist
firstnDQ-refines-DurQ-renpartial function, nat × bstatelist → bstatelist
firstnDMSQ-refines-DQ-renpartial function, nat × bstatelist → bstatelist
firstnDQatrace-absActionpartial function, nat × astatelist → astatelist
forestrestrictedpredicate, IOAutomaton × state → bool
forestrestrictedpredicate, IOAutomaton
fragIOtracefunction, IOAutomaton → statestream × actionstream → bool
frag*IOtracefunction, IOAutomaton → statestream × actionstream → bool
fragvtraceCvariable, cstatestream × actionstream → bool
fragvtraceAvariable, astatestream × actionstream → bool
fragvIOtracevariable, statestream × actionstream → bool
fragωIOtracefunction, IOAutomaton → statestream × actionstream → bool
fromtraceCpartial function, cstatelist × nat → cstatelist
fromtraceCpartial function, cstatestream × nat → cstatestream
fromtraceCfunction, nat → cstate × nat → nat → cstate
fromtraceApartial function, astatelist × nat → astatelist
fromtraceApartial function, astatestream × nat → astatestream
fromtraceAfunction, nat → astate × nat → nat → astate
fromIOstatestreampartial function, statelist × nat → statelist
fromIOstatestreampartial function, statestream × nat → statestream
fromIOstatestreamfunction, nat → state × nat → nat → state
fromactionstreampartial function, actionlist × nat → actionlist
fromactionstreampartial function, actionstream × nat → actionstream
fromactionstreamfunction, nat → action × nat → nat → action
fromstreampartial function, list × nat → list
fromstreampartial function, stream × nat → stream
fromstreamfunction, nat → elem × nat → nat → elem
fromDMSQfunction, reflist × Ref → reflist
fromKoenigs-Lemma-gen-bwactpartial function, pairastatenat-list × nat → pairastatenat-list
fromKoenigs-Lemma-gen-bwactpartial function, pairastatenat-stream × nat → pairastatenat-stream
fromKoenigs-Lemma-gen-bwactfunction, nat → pairastatenat × nat → nat → pairastatenat
fromDurQtrace-absActionpartial function, astatelist × nat → astatelist
fromDurQtrace-absActionpartial function, astatestream × nat → astatestream
fromDurQtrace-absActionfunction, nat → DurQState × nat → nat → DurQState
fromDurQtrace-absActionfunction, nat → absAction × nat → nat → absAction
fromDQctrace-absActionpartial function, cstatelist × nat → cstatelist
fromDQctrace-absActionpartial function, cstatestream × nat → cstatestream
fromDQctrace-absActionfunction, nat → DQState × nat → nat → DQState
fromDQctrace-absActionfunction, nat → absAction × nat → nat → absAction
fromDMSQtrace-absActionpartial function, cstatelist × nat → cstatelist
fromDMSQtrace-absActionpartial function, cstatestream × nat → cstatestream
fromDMSQtrace-absActionfunction, nat → DMSQState × nat → nat → DMSQState
fromDMSQtrace-absActionfunction, nat → absAction × nat → nat → absAction
fromDQ-refines-DurQ-renpartial function, bstatelist × nat → bstatelist
fromDQ-refines-DurQ-renpartial function, bstatestream × nat → bstatestream
fromDMSQ-refines-DQ-renpartial function, bstatelist × nat → bstatelist
fromDMSQ-refines-DQ-renpartial function, bstatestream × nat → bstatestream
fromDMSQ-DQ-refine-instancefunction, nat → DMSQState × nat → nat → DMSQState
fromDQatrace-absActionpartial function, astatelist × nat → astatelist
fromDQatrace-absActionpartial function, astatestream × nat → astatestream
fromDQatrace-absActionfunction, nat → DQState × nat → nat → DQState
fromDQatrace-absActionfunction, nat → absAction × nat → nat → absAction
frometraceCfunction, cstatelist × cstate → cstatelist
frometraceAfunction, astatelist × astate → astatelist
fromeIOstatestreamfunction, statelist × state → statelist
fromeactionstreamfunction, actionlist × action → actionlist
fromelist-delfunction, list × elem → list
fromeKoenigs-Lemma-gen-bwactfunction, pairastatenat-list × pairastatenat → pairastatenat-list
fromeDurQtrace-absActionfunction, astatelist × DurQState → astatelist
fromeDurQtrace-absActionfunction, actionlist × absAction → actionlist
fromeDQctrace-absActionfunction, cstatelist × DQState → cstatelist
fromeDQctrace-absActionfunction, actionlist × absAction → actionlist
fromeDMSQtrace-absActionfunction, cstatelist × DMSQState → cstatelist
fromeDMSQtrace-absActionfunction, actionlist × absAction → actionlist
fromeDQ-refines-DurQ-renfunction, bstatelist × DQState → bstatelist
fromeDMSQ-refines-DQ-renfunction, bstatelist × DQState → bstatelist
fromeDMSQ-DQ-refine-instancefunction, cstatelist × DMSQState → cstatelist
fromeDQatrace-absActionfunction, astatelist × DQState → astatelist
fromeDQatrace-absActionfunction, actionlist × absAction → actionlist
fwsimIOforwardpredicate, CIOAutomaton × AIOAutomaton × astate × cstate → bool
fwsimDMSQ-refines-DQ-renpredicate, CIOAutomaton × BIOAutomaton × DQState × DMSQState → bool
fwsimDMSQ-DQ-refine-instancepredicate, CIOAutomaton × AIOAutomaton × DQState × DMSQState → bool
ginfgraph-gen-basicvariable, graph
gdomDQ-refines-DurQ-instancefunction, graph → pairastatenat → bool
globalACrashDurQconstant, DurQAction
globalCRASHDMSQconstant, DMSQAction
globalCRASHabsActionconstant, absAction
globalCrashDQconstant, DQAction
globalFLUSHHEADDMSQconstant, DMSQAction
globalFLUSHVALDMSQfunction, Ref → DMSQAction
graphinfgraph-gen-basicsort,
gsDQvariable, DQGState
gsDMSQvariable, DMSQGState
gsDMSQ-proofsvariable, DMSQGState
gsabsvariable, DMSQGState
gsDQ-proofsvariable, DQGState
gsDurQvariable, DurQGState
gsDurQ-proofsvariable, DurQGState
gsbwabsvariable, DQGState
gsDurQ-renvariable, DurQGState
gsDQ-refines-DurQvariable, DQGState
gsDQ-refines-DurQ-renvariable, DQGState
gsDMSQ-refines-DQ-renvariable, DMSQGState
gsDMSQ-refines-DQvariable, DMSQGState
gstateDQvariable, DQGState
gstateDMSQvariable, DMSQGState
gstateDMSQ-proofsvariable, DMSQGState
gstateDQ-proofsvariable, DQGState
gstateDurQvariable, DurQGState
gstateDurQ-proofsvariable, DurQGState
gstateDurQ-renvariable, DurQGState
gstepfDQfunction, DQGState × DQLState × DQPC × DQAction → DQGState
gstepfDMSQfunction, DMSQGState × DMSQLState × DMSQPC × DMSQAction → DMSQGState
gstepfDurQfunction, DurQGState × DurQLState × DurQPC × DurQAction → DurQGState
haspathanylengthKoenigs-Lemma-genfunction, graph → elem → bool
haspathanylengthKoenigs-Lemma-gen-bwactfunction, graph → pairastatenat → bool
hdtraceCpartial function, cstatestream → cstate
hdtraceCpartial function, cstatelist → cstate
hdtraceApartial function, astatestream → astate
hdtraceApartial function, astatelist → astate
hdIOstatestreampartial function, statestream → state
hdIOstatestreampartial function, statelist → state
hdactionstreampartial function, actionstream → action
hdactionstreampartial function, actionlist → action
hdstreampartial function, stream → elem
hdKoenigs-Lemma-gen-bwactpartial function, pairastatenat-stream → pairastatenat
hdDurQtrace-absActionpartial function, astatestream → DurQState
hdDurQtrace-absActionpartial function, astatelist → DurQState
hdDurQtrace-absActionpartial function, actionstream → absAction
hdDurQtrace-absActionpartial function, actionlist → absAction
hdDQctrace-absActionpartial function, cstatestream → DQState
hdDQctrace-absActionpartial function, cstatelist → DQState
hdDQctrace-absActionpartial function, actionstream → absAction
hdDQctrace-absActionpartial function, actionlist → absAction
hdDMSQtrace-absActionpartial function, cstatestream → DMSQState
hdDMSQtrace-absActionpartial function, cstatelist → DMSQState
hdDMSQtrace-absActionpartial function, actionstream → absAction
hdDMSQtrace-absActionpartial function, actionlist → absAction
hdDQ-refines-DurQ-renpartial function, bstatestream → DQState
hdDQ-refines-DurQ-renpartial function, bstatelist → DQState
hdDMSQ-refines-DQ-renpartial function, bstatestream → DQState
hdDMSQ-refines-DQ-renpartial function, bstatelist → DQState
hdDMSQ-DQ-refine-instancepartial function, cstatestream → DMSQState
hdDMSQ-DQ-refine-instancepartial function, cstatelist → DMSQState
hdDQatrace-absActionpartial function, astatestream → DQState
hdDQatrace-absActionpartial function, astatelist → DQState
hdDQatrace-absActionpartial function, actionstream → absAction
hdDQatrace-absActionpartial function, actionlist → absAction
headlist-datavariable, elem
heapNode-heapsort,
iNVtraceCvariable, cstate → bool
iNVtraceAvariable, astate → bool
iNVIOtracevariable, state → bool
idleDQconstant, DQPC
idleDMSQconstant, DMSQPC
idleDurQconstant, DurQPC
iiinfinite-appendvariable, nat → nat
iigeninfinite-appendvariable, nat → nat → nat
imfinbwsimimfinIObackwardpredicate, CIOAutomaton × AIOAutomaton × cstate × astate → bool
imfinbwsimimfinIObackward-INVpredicate, CIOAutomaton × AIOAutomaton × cstate × astate → bool × cstate → bool × astate → bool
imfinbwsimDQ-refines-DurQ-instancepredicate, CIOAutomaton × AIOAutomaton × DQState × DurQState → bool × DQState → bool × DurQState → bool
imfinbwsimDQ-refines-DurQ-instancepredicate, CIOAutomaton × AIOAutomaton × DQState × DurQState → bool
imfinbwsimDQ-refines-DurQ-renpredicate, BIOAutomaton × AIOAutomaton × DQState × DurQState → bool × DQState → bool × DurQState → bool
imfinbwsimDQ-refines-DurQ-renpredicate, BIOAutomaton × AIOAutomaton × DQState × DurQState → bool
infgraphKoenigs-Lemma-genpredicate, graph
invDEQDMSQfunction, Tid → DMSQAction
invDeqDQconstant, DQPC
invDeqDurQconstant, DurQPC
invENQDMSQfunction, Tid × elem → DMSQAction
invENQvalueDMSQvariable, elem
invENQvalueDMSQ-proofsvariable, elem
invEnqDQconstant, DQPC
invEnqDurQconstant, DurQPC
invFLUSHVALrDMSQvariable, Ref
invFLUSHVALrDMSQ-proofsvariable, Ref
ioautIO-Aut-datavariable, IOAutomaton
isrootinfgraph-genfunction, graph → elem → bool
isrootKoenigs-Lemma-gen-bwactfunction, graph → pairastatenat → bool
isstaterestrictedvariable, state → bool
ivalDQvariable, elem
ivalDQ-proofsvariable, elem
ivalDurQvariable, elem
ivalDurQ-proofsvariable, elem
ivalDurQ-renvariable, elem
jjinfinite-appendvariable, nat → nat
lstream-basicvariable, list
lastntraceCpartial function, nat × cstatelist → cstatelist
lastntraceApartial function, nat × astatelist → astatelist
lastnIOstatestreampartial function, nat × statelist → statelist
lastnactionstreampartial function, nat × actionlist → actionlist
lastnlist-delpartial function, nat × list → list
lastnKoenigs-Lemma-gen-bwactpartial function, nat × pairastatenat-list → pairastatenat-list
lastnDurQtrace-absActionpartial function, nat × astatelist → astatelist
lastnDQctrace-absActionpartial function, nat × cstatelist → cstatelist
lastnDMSQtrace-absActionpartial function, nat × cstatelist → cstatelist
lastnDQ-refines-DurQ-renpartial function, nat × bstatelist → bstatelist
lastnDMSQ-refines-DQ-renpartial function, nat × bstatelist → bstatelist
lastnDQatrace-absActionpartial function, nat × astatelist → astatelist
lfinfinite-appendvariable, nat → list
lfgeninfinite-appendvariable, nat → nat → list
listlist-datasort,
listpDMSQpredicate, reflist × heap × heap × Ref → OptTid
lsDQvariable, DQLState
lsDMSQvariable, DMSQLState
lsDMSQ-proofsvariable, DMSQLState
lsabsvariable, DMSQLState
lsDQ-proofsvariable, DQLState
lsDurQvariable, DurQLState
lsDurQ-proofsvariable, DurQLState
lsbwabsvariable, DQLState
lsDurQ-renvariable, DurQLState
lsDQ-refines-DurQvariable, DQLState
lsDQ-refines-DurQ-renvariable, DQLState
lsDMSQ-refines-DQ-renvariable, DMSQLState
lsDMSQ-refines-DQvariable, DMSQLState
lsfDQvariable, Tid → DQLState
lsfDMSQvariable, Tid → DMSQLState
lsfDMSQ-proofsvariable, Tid → DMSQLState
lsfabsvariable, Tid → DMSQLState
lsfDQ-proofsvariable, Tid → DQLState
lsfDurQvariable, Tid → DurQLState
lsfDurQ-proofsvariable, Tid → DurQLState
lsfbwabsvariable, Tid → DQLState
lsfDurQ-renvariable, Tid → DurQLState
lsfDQ-refines-DurQvariable, Tid → DQLState
lsfDQ-refines-DurQ-renvariable, Tid → DQLState
lsfDMSQ-refines-DQ-renvariable, Tid → DMSQLState
lsfDMSQ-refines-DQvariable, Tid → DMSQLState
lstDMSQvariable, Ref
lstDMSQ-proofsvariable, Ref
lstepDQpredicate, DQGState × DQLState × DQPC × DQAction × DQGState × DQLState × DQPC
lstepDMSQpredicate, DMSQGState × DMSQLState × DMSQPC × DMSQAction × DMSQGState × DMSQLState × DMSQPC
lstepDurQpredicate, DurQGState × DurQLState × DurQPC × DurQAction × DurQGState × DurQLState × DurQPC
lstepfDQfunction, DQGState × DQLState × DQPC × DQAction → DQLState
lstepfDMSQfunction, DMSQGState × DMSQLState × DMSQPC × DMSQAction → DMSQLState
lstepfDurQfunction, DurQGState × DurQLState × DurQPC × DurQAction → DurQLState
minfinite-appendvariable, nat
mnat-infvariable, nat
mstream-basicvariable, nat
mlist-delvariable, nat
mlist-lastvariable, nat
mlist-getputvariable, nat
markedpDMSQpredicate, reflist × heap
minnat-inffunction, natinf × natinf → natinf
mkNodefunction, elem × OptTid × Ref → Node
mkdgsDurQ-renfunction, list → DurQGState
mkgsDQfunction, list → DQGState
mkgsDMSQfunction, heap × heap × Ref × Ref × Ref × Tid → rvRef × Tid → rvRef × rvHeap × rvHeap × reflist × reflist × Ref → OptTid × rvRef → rvOwner → DMSQGState
mkgsDurQfunction, list → DurQGState
mklisttraceCfunction, cstate × nat → cstatelist
mklisttraceAfunction, astate × nat → astatelist
mklistIOstatestreamfunction, state × nat → statelist
mklistactionstreamfunction, action × nat → actionlist
mklistlist-lastfunction, elem × nat → list
mklistreflistfunction, Ref × nat → reflist
mklistKoenigs-Lemma-gen-bwactfunction, pairastatenat × nat → pairastatenat-list
mklistDurQtrace-absActionfunction, DurQState × nat → astatelist
mklistDurQtrace-absActionfunction, absAction × nat → actionlist
mklistDQctrace-absActionfunction, DQState × nat → cstatelist
mklistDQctrace-absActionfunction, absAction × nat → actionlist
mklistDMSQtrace-absActionfunction, DMSQState × nat → cstatelist
mklistDMSQtrace-absActionfunction, absAction × nat → actionlist
mklistDQ-refines-DurQ-renfunction, DQState × nat → bstatelist
mklistDMSQ-refines-DQ-renfunction, DQState × nat → bstatelist
mklistDMSQ-DQ-refine-instancefunction, DMSQState × nat → cstatelist
mklistDQatrace-absActionfunction, DQState × nat → astatelist
mklistDQatrace-absActionfunction, absAction × nat → actionlist
mklsDQfunction, Tid × bool × elem × OptElem × elem × OptElem → DQLState
mklsDMSQfunction, Tid × elem × OptElem × Ref × Node × bool × Ref × Ref × rvRef × OptElem × Ref × Tid × rvRef → DMSQLState
mklsDurQfunction, Tid × elem × OptElem × elem × OptElem → DurQLState
mkstateDQfunction, DQGState × Tid → DQLState × Tid → DQPC → DQState
mkstateDMSQfunction, DMSQGState × Tid → DMSQLState × Tid → DMSQPC → DMSQState
mkstateDurQfunction, DurQGState × Tid → DurQLState × Tid → DurQPC → DurQState
moveIOtracefunction, IOAutomaton → state × actionstream × state → bool
movevtraceCvariable, cstate × actionstream × cstate → bool
movevtraceAvariable, astate × actionstream × astate → bool
movevIOtracevariable, state × actionstream × state → bool
ninfinite-appendvariable, nat
nnat-infvariable, nat
nlist-delvariable, nat
nlist-lastvariable, nat
nlist-datavariable, nat
nlist-getputvariable, nat
npair-astate-natvariable, nat
natnat-basicsort,
natinfnat-infsort,
ndNodevariable, Node
ndDMSQvariable, Node
ndDMSQ-proofsvariable, Node
ndabsvariable, Node
nextNodevariable, Ref
nextjinfinite-appendvariable, nat × elem → nat
nextlinfinite-appendvariable, nat × elem → list
nextnottidDMSQpredicate, Tid × Ref × heap
nextnottidRelyDMSQpredicate, Tid × Ref × heap × Ref × heap
nfinfinite-appendvariable, nat → elem
nfstreamvariable, nat → elem
nfstream-basicvariable, nat → elem
nfgeninfinite-appendvariable, nat → nat → elem
nodeDMSQvariable, Ref
nodeDMSQ-proofsvariable, Ref
noidDMSQpredicate, Tid × reflist × Ref × heap
noidRelyDMSQpredicate, Tid × reflist × heap × reflist × heap
nonullRetRefsDMSQpredicate, reflist × heap × Tid → rvRef × Tid → rvRef
noownsDMSQpredicate, Tid × Ref → OptTid
nullrvRefconstant, rvRef
nullRefconstant, Ref
nxtNodevariable, Ref
nxtDMSQvariable, Ref
nxtDMSQ-proofsvariable, Ref
n∞nat-infvariable, natinf
obsEmptyDQvariable, bool
obsEmptyDQ-proofsvariable, bool
obsEmptyDMSQ-refines-DQ-renvariable, bool
obsEmptyDMSQ-refines-DQvariable, bool
obsEmptyfDMSQ-refines-DQ-renvariable, Tid → bool
obsEmptyfDMSQ-refines-DQvariable, Tid → bool
oneownsDMSQpredicate, Tid × Ref × Ref → OptTid × heap × heap
oneweakownsDMSQpredicate, Tid × Ref × Ref → OptTid × heap × heap
opttidopttidvariable, OptTid
opttidNodevariable, OptTid
optvaloptelemvariable, OptElem
optvalDQvariable, OptElem
optvalDMSQvariable, OptElem
optvalDMSQ-proofsvariable, OptElem
optvalabsvariable, OptElem
optvalDQ-proofsvariable, OptElem
optvalDurQvariable, OptElem
optvalDurQ-proofsvariable, OptElem
optvalbwabsvariable, OptElem
optvalDurQ-renvariable, OptElem
optvalDQ-refines-DurQvariable, OptElem
optvalabsActionvariable, OptElem
optvalDQ-refines-DurQ-renvariable, OptElem
optvalDMSQ-refines-DQ-renvariable, OptElem
optvalDMSQ-refines-DQvariable, OptElem
optvalaabsvariable, OptElem
orlDMSQvariable, reflist
orlDMSQ-proofsvariable, reflist
orlDMSQ-refines-DQ-renvariable, reflist
orlDMSQ-refines-DQvariable, reflist
othertidDMSQvariable, Tid
othertidDMSQ-proofsvariable, Tid
ovalDQvariable, OptElem
ovalDQ-proofsvariable, OptElem
ovalDurQvariable, OptElem
ovalDurQ-proofsvariable, OptElem
ovalDurQ-renvariable, OptElem
owrvownervariable, rvOwner
ownsDMSQvariable, Ref → OptTid
ownsDMSQ-proofsvariable, Ref → OptTid
ownsDMSQ-refines-DQ-renvariable, Ref → OptTid
ownsDMSQ-refines-DQvariable, Ref → OptTid
ownsRelyDMSQpredicate, Tid × Ref → OptTid × Ref → OptTid
pairastatenatpair-astate-natsort,
pairastatenat-listKoenigs-Lemma-gen-bwactsort,
pairastatenat-setKoenigs-Lemma-gen-bwactsort,
pairastatenat-streamKoenigs-Lemma-gen-bwactsort,
pathinfgraph-genfunction, graph → elem × elem → bool
pathKoenigs-Lemma-gen-bwactfunction, graph → pairastatenat × pairastatenat → bool
pathpinfgraph-genfunction, graph → stream → bool
pathpKoenigs-Lemma-gen-bwactfunction, graph → pairastatenat-stream → bool
pcDQvariable, DQPC
pcDMSQvariable, DMSQPC
pcDMSQ-proofsvariable, DMSQPC
pcabsvariable, DMSQPC
pcDQ-proofsvariable, DQPC
pcDurQvariable, DurQPC
pcDurQ-proofsvariable, DurQPC
pcDurQ-renvariable, DurQPC
pcDQ-refines-DurQvariable, DQPC
pcDQ-refines-DurQ-renvariable, DQPC
pcDMSQ-refines-DQ-renvariable, DMSQPC
pcDMSQ-refines-DQvariable, DMSQPC
pcfDQvariable, Tid → DQPC
pcfDMSQvariable, Tid → DMSQPC
pcfDMSQ-proofsvariable, Tid → DMSQPC
pcfabsvariable, Tid → DMSQPC
pcfDQ-proofsvariable, Tid → DQPC
pcfDurQvariable, Tid → DurQPC
pcfDurQ-proofsvariable, Tid → DurQPC
pcfbwabsvariable, Tid → DQPC
pcfDurQ-renvariable, Tid → DurQPC
pcfDQ-refines-DurQvariable, Tid → DQPC
pcfDQ-refines-DurQ-renvariable, Tid → DQPC
pcfDMSQ-refines-DQ-renvariable, Tid → DMSQPC
pcfDMSQ-refines-DQvariable, Tid → DMSQPC
pcstepfDQfunction, DQGState × DQLState × DQPC × DQAction → DQPC
pcstepfDMSQfunction, DMSQGState × DMSQLState × DMSQPC × DMSQAction → DMSQPC
pcstepfDurQfunction, DurQGState × DurQLState × DurQPC × DurQAction → DurQPC
pheadDMSQvariable, Ref
pheadDMSQ-proofsvariable, Ref
pheadDMSQ-refines-DQ-renvariable, Ref
pheadDMSQ-refines-DQvariable, Ref
postraceCfunction, cstate × cstatelist → nat
postraceAfunction, astate × astatelist → nat
posIOstatestreamfunction, state × statelist → nat
posactionstreamfunction, action × actionlist → nat
poslist-delfunction, elem × list → nat
posKoenigs-Lemma-gen-bwactfunction, pairastatenat × pairastatenat-list → nat
posDurQtrace-absActionfunction, DurQState × astatelist → nat
posDurQtrace-absActionfunction, absAction × actionlist → nat
posDQctrace-absActionfunction, DQState × cstatelist → nat
posDQctrace-absActionfunction, absAction × actionlist → nat
posDMSQtrace-absActionfunction, DMSQState × cstatelist → nat
posDMSQtrace-absActionfunction, absAction × actionlist → nat
posDQ-refines-DurQ-renfunction, DQState × bstatelist → nat
posDMSQ-refines-DQ-renfunction, DQState × bstatelist → nat
posDMSQ-DQ-refine-instancefunction, DMSQState × cstatelist → nat
posDQatrace-absActionfunction, DQState × astatelist → nat
posDQatrace-absActionfunction, absAction × actionlist → nat
preDQpredicate, DQGState × DQLState × DQPC × DQAction
preDMSQpredicate, DMSQGState × DMSQLState × DMSQPC × DMSQAction
preDurQpredicate, DurQGState × DurQLState × DurQPC × DurQAction
pretRefsDMSQvariable, Tid → rvRef
pretRefsDMSQ-proofsvariable, Tid → rvRef
pretValsDMSQ-refines-DQ-renvariable, Tid → OptElem
pretValsDMSQ-refines-DQvariable, Tid → OptElem
prvHpDMSQvariable, rvHeap
prvHpDMSQ-proofsvariable, rvHeap
prvHpRelyDMSQpredicate, rvHeap × rvHeap × rvHeap
psDMSQvariable, heap
psDMSQ-proofsvariable, heap
psabsvariable, heap
psDMSQ-refines-DQ-renvariable, heap
psDMSQ-refines-DQvariable, heap
qabsvariable, list
qDMSQ-refines-DQ-renvariable, list
qDMSQ-refines-DQvariable, list
qrlDMSQvariable, reflist
qrlDMSQ-proofsvariable, reflist
qrlDMSQ-refines-DQ-renvariable, reflist
qrlDMSQ-refines-DQvariable, reflist
queueDQvariable, list
queueDQ-proofsvariable, list
queueDurQvariable, list
queueDurQ-proofsvariable, list
queueDurQ-renvariable, list
queueDMSQ-refines-DQ-renvariable, list
queueDMSQ-refines-DQvariable, list
rIOforwardvariable, astate × cstate → bool
rDMSQvariable, Ref
rDMSQ-proofsvariable, Ref
rabsvariable, Ref
rRefvariable, Ref
reachKoenigs-Lemma-genfunction, graph → set × nat → elem → bool
reachKoenigs-Lemma-gen-bwactfunction, graph → pairastatenat-set × nat → pairastatenat → bool
reach≤Koenigs-Lemma-genfunction, graph → set × nat → elem → bool
reach≤Koenigs-Lemma-gen-bwactfunction, graph → pairastatenat-set × nat → pairastatenat → bool
readyDQconstant, DQPC
readyDMSQconstant, DMSQPC
readyDurQconstant, DurQPC
reflistreflistsort,
renabsfunction, DMSQAction → DQAction
resDeqDQconstant, DQPC
resDeqDurQconstant, DurQPC
resEnqDQconstant, DQPC
resEnqDurQconstant, DurQPC
restntraceCpartial function, nat × cstatelist → cstatelist
restntraceApartial function, nat × astatelist → astatelist
restnIOstatestreampartial function, nat × statelist → statelist
restnactionstreampartial function, nat × actionlist → actionlist
restnlist-delpartial function, nat × list → list
restnKoenigs-Lemma-gen-bwactpartial function, nat × pairastatenat-list → pairastatenat-list
restnDurQtrace-absActionpartial function, nat × astatelist → astatelist
restnDQctrace-absActionpartial function, nat × cstatelist → cstatelist
restnDMSQtrace-absActionpartial function, nat × cstatelist → cstatelist
restnDQ-refines-DurQ-renpartial function, nat × bstatelist → bstatelist
restnDMSQ-refines-DQ-renpartial function, nat × bstatelist → bstatelist
restnDQatrace-absActionpartial function, nat × astatelist → astatelist
retDEQDMSQfunction, Tid × OptElem → DMSQAction
retDEQoptvalDMSQvariable, OptElem
retDEQoptvalDMSQ-proofsvariable, OptElem
retENQDMSQfunction, Tid → DMSQAction
revtraceCfunction, cstatelist → cstatelist
revtraceAfunction, astatelist → astatelist
revIOstatestreamfunction, statelist → statelist
revactionstreamfunction, actionlist → actionlist
revlist-lastfunction, list → list
revreflistfunction, reflist → reflist
revKoenigs-Lemma-gen-bwactfunction, pairastatenat-list → pairastatenat-list
revDurQtrace-absActionfunction, astatelist → astatelist
revDQctrace-absActionfunction, cstatelist → cstatelist
revDMSQtrace-absActionfunction, cstatelist → cstatelist
revDQ-refines-DurQ-renfunction, bstatelist → bstatelist
revDMSQ-refines-DQ-renfunction, bstatelist → bstatelist
revDQatrace-absActionfunction, astatelist → astatelist
rfKoenigs-Lemma-genvariable, set × nat → elem → bool
rlDMSQvariable, reflist
rlDMSQ-proofsvariable, reflist
rlabsvariable, reflist
rmduptraceCfunction, cstatelist → cstatelist
rmduptraceAfunction, astatelist → astatelist
rmdupIOstatestreamfunction, statelist → statelist
rmdupactionstreamfunction, actionlist → actionlist
rmduplist-dupfunction, list → list
rmdupreflistfunction, reflist → reflist
rmdupKoenigs-Lemma-gen-bwactfunction, pairastatenat-list → pairastatenat-list
rmdupDurQtrace-absActionfunction, astatelist → astatelist
rmdupDQctrace-absActionfunction, cstatelist → cstatelist
rmdupDMSQtrace-absActionfunction, cstatelist → cstatelist
rmdupDQ-refines-DurQ-renfunction, bstatelist → bstatelist
rmdupDMSQ-refines-DQ-renfunction, bstatelist → bstatelist
rmdupDQatrace-absActionfunction, astatelist → astatelist
rvHeapretval-heapsort,
rvOwnerrvownersort,
rvRefrvRefsort,
rvSetretval-heapsort,
rvownerokDMSQpredicate, Tid → rvRef × rvHeap × rvRef → rvOwner
rvownsDMSQvariable, rvRef → rvOwner
rvownsDMSQ-proofsvariable, rvRef → rvOwner
rvownsrelyDMSQpredicate, Tid × rvRef → rvOwner × rvRef → rvOwner × rvHeap
rvrefrvRefvariable, rvRef
rvrefDMSQvariable, rvRef
rvrefDMSQ-proofsvariable, rvRef
rvrefabsvariable, rvRef
rvrelyDMSQpredicate, Tid × rvRef → rvOwner × Tid → rvRef × rvHeap × Tid → rvRef × rvHeap
sIOstatevariable, state
sset-basicvariable, set
sDQvariable, DQState
sDMSQvariable, DMSQState
sDMSQ-proofsvariable, DMSQState
sDQ-proofsvariable, DQState
sDurQvariable, DurQState
sKoenigs-Lemma-genvariable, set
sDurQ-proofsvariable, DurQState
sDurQ-renvariable, DurQState
setset-basicsort,
sftraceCvariable, nat → cstate
sftraceAvariable, nat → astate
sfIOtracevariable, nat → state
sfrestrictedvariable, nat → state
sltraceCvariable, cstatelist
sltraceAvariable, astatelist
slIOtracevariable, statelist
slrestrictedvariable, statelist
some?opttidpredicate, OptTid
ststorevariable, store
ststore+setvariable, store
startIO-Aut-datavariable, state → bool
startfIO-Aut-datavariable, state → bool
stateIOstatesort,
statelistIOstatestreamsort,
statesetstatesetsort,
statestreamIOstatestreamsort,
stepIO-Aut-datavariable, state × action × state → bool
stepdetrestrictedpredicate, IOAutomaton
stepfIO-Aut-datavariable, state × action × state → bool
storestoresort,
strPinfgraph-genvariable, stream → bool
streamstream-basicsort,
sublisttraceCpartial function, nat × nat × cstatelist → cstatelist
sublisttraceApartial function, nat × nat × astatelist → astatelist
sublistIOstatestreampartial function, nat × nat × statelist → statelist
sublistactionstreampartial function, nat × nat × actionlist → actionlist
sublistlist-delpartial function, nat × nat × list → list
sublistKoenigs-Lemma-gen-bwactpartial function, nat × nat × pairastatenat-list → pairastatenat-list
sublistDurQtrace-absActionpartial function, nat × nat × astatelist → astatelist
sublistDQctrace-absActionpartial function, nat × nat × cstatelist → cstatelist
sublistDMSQtrace-absActionpartial function, nat × nat × cstatelist → cstatelist
sublistDQ-refines-DurQ-renpartial function, nat × nat × bstatelist → bstatelist
sublistDMSQ-refines-DQ-renpartial function, nat × nat × bstatelist → bstatelist
sublistDQatrace-absActionpartial function, nat × nat × astatelist → astatelist
successDMSQvariable, bool
successDMSQ-proofsvariable, bool
successabsvariable, bool
tIObackwardvariable, cstate × astate → bool
tIObackward-INVvariable, cstate × astate → bool
taillist-datavariable, list
tailDMSQ-refines-DQ-renvariable, Ref
tailDMSQ-refines-DQvariable, Ref
tidtidvariable, Tid
tidopttidvariable, Tid
tidrvownervariable, Tid
tidDQvariable, Tid
tidDMSQvariable, Tid
tidDMSQ-proofsvariable, Tid
tidabsvariable, Tid
tidDQ-proofsvariable, Tid
tidDurQvariable, Tid
tidDurQ-proofsvariable, Tid
tidbwabsvariable, Tid
tidDurQ-renvariable, Tid
tidDQ-refines-DurQvariable, Tid
tidabsActionvariable, Tid
tidDQ-refines-DurQ-renvariable, Tid
tidDMSQ-refines-DQ-renvariable, Tid
tidDMSQ-refines-DQvariable, Tid
tidaabsvariable, Tid
tidsDQ-refines-DurQvariable, tidset
tidsDQ-refines-DurQ-renvariable, tidset
tidsettidsetsort,
tltraceCpartial function, cstatestream → cstatestream
tltraceCpartial function, cstatelist → cstatelist
tltraceApartial function, astatestream → astatestream
tltraceApartial function, astatelist → astatelist
tlIOstatestreampartial function, statestream → statestream
tlIOstatestreampartial function, statelist → statelist
tlactionstreampartial function, actionstream → actionstream
tlactionstreampartial function, actionlist → actionlist
tlstreampartial function, stream → stream
tlKoenigs-Lemma-gen-bwactpartial function, pairastatenat-stream → pairastatenat-stream
tlDurQtrace-absActionpartial function, astatestream → astatestream
tlDurQtrace-absActionpartial function, astatelist → astatelist
tlDQctrace-absActionpartial function, cstatestream → cstatestream
tlDQctrace-absActionpartial function, cstatelist → cstatelist
tlDMSQtrace-absActionpartial function, cstatestream → cstatestream
tlDMSQtrace-absActionpartial function, cstatelist → cstatelist
tlDQ-refines-DurQ-renpartial function, bstatestream → bstatestream
tlDQ-refines-DurQ-renpartial function, bstatelist → bstatelist
tlDMSQ-refines-DQ-renpartial function, bstatestream → bstatestream
tlDMSQ-refines-DQ-renpartial function, bstatelist → bstatelist
tlDQatrace-absActionpartial function, astatestream → astatestream
tlDQatrace-absActionpartial function, astatelist → astatelist
totraceCpartial function, cstatelist × nat → cstatelist
totraceCpartial function, cstatestream × nat → cstatestream
totraceCfunction, nat → cstate × nat → cstatelist
totraceApartial function, astatelist × nat → astatelist
totraceApartial function, astatestream × nat → astatestream
totraceAfunction, nat → astate × nat → astatelist
toIOstatestreampartial function, statelist × nat → statelist
toIOstatestreampartial function, statestream × nat → statestream
toIOstatestreamfunction, nat → state × nat → statelist
toactionstreampartial function, actionlist × nat → actionlist
toactionstreampartial function, actionstream × nat → actionstream
toactionstreamfunction, nat → action × nat → actionlist
tostreampartial function, list × nat → list
tostreampartial function, stream × nat → stream
tostreamfunction, nat → elem × nat → list
toKoenigs-Lemma-gen-bwactpartial function, pairastatenat-list × nat → pairastatenat-list
toKoenigs-Lemma-gen-bwactpartial function, pairastatenat-stream × nat → pairastatenat-stream
toKoenigs-Lemma-gen-bwactfunction, nat → pairastatenat × nat → pairastatenat-list
toDurQtrace-absActionpartial function, astatelist × nat → astatelist
toDurQtrace-absActionpartial function, astatestream × nat → astatestream
toDurQtrace-absActionfunction, nat → DurQState × nat → astatelist
toDurQtrace-absActionfunction, nat → absAction × nat → actionlist
toDQctrace-absActionpartial function, cstatelist × nat → cstatelist
toDQctrace-absActionpartial function, cstatestream × nat → cstatestream
toDQctrace-absActionfunction, nat → DQState × nat → cstatelist
toDQctrace-absActionfunction, nat → absAction × nat → actionlist
toDMSQtrace-absActionpartial function, cstatelist × nat → cstatelist
toDMSQtrace-absActionpartial function, cstatestream × nat → cstatestream
toDMSQtrace-absActionfunction, nat → DMSQState × nat → cstatelist
toDMSQtrace-absActionfunction, nat → absAction × nat → actionlist
toDQ-refines-DurQ-renpartial function, bstatelist × nat → bstatelist
toDQ-refines-DurQ-renpartial function, bstatestream × nat → bstatestream
toDQ-refines-DurQ-renfunction, nat → DQState × nat → bstatelist
toDMSQ-refines-DQ-renpartial function, bstatelist × nat → bstatelist
toDMSQ-refines-DQ-renpartial function, bstatestream × nat → bstatestream
toDMSQ-refines-DQ-renfunction, nat → DQState × nat → bstatelist
toDMSQ-DQ-refine-instancefunction, nat → DMSQState × nat → cstatelist
toDQatrace-absActionpartial function, astatelist × nat → astatelist
toDQatrace-absActionpartial function, astatestream × nat → astatestream
toDQatrace-absActionfunction, nat → DQState × nat → astatelist
toDQatrace-absActionfunction, nat → absAction × nat → actionlist
to∞traceCpartial function, cstatestream × natinf → cstatestream
to∞traceApartial function, astatestream × natinf → astatestream
to∞IOstatestreampartial function, statestream × natinf → statestream
to∞actionstreampartial function, actionstream × natinf → actionstream
to∞streampartial function, stream × natinf → stream
to∞Koenigs-Lemma-gen-bwactpartial function, pairastatenat-stream × natinf → pairastatenat-stream
to∞DurQtrace-absActionpartial function, astatestream × natinf → astatestream
to∞DQctrace-absActionpartial function, cstatestream × natinf → cstatestream
to∞DMSQtrace-absActionpartial function, cstatestream × natinf → cstatestream
to∞DQ-refines-DurQ-renpartial function, bstatestream × natinf → bstatestream
to∞DMSQ-refines-DQ-renpartial function, bstatestream × natinf → bstatestream
to∞DQatrace-absActionpartial function, astatestream × natinf → astatestream
traceIOtracefunction, IOAutomaton → actionstream → bool
trace*IOtracefunction, IOAutomaton → actionstream → bool
tracevtraceCvariable, actionstream → bool
tracevtraceAvariable, actionstream → bool
tracevIOtracevariable, actionstream → bool
traceωIOtracefunction, IOAutomaton → actionstream → bool
unmarkedpDMSQpredicate, reflist × heap
valNodevariable, elem
valoptelemvariable, elem
valrvownervariable, elem
valDQvariable, elem
valabsvariable, elem
valDQ-proofsvariable, elem
valDurQvariable, elem
valDurQ-proofsvariable, elem
valbwabsvariable, elem
valDurQ-renvariable, elem
valDQ-refines-DurQvariable, elem
valabsActionvariable, elem
valDQ-refines-DurQ-renvariable, elem
valDMSQ-refines-DQ-renvariable, elem
valDMSQ-refines-DQvariable, elem
valaabsvariable, elem
valueDQvariable, elem
valueDMSQvariable, elem
valueDMSQ-proofsvariable, elem
valueDQ-proofsvariable, elem
valueDurQvariable, elem
valueDurQ-proofsvariable, elem
valueDurQ-renvariable, elem
vheadDMSQvariable, Ref
vheadDMSQ-proofsvariable, Ref
vheadDMSQ-refines-DQ-renvariable, Ref
vheadDMSQ-refines-DQvariable, Ref
vretRefsDMSQvariable, Tid → rvRef
vretRefsDMSQ-proofsvariable, Tid → rvRef
vretValsDMSQ-refines-DQ-renvariable, Tid → OptElem
vretValsDMSQ-refines-DQvariable, Tid → OptElem
vrvHpDMSQvariable, rvHeap
vrvHpDMSQ-proofsvariable, rvHeap
vsDMSQvariable, heap
vsDMSQ-proofsvariable, heap
vsabsvariable, heap
vsinfgraph-gen-basicvariable, elem → bool
vsDMSQ-refines-DQ-renvariable, heap
vsDMSQ-refines-DQvariable, heap
vtailDMSQvariable, Ref
vtailDMSQ-proofsvariable, Ref
weak?opttidpredicate, OptTid
weakbwsimIObackward-INVpredicate, CIOAutomaton × AIOAutomaton × cstate × astate → bool × astate → bool
weakbwsimDQ-refines-DurQ-instancepredicate, CIOAutomaton × AIOAutomaton × DQState × DurQState → bool × DurQState → bool
weakbwsimDQ-refines-DurQ-renpredicate, BIOAutomaton × AIOAutomaton × DQState × DurQState → bool × DurQState → bool
xstreamvariable, list
xstream-basicvariable, list
xlist-delvariable, list
xlist-lastvariable, list
xlist-dupvariable, list
xlist-datavariable, list
xlistvariable, list
xlist-getputvariable, list
xKoenigs-Lemma-genvariable, list
ystreamvariable, list
ylist-delvariable, list
ylist-lastvariable, list
ylist-dupvariable, list
ylist-datavariable, list
ylistvariable, list
ylist-getputvariable, list
zstreamvariable, list
zlist-delvariable, list
zlist-lastvariable, list
zlist-dupvariable, list
zlist-datavariable, list
zlistvariable, list
zlist-getputvariable, list
|retval-heapfunction, rvHeap × rvSet → rvHeap
|store+setfunction, store × set → store
}retval-heapfunction, rvRef → rvSet
}set-unionfunction, elem → set
}statesetfunction, state → stateset
}astatesetfunction, astate → astateset
}Koenigs-Lemma-gen-bwactfunction, pairastatenat → pairastatenat-set
}DQ-refines-DurQ-instancefunction, DurQState → astateset
}tidsetfunction, Tid → tidset
×infgraph-gen-basicfunction, elem → bool × elem × elem → bool → graph
×pair-astate-natfunction, astate × nat → pairastatenat
×Koenigs-Lemma-gen-bwactfunction, pairastatenat → bool × pairastatenat × pairastatenat → bool → graph
×DQ-refines-DurQ-instancefunction, DurQState × nat → pairastatenat
αIOforward-is-leqrefinevariable, actionstream
αIOrefine-defvariable, actionstream
αtraceCvariable, actionstream
αtraceAvariable, actionstream
αIOtracevariable, actionstream
αIObackwardvariable, actionstream
αimfinIObackwardvariable, actionstream
αrestrictedvariable, actionstream
αIObackward-INVvariable, actionstream
αimfinIObackward-INVvariable, actionstream
αIObackward-INV-is-leqstarrefinevariable, actionstream
αimfinIObackward-is-refinevariable, actionstream
βremtauvariable, actionstream
σtraceCvariable, cstatestream
σtraceAvariable, astatestream
σIOtracevariable, statestream
σinfinite-appendvariable, stream
σstreamvariable, stream
σstream-basicvariable, stream
σrestrictedvariable, statestream
τactionconstant, action
τDQconstant, DQAction
τDMSQconstant, DMSQAction
τDurQconstant, DurQAction
τabsActionconstant, absAction
∅Node-heapconstant, heap
∅storeconstant, store
∅retval-heapconstant, rvSet
∅retval-heapconstant, rvHeap
∅set-basicconstant, set
∅statesetconstant, stateset
∅astatesetconstant, astateset
∅Koenigs-Lemma-gen-bwactconstant, pairastatenat-set
∅tidsetconstant, tidset
∈traceCpredicate, cstate × cstatelist
∈traceApredicate, astate × astatelist
∈IOstatestreampredicate, state × statelist
∈actionstreampredicate, action × actionlist
∈listpredicate, elem × list
∈reflistpredicate, Ref × reflist
∈Node-heappredicate, Ref × heap
∈storepredicate, elem × store
∈retval-heappredicate, OptElem × rvHeap
∈retval-heappredicate, rvRef × rvSet
∈retval-heappredicate, rvRef × rvHeap
∈set-basicpredicate, elem × set
∈store+setpredicate, data × store
∈statesetpredicate, state × stateset
∈astatesetpredicate, astate × astateset
∈Koenigs-Lemma-gen-bwactpredicate, pairastatenat × pairastatenat-set
∈Koenigs-Lemma-gen-bwactpredicate, pairastatenat × pairastatenat-list
∈DQ-refines-DurQ-instancepredicate, DurQState × astateset
∈DurQtrace-absActionpredicate, DurQState × astatelist
∈DurQtrace-absActionpredicate, absAction × actionlist
∈DQctrace-absActionpredicate, DQState × cstatelist
∈DQctrace-absActionpredicate, absAction × actionlist
∈tidsetpredicate, Tid × tidset
∈DMSQtrace-absActionpredicate, DMSQState × cstatelist
∈DMSQtrace-absActionpredicate, absAction × actionlist
∈DQ-refines-DurQ-renpredicate, DQState × bstatelist
∈DMSQ-refines-DQ-renpredicate, DQState × bstatelist
∈DMSQ-DQ-refine-instancepredicate, DMSQState × cstatelist
∈DQatrace-absActionpredicate, DQState × astatelist
∈DQatrace-absActionpredicate, absAction × actionlist
∞nat-infconstant, natinf
∩retval-heapfunction, rvSet × rvSet → rvSet
∩set-unionfunction, set × set → set
∩statesetfunction, stateset × stateset → stateset
∩astatesetfunction, astateset × astateset → astateset
∩Koenigs-Lemma-gen-bwactfunction, pairastatenat-set × pairastatenat-set → pairastatenat-set
∩tidsetfunction, tidset × tidset → tidset
∪retval-heapfunction, rvSet × rvSet → rvSet
∪set-unionfunction, set × set → set
∪statesetfunction, stateset × stateset → stateset
∪astatesetfunction, astateset × astateset → astateset
∪Koenigs-Lemma-gen-bwactfunction, pairastatenat-set × pairastatenat-set → pairastatenat-set
∪tidsetfunction, tidset × tidset → tidset
≤traceCpredicate, cstatestream × cstatestream
≤traceApredicate, astatestream × astatestream
≤IOstatestreampredicate, statestream × statestream
≤actionstreampredicate, actionstream × actionstream
≤streampredicate, stream × stream
≤natpredicate, nat × nat
≤Koenigs-Lemma-gen-bwactpredicate, pairastatenat-stream × pairastatenat-stream
≤DurQtrace-absActionpredicate, astatestream × astatestream
≤DQctrace-absActionpredicate, cstatestream × cstatestream
≤DMSQtrace-absActionpredicate, cstatestream × cstatestream
≤DQ-refines-DurQ-renpredicate, bstatestream × bstatestream
≤DMSQ-refines-DQ-renpredicate, bstatestream × bstatestream
≤DQatrace-absActionpredicate, astatestream × astatestream
≤BIObackwardpredicate, CIOAutomaton × AIOAutomaton
≤BIObackward-INVpredicate, CIOAutomaton × AIOAutomaton
≤BDQ-refines-DurQ-renpredicate, BIOAutomaton × AIOAutomaton
≤BIIObackward-INVpredicate, CIOAutomaton × AIOAutomaton
≤BIDQ-refines-DurQ-renpredicate, BIOAutomaton × AIOAutomaton
≤FIOforwardpredicate, CIOAutomaton × AIOAutomaton
≤FDMSQ-refines-DQ-renpredicate, CIOAutomaton × BIOAutomaton
≤iBimfinIObackwardpredicate, CIOAutomaton × AIOAutomaton
≤iBDQ-refines-DurQ-renpredicate, BIOAutomaton × AIOAutomaton
≤iBIimfinIObackward-INVpredicate, CIOAutomaton × AIOAutomaton
≤iBIDQ-refines-DurQ-renpredicate, BIOAutomaton × AIOAutomaton
≤wBIObackward-INVpredicate, CIOAutomaton × AIOAutomaton
≤wBDQ-refines-DurQ-renpredicate, BIOAutomaton × AIOAutomaton
≥natpredicate, nat × nat
⊆Node-heappredicate, heap × heap
⊆storepredicate, store × store
⊆retval-heappredicate, rvSet × rvSet
⊆retval-heappredicate, rvHeap × rvHeap
⊆set-basicpredicate, set × set
⊆statesetpredicate, stateset × stateset
⊆astatesetpredicate, astateset × astateset
⊆Koenigs-Lemma-gen-bwactpredicate, pairastatenat-set × pairastatenat-set
⊆tidsetpredicate, tidset × tidset
⊑traceCpredicate, cstatelist × cstatelist
⊑traceApredicate, astatelist × astatelist
⊑IOstatestreampredicate, statelist × statelist
⊑actionstreampredicate, actionlist × actionlist
⊑list-lastpredicate, list × list
⊑reflistpredicate, reflist × reflist
⊑Koenigs-Lemma-gen-bwactpredicate, pairastatenat-list × pairastatenat-list
⊑DurQtrace-absActionpredicate, astatelist × astatelist
⊑DQctrace-absActionpredicate, cstatelist × cstatelist
⊑DMSQtrace-absActionpredicate, cstatelist × cstatelist
⊑DQ-refines-DurQ-renpredicate, bstatelist × bstatelist
⊑DMSQ-refines-DQ-renpredicate, bstatelist × bstatelist
⊑DQatrace-absActionpredicate, astatelist × astatelist
⊒traceCpredicate, cstatelist × cstatelist
⊒traceApredicate, astatelist × astatelist
⊒IOstatestreampredicate, statelist × statelist
⊒actionstreampredicate, actionlist × actionlist
⊒list-lastpredicate, list × list
⊒reflistpredicate, reflist × reflist
⊒Koenigs-Lemma-gen-bwactpredicate, pairastatenat-list × pairastatenat-list
⊒DurQtrace-absActionpredicate, astatelist × astatelist
⊒DQctrace-absActionpredicate, cstatelist × cstatelist
⊒DMSQtrace-absActionpredicate, cstatelist × cstatelist
⊒DQ-refines-DurQ-renpredicate, bstatelist × bstatelist
⊒DMSQ-refines-DQ-renpredicate, bstatelist × bstatelist
⊒DQatrace-absActionpredicate, astatelist × astatelist
⊕retval-heapfunction, rvHeap × rvHeap → rvHeap
⊕store+setfunction, store × store → store
⊕DMSQfunction, heap × heap → heap
⌝traceCfunction, nat → cstate → cstatestream
⌝traceCfunction, cstatelist → cstatestream
⌝traceAfunction, nat → astate → astatestream
⌝traceAfunction, astatelist → astatestream
⌝IOstatestreamfunction, nat → state → statestream
⌝IOstatestreamfunction, statelist → statestream
⌝actionstreamfunction, nat → action → actionstream
⌝actionstreamfunction, actionlist → actionstream
⌝nat-inffunction, nat → natinf
⌝stream-basicfunction, nat → elem → stream
⌝stream-basicfunction, list → stream
⌝Koenigs-Lemma-gen-bwactfunction, nat → pairastatenat → pairastatenat-stream
⌝Koenigs-Lemma-gen-bwactfunction, pairastatenat-list → pairastatenat-stream
⌝DurQtrace-absActionfunction, nat → DurQState → astatestream
⌝DurQtrace-absActionfunction, astatelist → astatestream
⌝DurQtrace-absActionfunction, nat → absAction → actionstream
⌝DQctrace-absActionfunction, nat → DQState → cstatestream
⌝DQctrace-absActionfunction, cstatelist → cstatestream
⌝DQctrace-absActionfunction, nat → absAction → actionstream
⌝DMSQtrace-absActionfunction, nat → DMSQState → cstatestream
⌝DMSQtrace-absActionfunction, cstatelist → cstatestream
⌝DMSQtrace-absActionfunction, nat → absAction → actionstream
⌝DQ-refines-DurQ-renfunction, nat → DQState → bstatestream
⌝DQ-refines-DurQ-renfunction, bstatelist → bstatestream
⌝DMSQ-refines-DQ-renfunction, nat → DQState → bstatestream
⌝DMSQ-refines-DQ-renfunction, bstatelist → bstatestream
⌝DMSQ-DQ-refine-instancefunction, nat → DMSQState → cstatestream
⌝DQatrace-absActionfunction, nat → DQState → astatestream
⌝DQatrace-absActionfunction, astatelist → astatestream
⌝DQatrace-absActionfunction, nat → absAction → actionstream