Uses of Interface
edu.toronto.cs.mvset.MvSet

Packages that use MvSet
edu.toronto.cs.ctl CTL Abstract Syntax Tree 
edu.toronto.cs.gclang.parser ANTLR parser for GCLang 
edu.toronto.cs.modelchecker Basic CTL model-checking engine based on MvSet 
edu.toronto.cs.mvset Provides several symbolic implementations of multi-valued sets 
edu.toronto.cs.proof Provides classes for representing, manipulating, and constructing proofs for CTL formulas (OLD) 
edu.toronto.cs.proof2 Provides classes for representing, manipulating, and constructing proofs for CTL formulas (NEW) 
edu.toronto.cs.simulator A model simulator for XChek (Victor). 
edu.toronto.cs.smv Provides classes to represent SMV models 
edu.toronto.cs.smv.parser ANTLR parsers for SMV models 
edu.toronto.cs.tlq Classes used by TLQSolver extension of XChek 
edu.toronto.cs.xkripke Classes to represent, manipulate, and parse XML representation of XKripke structures. 
 

Uses of MvSet in edu.toronto.cs.ctl
 

Methods in edu.toronto.cs.ctl that return MvSet
 MvSet CTLMvSetNode.getMvSet()
           
 MvSet CTLAtomPropNode.getMvSet()
           
 MvSet[] CTLPlaceholderNode.getTerm(int i)
           
 MvSet[][] CTLPlaceholderNode.getTerms()
           
 

Methods in edu.toronto.cs.ctl with parameters of type MvSet
static CTLMvSetNode CTLFactory.createCTLMvSetNode(MvSet mvset)
           
static CTLTransitionNode CTLFactory.createCTLTransitionNode(MvSet mvset)
           
 void CTLAtomPropNode.setMvSet(MvSet v)
           
 void CTLPlaceholderNode.setTerms(MvSet[][] v)
           
 

Constructors in edu.toronto.cs.ctl with parameters of type MvSet
CTLAtomPropNode(java.lang.String _name, MvSet value)
           
CTLMvSetNode(MvSet set)
          Construct a CTL node associated with a particular MvSet.
CTLTransitionNode(MvSet set)
           
 

Uses of MvSet in edu.toronto.cs.gclang.parser
 

Methods in edu.toronto.cs.gclang.parser that return MvSet
 MvSet GCLangBuilder.assign(antlr.collections.AST _t)
           
 MvSet GCLangBuilder.atomicCommand(antlr.collections.AST _t)
           
 MvSet GCLangBuilder.command(antlr.collections.AST _t)
           
abstract  MvSet VariableTable.Variable.eq(MvSet v)
           
 MvSet VariableTable.EnumeratedVariable.eq(MvSet v)
           
 MvSet VariableTable.StateVariable.eq(MvSet v)
           
abstract  MvSet VariableTable.Variable.eq(java.lang.String v)
           
 MvSet VariableTable.EnumeratedVariable.eq(java.lang.String v)
           
 MvSet VariableTable.StateVariable.eq(java.lang.String v)
           
 MvSet VariableTable.EnumeratedVariable.eq(VariableTable.EnumeratedVariable v)
           
 MvSet VariableTable.StateVariable.eq(VariableTable.StateVariable v)
           
abstract  MvSet VariableTable.Variable.eq(VariableTable.Variable v)
           
 MvSet VariableTable.EnumeratedVariable.eq(VariableTable.Variable v)
           
 MvSet VariableTable.StateVariable.eq(VariableTable.Variable v)
           
abstract  MvSet VariableTable.Variable.eqShadow(int i)
           
 MvSet VariableTable.EnumeratedVariable.eqShadow(int idx)
           
 MvSet VariableTable.StateVariable.eqShadow(int idx)
           
 MvSet GCLangBuilder.expression(antlr.collections.AST _t)
           
 MvSet GCLangCompiler.getInit()
           
 MvSet VariableTable.StateVariable.getMvSet()
           
protected  MvSet GCLangBuilder.guard(antlr.collections.AST _t)
           
 MvSet GCLangBuilder.guardedCommand(antlr.collections.AST _t)
           
 MvSet GCLangBuilder.ite(antlr.collections.AST _t)
           
 MvSet GCLangBuilder.skip(antlr.collections.AST _t)
           
 

Methods in edu.toronto.cs.gclang.parser with parameters of type MvSet
 VariableTable.DefineVariable VariableTable.declareDefine(java.lang.String name, MvSet value)
          Describe declareDefine method here.
abstract  MvSet VariableTable.Variable.eq(MvSet v)
           
 MvSet VariableTable.EnumeratedVariable.eq(MvSet v)
           
 MvSet VariableTable.StateVariable.eq(MvSet v)
           
protected  void VariableTable.StateVariable.setMvSet(MvSet v)
           
 

Constructors in edu.toronto.cs.gclang.parser with parameters of type MvSet
VariableTable.DefineVariable(java.lang.String name, MvSet value)
           
 

Uses of MvSet in edu.toronto.cs.modelchecker
 

Methods in edu.toronto.cs.modelchecker that return MvSet
 MvSet MvSetModelChecker.__checkCTL(CTLNode ctl, MvSet init)
           
 MvSet MvSetModelChecker.checkCTL(CTLNode v)
           
 MvSet MvSetModelChecker.checkCTL(CTLNode ctl, MvSet state)
           
 MvSet XKripkeStructure.getInit()
           
 MvSet XKripkeStructure.getPrimeCube()
           
 MvSet XKripkeStructure.getUnPrimeCube()
           
 MvSet MvSetModelChecker.getUnPrimeCube()
           
 

Methods in edu.toronto.cs.modelchecker with parameters of type MvSet
 MvSet MvSetModelChecker.__checkCTL(CTLNode ctl, MvSet init)
           
 MvSet MvSetModelChecker.checkCTL(CTLNode ctl, MvSet state)
           
 CTLNode[] StatePresenter.toCTL(MvSet cube)
           
 

Constructors in edu.toronto.cs.modelchecker with parameters of type MvSet
CTLUntilExpander(MvSet _top)
           
XKripkeStructure(MvRelation _trans, MvSet _init, int[] _prime, MvSet _primeCube, MvSet _unPrimeCube, java.lang.String[] _varNames, IAlgebra _algebra, int _numDDVars, int _numVars, CTLReWriter _rewriter, StatePresenter _statePresenter)
           
XKripkeStructure(MvRelation _trans, MvSet _init, int[] _prime, MvSet _primeCube, MvSet _unPrimeCube, java.lang.String[] _varNames, IAlgebra _algebra, int _numDDVars, int _numVars, CTLReWriter _rewriter, StatePresenter _statePresenter, java.lang.String _name)
           
 

Uses of MvSet in edu.toronto.cs.mvset
 

Classes in edu.toronto.cs.mvset that implement MvSet
 class AbstractMvSet
           
 class CUADDMvSetFactory.CUADDMvSet
           
 class JADDMvSetFactory.JADDMvSet
           
 class JCUDDBelnapMvSetFactory.JCUDDBelnapMvSet
           
 class JCUDDMvSetFactory.JCUDDMvSet
           
 class MDDMvSetFactory.MDDMvSet
           
 

Methods in edu.toronto.cs.mvset that return MvSet
 MvSet AbstractMvSet.and(MvSet v)
          Utility functions
 MvSet MvSet.and(MvSet v)
          Utility functions
 MvSet JCUDDMvSetFactory.bot()
           
 MvSet MvSetFactory.bot()
           
 MvSet JCUDDBelnapMvSetFactory.bot()
           
 MvSet MDDMvSetFactory.bot()
           
 MvSet JADDMvSetFactory.bot()
           
 MvSet CUADDMvSetFactory.bot()
           
 MvSet JCUDDMvSetFactory.buildCube(int[] varIndex)
           
 MvSet MvSetFactory.buildCube(int[] varIndex)
          builds a cube out of variables
 MvSet JCUDDBelnapMvSetFactory.buildCube(int[] varIndex)
           
 MvSet MDDMvSetFactory.buildCube(int[] varIndex)
           
 MvSet JADDMvSetFactory.buildCube(int[] varIndex)
           
 MvSet CUADDMvSetFactory.buildCube(int[] varIndex)
           
 MvSet MvRelation.bwdImage(MvSet v)
          Computes the backward image (a.k.a, pre, EX) of v.
 MvSet SeqMvRelation.bwdImage(MvSet v)
           
 MvSet MvSetMvRelation.bwdImage(MvSet v)
           
 MvSet JCUDDMvSetFactory.JCUDDMvSet.cofactor(AlgebraValue[] r)
           
 MvSet JCUDDBelnapMvSetFactory.JCUDDBelnapMvSet.cofactor(AlgebraValue[] r)
           
 MvSet MDDMvSetFactory.MDDMvSet.cofactor(AlgebraValue[] r)
           
 MvSet JADDMvSetFactory.JADDMvSet.cofactor(AlgebraValue[] r)
           
 MvSet MvSet.cofactor(AlgebraValue[] r)
          Restricts the MvSet to a particular L^n (or set of permutations on L^n if r is not total)
 MvSet CUADDMvSetFactory.CUADDMvSet.cofactor(AlgebraValue[] r)
           
 MvSet JCUDDMvSetFactory.JCUDDMvSet.cofactor(int argIdx, AlgebraValue value)
          Restricts an argument h (x_0, x_1, x_2, ...) = f (x_0, ..., value, ...) where value is substituted at argIdx
 MvSet JCUDDBelnapMvSetFactory.JCUDDBelnapMvSet.cofactor(int argIdx, AlgebraValue value)
          Restricts an argument h (x_0, x_1, x_2, ...) = f (x_0, ..., value, ...) where value is substituted at argIdx
 MvSet MDDMvSetFactory.MDDMvSet.cofactor(int argIdx, AlgebraValue value)
          Restricts an argument h (x_0, x_1, x_2, ...) = f (x_0, ..., value, ...) where value is substituted at argIdx
 MvSet JADDMvSetFactory.JADDMvSet.cofactor(int argIdx, AlgebraValue value)
          Restricts an argument h (x_0, x_1, x_2, ...) = f (x_0, ..., value, ...) where value is substituted at argIdx
 MvSet MvSet.cofactor(int argIdx, AlgebraValue value)
          Restricts an argument h (x_0, x_1, x_2, ...) = f (x_0, ..., value, ...) where value is substituted at argIdx
 MvSet CUADDMvSetFactory.CUADDMvSet.cofactor(int argIdx, AlgebraValue value)
          Restricts an argument h (x_0, x_1, x_2, ...) = f (x_0, ..., value, ...) where value is substituted at argIdx
 MvSet JCUDDMvSetFactory.JCUDDMvSet.cofactor(MvSet cube)
           
 MvSet JCUDDBelnapMvSetFactory.JCUDDBelnapMvSet.cofactor(MvSet cube)
           
 MvSet MDDMvSetFactory.MDDMvSet.cofactor(MvSet point)
           
 MvSet AbstractMvSet.cofactor(MvSet point)
           
 MvSet MvSet.cofactor(MvSet point)
           
 MvSet JCUDDMvSetFactory.createCase(int argIdx, MvSet[] children)
           
 MvSet MvSetFactory.createCase(int argIdx, MvSet[] children)
          createCase creates a case relative to argIdx this is somewhat simillar to Ite (if-then-else) in CUDD but extended to more than two children.
 MvSet JCUDDBelnapMvSetFactory.createCase(int argIdx, MvSet[] children)
           
 MvSet MDDMvSetFactory.createCase(int argIdx, MvSet[] children)
           
 MvSet JADDMvSetFactory.createCase(int argIdx, MvSet[] children)
           
 MvSet CUADDMvSetFactory.createCase(int argIdx, MvSet[] children)
           
 MvSet JCUDDMvSetFactory.createConstant(AlgebraValue v)
          Given a value in L creates a function f(x_0, x_1, ...) = value
 MvSet MvSetFactory.createConstant(AlgebraValue value)
          Given a value in L creates a function f(x_0, x_1, ...) = value
 MvSet JCUDDBelnapMvSetFactory.createConstant(AlgebraValue v)
          Given a value in L creates a function f(x_0, x_1, ...) = value
 MvSet MDDMvSetFactory.createConstant(AlgebraValue v)
          Given a value in L creates a function f(x_0, x_1, ...) = value
 MvSet JADDMvSetFactory.createConstant(AlgebraValue v)
          Given a value in L creates a function f(x_0, x_1, ...) = value
 MvSet CUADDMvSetFactory.createConstant(AlgebraValue v)
          Given a value in L creates a function f(x_0, x_1, ...) = value
 MvSet JCUDDMvSetFactory.createIte(int argIdx, MvSet child0, MvSet child1)
           
 MvSet JCUDDBelnapMvSetFactory.createIte(int argIdx, MvSet child0, MvSet child1)
           
 MvSet CUADDMvSetFactory.createIte(int argIdx, MvSet child0, MvSet child1)
           
 MvSet CUADDMvSetFactory.createMvSet(CuddAdd.ADD addNode)
           
 MvSet JCUDDMvSetFactory.createMvSet(int cPtr)
           
 MvSet JCUDDBelnapMvSetFactory.createMvSet(int cPtr)
           
 MvSet MDDMvSetFactory.createMvSet(MDDNode mddNode)
           
 MvSet JADDMvSetFactory.createMvSet(MDDNode mddNode)
           
 MvSet JCUDDMvSetFactory.createPoint(AlgebraValue[] args, AlgebraValue value)
          Creates a point function f (args) = value = 0 otherwise
 MvSet MvSetFactory.createPoint(AlgebraValue[] args, AlgebraValue value)
          Creates a point function f (args) = value = 0 otherwise
 MvSet JCUDDBelnapMvSetFactory.createPoint(AlgebraValue[] args, AlgebraValue value)
          Creates a point function f (args) = value = 0 otherwise
 MvSet MDDMvSetFactory.createPoint(AlgebraValue[] args, AlgebraValue value)
          Creates a point function f (args) = value = 0 otherwise
 MvSet JADDMvSetFactory.createPoint(AlgebraValue[] args, AlgebraValue value)
          Creates a point function f (args) = value = 0 otherwise
 MvSet CUADDMvSetFactory.createPoint(AlgebraValue[] args, AlgebraValue value)
          Creates a point function f (args) = value = 0 otherwise
 MvSet JCUDDMvSetFactory.createProjection(int argIdx)
          Given an argument index (0 <= argIdx < n) constructs a projection function f(x_0, x_1, ...) = x_argIdx
 MvSet MvSetFactory.createProjection(int argIdx)
          Given an argument index (0 <= argIdx < n) constructs a projection function f(x_0, x_1, ...) = x_argIdx
 MvSet JCUDDBelnapMvSetFactory.createProjection(int argIdx)
          Given an argument index (0 <= argIdx < n) constructs a projection function f(x_0, x_1, ...) = x_argIdx
 MvSet MDDMvSetFactory.createProjection(int argIdx)
          Given an argument index (0 <= argIdx < n) constructs a projection function f(x_0, x_1, ...) = x_argIdx
 MvSet JADDMvSetFactory.createProjection(int argIdx)
          Given an argument index (0 <= argIdx < n) constructs a projection function f(x_0, x_1, ...) = x_argIdx
 MvSet CUADDMvSetFactory.createProjection(int argIdx)
          Given an argument index (0 <= argIdx < n) constructs a projection function f(x_0, x_1, ...) = x_argIdx
 MvSet MvRelation.dualBwdImage(MvSet v)
          Computes the logical dual of backward image (a.k.a.
 MvSet SeqMvRelation.dualBwdImage(MvSet v)
           
 MvSet MvSetMvRelation.dualBwdImage(MvSet v)
           
 MvSet AbstractMvSet.eq(MvSet v)
           
 MvSet MvSet.eq(MvSet v)
           
 MvSet JCUDDMvSetFactory.JCUDDMvSet.existAbstract(MvSet _cube)
           
 MvSet JCUDDBelnapMvSetFactory.JCUDDBelnapMvSet.existAbstract(MvSet _cube)
           
 MvSet MDDMvSetFactory.MDDMvSet.existAbstract(MvSet _cube)
           
 MvSet JADDMvSetFactory.JADDMvSet.existAbstract(MvSet _cube)
           
 MvSet MvSet.existAbstract(MvSet cube)
           
 MvSet CUADDMvSetFactory.CUADDMvSet.existAbstract(MvSet _cube)
           
 MvSet JCUDDMvSetFactory.JCUDDMvSet.forallAbstract(MvSet _cube)
           
 MvSet JCUDDBelnapMvSetFactory.JCUDDBelnapMvSet.forallAbstract(MvSet _cube)
           
 MvSet MDDMvSetFactory.MDDMvSet.forallAbstract(MvSet _cube)
           
 MvSet JADDMvSetFactory.JADDMvSet.forallAbstract(MvSet _cube)
           
 MvSet MvSet.forallAbstract(MvSet cube)
           
 MvSet CUADDMvSetFactory.CUADDMvSet.forallAbstract(MvSet _cube)
           
 MvSet MvRelation.fwdImage(MvSet v)
          Computes forward image (post) of v
 MvSet SeqMvRelation.fwdImage(MvSet v)
           
 MvSet MvSetMvRelation.fwdImage(MvSet v)
           
 MvSet AbstractMvSet.geq(MvSet v)
           
 MvSet MvSet.geq(MvSet v)
           
 MvSet MvRelation.getPostVariablesCube()
          get cube of post-state variables
 MvSet SeqMvRelation.getPostVariablesCube()
          get cube of post-state variables
 MvSet MvSetMvRelation.getPostVariablesCube()
          get cube of post-state variables
 MvSet MvRelation.getPreVariablesCube()
          return cube of pre-state variables
 MvSet SeqMvRelation.getPreVariablesCube()
          return cube of pre-state variables
 MvSet MvSetMvRelation.getPreVariablesCube()
          return cube of pre-state variables
 MvSet AbstractMvSet.impl(MvSet v)
           
 MvSet MvSet.impl(MvSet v)
           
 MvSet AbstractMvSet.infoAnd(MvSet v)
           
 MvSet MvSet.infoAnd(MvSet v)
           
 MvSet JCUDDMvSetFactory.infoBot()
           
 MvSet MvSetFactory.infoBot()
           
 MvSet JCUDDBelnapMvSetFactory.infoBot()
           
 MvSet MDDMvSetFactory.infoBot()
           
 MvSet AbstractMvSetFactory.infoBot()
           
 MvSet JCUDDBelnapMvSetFactory.JCUDDBelnapMvSet.infoNot()
           
 MvSet AbstractMvSet.infoNot()
           
 MvSet MvSet.infoNot()
           
 MvSet AbstractMvSet.infoOr(MvSet v)
           
 MvSet MvSet.infoOr(MvSet v)
           
 MvSet JCUDDMvSetFactory.infoTop()
           
 MvSet MvSetFactory.infoTop()
           
 MvSet JCUDDBelnapMvSetFactory.infoTop()
           
 MvSet MDDMvSetFactory.infoTop()
           
 MvSet AbstractMvSetFactory.infoTop()
           
 MvSet AbstractMvSet.leq(MvSet v)
           
 MvSet MvSet.leq(MvSet v)
           
 MvSet AbstractMvSet.not()
           
 MvSet MvSet.not()
           
 MvSet AbstractMvSet.or(MvSet v)
           
 MvSet MvSet.or(MvSet v)
           
 MvSet JCUDDMvSetFactory.JCUDDMvSet.ptwiseCompare(int op, MvSet g)
           
 MvSet JCUDDBelnapMvSetFactory.JCUDDBelnapMvSet.ptwiseCompare(int op, MvSet g)
           
 MvSet MDDMvSetFactory.MDDMvSet.ptwiseCompare(int op, MvSet g)
           
 MvSet JADDMvSetFactory.JADDMvSet.ptwiseCompare(int op, MvSet g)
           
 MvSet MvSet.ptwiseCompare(int op, MvSet g)
          Ptwise compare: <=, >=, =.
 MvSet CUADDMvSetFactory.CUADDMvSet.ptwiseCompare(int op, MvSet g)
           
 MvSet JCUDDMvSetFactory.JCUDDMvSet.ptwiseCompose(int op, MvSet g)
          Creates a pointwise composition op is an operator: L x L -> L f is the current mv-set result h (x) = f (x) op g (x)
 MvSet JCUDDBelnapMvSetFactory.JCUDDBelnapMvSet.ptwiseCompose(int op, MvSet g)
          Creates a pointwise composition op is an operator: L x L -> L f is the current mv-set result h (x) = f (x) op g (x)
 MvSet MDDMvSetFactory.MDDMvSet.ptwiseCompose(int op, MvSet g)
          Creates a pointwise composition op is an operator: L x L -> L f is the current mv-set result h (x) = f (x) op g (x)
 MvSet JADDMvSetFactory.JADDMvSet.ptwiseCompose(int op, MvSet g)
          Creates a pointwise composition op is an operator: L x L -> L f is the current mv-set result h (x) = f (x) op g (x)
 MvSet MvSet.ptwiseCompose(int op, MvSet g)
          Creates a pointwise composition op is an operator: L x L -> L f is the current mv-set result h (x) = f (x) op g (x)
 MvSet CUADDMvSetFactory.CUADDMvSet.ptwiseCompose(int op, MvSet g)
          Creates a pointwise composition op is an operator: L x L -> L f is the current mv-set result h (x) = f (x) op g (x)
 MvSet JCUDDMvSetFactory.JCUDDMvSet.ptwiseNeg()
          Creates a ptwise negation h (x) = \neg f (x)
 MvSet JCUDDBelnapMvSetFactory.JCUDDBelnapMvSet.ptwiseNeg()
          Creates a ptwise negation h (x) = \neg f (x)
 MvSet MDDMvSetFactory.MDDMvSet.ptwiseNeg()
          Creates a ptwise negation h (x) = \neg f (x)
 MvSet JADDMvSetFactory.JADDMvSet.ptwiseNeg()
          Creates a ptwise negation h (x) = \neg f (x)
 MvSet MvSet.ptwiseNeg()
          Creates a ptwise negation h (x) = \neg f (x)
 MvSet CUADDMvSetFactory.CUADDMvSet.ptwiseNeg()
          Creates a ptwise negation h (x) = \neg f (x)
 MvSet JCUDDMvSetFactory.JCUDDMvSet.renameArgs(int[] newArgs)
          Renames the arguments.
 MvSet JCUDDBelnapMvSetFactory.JCUDDBelnapMvSet.renameArgs(int[] newArgs)
          Renames the arguments.
 MvSet MDDMvSetFactory.MDDMvSet.renameArgs(int[] newArgs)
          Renames the arguments.
 MvSet JADDMvSetFactory.JADDMvSet.renameArgs(int[] newArgs)
          Renames the arguments.
 MvSet MvSet.renameArgs(int[] newArgs)
          Renames the arguments.
 MvSet CUADDMvSetFactory.CUADDMvSet.renameArgs(int[] newArgs)
          Renames the arguments.
 MvSet MvRelation.toMvSet()
          Converts this transformer to an MvSet over pre- and post-variables, if possible.
 MvSet SeqMvRelation.toMvSet()
           
 MvSet MvSetMvRelation.toMvSet()
           
 MvSet JCUDDMvSetFactory.top()
           
 MvSet MvSetFactory.top()
           
 MvSet JCUDDBelnapMvSetFactory.top()
           
 MvSet MDDMvSetFactory.top()
           
 MvSet JADDMvSetFactory.top()
           
 MvSet CUADDMvSetFactory.top()
           
 MvSet JCUDDMvSetFactory.var(int argIdx, AlgebraValue argVal, AlgebraValue value)
           
 MvSet MvSetFactory.var(int arg, AlgebraValue argVal, AlgebraValue value)
          Builds an mvset corresponding to (arg = argVal) /\ value
 MvSet JCUDDBelnapMvSetFactory.var(int argIdx, AlgebraValue argVal, AlgebraValue value)
           
 MvSet MDDMvSetFactory.var(int argIdx, AlgebraValue argVal, AlgebraValue value)
           
 MvSet JADDMvSetFactory.var(int argIdx, AlgebraValue argVal, AlgebraValue value)
           
 MvSet CUADDMvSetFactory.var(int argIdx, AlgebraValue argVal, AlgebraValue value)
           
 

Methods in edu.toronto.cs.mvset with parameters of type MvSet
 MvSet AbstractMvSet.and(MvSet v)
          Utility functions
 MvSet MvSet.and(MvSet v)
          Utility functions
 MvSet MvRelation.bwdImage(MvSet v)
          Computes the backward image (a.k.a, pre, EX) of v.
 MvSet SeqMvRelation.bwdImage(MvSet v)
           
 MvSet MvSetMvRelation.bwdImage(MvSet v)
           
 MvSet JCUDDMvSetFactory.JCUDDMvSet.cofactor(MvSet cube)
           
 MvSet JCUDDBelnapMvSetFactory.JCUDDBelnapMvSet.cofactor(MvSet cube)
           
 MvSet MDDMvSetFactory.MDDMvSet.cofactor(MvSet point)
           
 MvSet AbstractMvSet.cofactor(MvSet point)
           
 MvSet MvSet.cofactor(MvSet point)
           
 MvSet JCUDDMvSetFactory.createCase(int argIdx, MvSet[] children)
           
 MvSet MvSetFactory.createCase(int argIdx, MvSet[] children)
          createCase creates a case relative to argIdx this is somewhat simillar to Ite (if-then-else) in CUDD but extended to more than two children.
 MvSet JCUDDBelnapMvSetFactory.createCase(int argIdx, MvSet[] children)
           
 MvSet MDDMvSetFactory.createCase(int argIdx, MvSet[] children)
           
 MvSet JADDMvSetFactory.createCase(int argIdx, MvSet[] children)
           
 MvSet CUADDMvSetFactory.createCase(int argIdx, MvSet[] children)
           
 MvSet JCUDDMvSetFactory.createIte(int argIdx, MvSet child0, MvSet child1)
           
 MvSet JCUDDBelnapMvSetFactory.createIte(int argIdx, MvSet child0, MvSet child1)
           
 MvSet CUADDMvSetFactory.createIte(int argIdx, MvSet child0, MvSet child1)
           
 MvSet MvRelation.dualBwdImage(MvSet v)
          Computes the logical dual of backward image (a.k.a.
 MvSet SeqMvRelation.dualBwdImage(MvSet v)
           
 MvSet MvSetMvRelation.dualBwdImage(MvSet v)
           
 MvSet AbstractMvSet.eq(MvSet v)
           
 MvSet MvSet.eq(MvSet v)
           
 MvSet JCUDDMvSetFactory.JCUDDMvSet.existAbstract(MvSet _cube)
           
 MvSet JCUDDBelnapMvSetFactory.JCUDDBelnapMvSet.existAbstract(MvSet _cube)
           
 MvSet MDDMvSetFactory.MDDMvSet.existAbstract(MvSet _cube)
           
 MvSet JADDMvSetFactory.JADDMvSet.existAbstract(MvSet _cube)
           
 MvSet MvSet.existAbstract(MvSet cube)
           
 MvSet CUADDMvSetFactory.CUADDMvSet.existAbstract(MvSet _cube)
           
 MvSet JCUDDMvSetFactory.JCUDDMvSet.forallAbstract(MvSet _cube)
           
 MvSet JCUDDBelnapMvSetFactory.JCUDDBelnapMvSet.forallAbstract(MvSet _cube)
           
 MvSet MDDMvSetFactory.MDDMvSet.forallAbstract(MvSet _cube)
           
 MvSet JADDMvSetFactory.JADDMvSet.forallAbstract(MvSet _cube)
           
 MvSet MvSet.forallAbstract(MvSet cube)
           
 MvSet CUADDMvSetFactory.CUADDMvSet.forallAbstract(MvSet _cube)
           
 MvSet MvRelation.fwdImage(MvSet v)
          Computes forward image (post) of v
 MvSet SeqMvRelation.fwdImage(MvSet v)
           
 MvSet MvSetMvRelation.fwdImage(MvSet v)
           
 MvSet AbstractMvSet.geq(MvSet v)
           
 MvSet MvSet.geq(MvSet v)
           
 MvSet AbstractMvSet.impl(MvSet v)
           
 MvSet MvSet.impl(MvSet v)
           
 MvSet AbstractMvSet.infoAnd(MvSet v)
           
 MvSet MvSet.infoAnd(MvSet v)
           
 MvSet AbstractMvSet.infoOr(MvSet v)
           
 MvSet MvSet.infoOr(MvSet v)
           
 MvSet AbstractMvSet.leq(MvSet v)
           
 MvSet MvSet.leq(MvSet v)
           
 java.util.Iterator JCUDDMvSetFactory.JCUDDMvSet.mintermIterator(MvSet vars, AlgebraValue val)
           
 java.util.Iterator JCUDDBelnapMvSetFactory.JCUDDBelnapMvSet.mintermIterator(MvSet vars, AlgebraValue val)
           
 java.util.Iterator MDDMvSetFactory.MDDMvSet.mintermIterator(MvSet _vars, AlgebraValue val)
           
 java.util.Iterator AbstractMvSet.mintermIterator(MvSet vars, AlgebraValue v)
           
 java.util.Iterator MvSet.mintermIterator(MvSet vars, AlgebraValue val)
           
 MvSet AbstractMvSet.or(MvSet v)
           
 MvSet MvSet.or(MvSet v)
           
 MvSet JCUDDMvSetFactory.JCUDDMvSet.ptwiseCompare(int op, MvSet g)
           
 MvSet JCUDDBelnapMvSetFactory.JCUDDBelnapMvSet.ptwiseCompare(int op, MvSet g)
           
 MvSet MDDMvSetFactory.MDDMvSet.ptwiseCompare(int op, MvSet g)
           
 MvSet JADDMvSetFactory.JADDMvSet.ptwiseCompare(int op, MvSet g)
           
 MvSet MvSet.ptwiseCompare(int op, MvSet g)
          Ptwise compare: <=, >=, =.
 MvSet CUADDMvSetFactory.CUADDMvSet.ptwiseCompare(int op, MvSet g)
           
 MvSet JCUDDMvSetFactory.JCUDDMvSet.ptwiseCompose(int op, MvSet g)
          Creates a pointwise composition op is an operator: L x L -> L f is the current mv-set result h (x) = f (x) op g (x)
 MvSet JCUDDBelnapMvSetFactory.JCUDDBelnapMvSet.ptwiseCompose(int op, MvSet g)
          Creates a pointwise composition op is an operator: L x L -> L f is the current mv-set result h (x) = f (x) op g (x)
 MvSet MDDMvSetFactory.MDDMvSet.ptwiseCompose(int op, MvSet g)
          Creates a pointwise composition op is an operator: L x L -> L f is the current mv-set result h (x) = f (x) op g (x)
 MvSet JADDMvSetFactory.JADDMvSet.ptwiseCompose(int op, MvSet g)
          Creates a pointwise composition op is an operator: L x L -> L f is the current mv-set result h (x) = f (x) op g (x)
 MvSet MvSet.ptwiseCompose(int op, MvSet g)
          Creates a pointwise composition op is an operator: L x L -> L f is the current mv-set result h (x) = f (x) op g (x)
 MvSet CUADDMvSetFactory.CUADDMvSet.ptwiseCompose(int op, MvSet g)
          Creates a pointwise composition op is an operator: L x L -> L f is the current mv-set result h (x) = f (x) op g (x)
 void MvRelation.setTrans(MvSet v)
          Sets the transition part of the relation from an mvset over pre- and post- variables
 void SeqMvRelation.setTrans(MvSet v)
           
 void MvSetMvRelation.setTrans(MvSet v)
           
 MvRelation JCUDDMvSetFactory.JCUDDMvSet.toMvRelation(MvSet invariant, MvSet preVariablesCube, MvSet postVariablesCube, int[] preToPostMap, int[] postToPreMap)
           
 MvRelation JCUDDBelnapMvSetFactory.JCUDDBelnapMvSet.toMvRelation(MvSet invariant, MvSet preVariablesCube, MvSet postVariablesCube, int[] preToPostMap, int[] postToPreMap)
           
 MvRelation AbstractMvSet.toMvRelation(MvSet invar, MvSet preVarCube, MvSet postVarCube, int[] preToPostMap, int[] postToPreMap)
           
 MvRelation MvSet.toMvRelation(MvSet invar, MvSet preVarCube, MvSet postVarCube, int[] preToPostMap, int[] postToPreMap)
           
 MvRelation AbstractMvSet.toMvRelation(MvSet invar, MvSet invarPost, MvSet preVarCube, MvSet postVarCube, int[] preToPostMap, int[] postToPreMap)
           
 MvRelation MvSet.toMvRelation(MvSet invar, MvSet invarPost, MvSet preVarCube, MvSet postVarCube, int[] preToPostMap, int[] postToPreMap)
           
 

Constructors in edu.toronto.cs.mvset with parameters of type MvSet
MvSetMvRelation(MvSet _reln, MvSet _preVariablesCube, MvSet _postVariablesCube, int[] _preToPostMap, int[] _postToPreMap)
           
MvSetMvRelation(MvSet _reln, MvSet _invariant, MvSet _preVariablesCube, MvSet _postVariablesCube, int[] _preToPostMap, int[] _postToPreMap)
          Creates a new MvSetMvRelation instance.
MvSetMvRelation(MvSet _reln, MvSet _invariant, MvSet _invariantPost, MvSet _preVariablesCube, MvSet _postVariablesCube, int[] _preToPostMap, int[] _postToPreMap)
          Creates a new MvSetMvRelation instance.
 

Uses of MvSet in edu.toronto.cs.proof
 

Methods in edu.toronto.cs.proof that return MvSet
 MvSet ProofStep.getState()
           
 

Methods in edu.toronto.cs.proof with parameters of type MvSet
static ProofStep ProofStepFactory.makeProofStep(AlgebraValue _v, MvSet _state, CTLNode _consequent)
           
static java.lang.String ProofStepFactory.makeStateName(MvSet state)
           
 

Constructors in edu.toronto.cs.proof with parameters of type MvSet
ConjProofStep(AlgebraValue _v, MvSet _state, java.lang.String _stateName, CTLNode _consequent)
           
DisjProofStep(AlgebraValue _v, MvSet _state, java.lang.String stateName, CTLNode _consequent, DisjProofStrategy _strategy)
           
EGProofStep(AlgebraValue _v, MvSet _state, java.lang.String _stateName, CTLNode _consequent)
           
EUiProofStep(AlgebraValue _v, MvSet _state, java.lang.String _stateName, CTLNode _consequent, int _bound)
           
EUProofStep(AlgebraValue _v, MvSet _state, java.lang.String _stateName, CTLNode _consequent)
           
EXProofStep(AlgebraValue _v, MvSet _state, java.lang.String _stateName, CTLNode _consequent)
           
NegProofStep(AlgebraValue _v, MvSet _state, java.lang.String _stateName, CTLNode _consequent)
           
ProofStep(AlgebraValue _v, MvSet _state, java.lang.String _stateName, CTLNode _consequent)
           
PropProofStep(AlgebraValue _v, MvSet _state, java.lang.String _stateName, CTLNode _consequent)
           
 

Uses of MvSet in edu.toronto.cs.proof2
 

Methods in edu.toronto.cs.proof2 that return MvSet
protected abstract  MvSet CTLProver.PreferAvoidEXProofRule.getPreferred(MvSet allSucc)
           
 MvSet Formula.getState()
           
 

Methods in edu.toronto.cs.proof2 with parameters of type MvSet
static void CTLProver.dumpMvSet(MvSet mvSet, AlgebraValue x)
           
static Formula Formula.duplicate(Formula f, CTLNode ctl, AlgebraValue val, MvSet state)
           
protected abstract  MvSet CTLProver.PreferAvoidEXProofRule.getPreferred(MvSet allSucc)
           
 void CTLProver.BaseEXProofRule.getSuccessorMap(MvSet state, java.lang.String name, CTLNode conseq)
           
 

Constructors in edu.toronto.cs.proof2 with parameters of type MvSet
AboveFormula(CTLNode _ctl, AlgebraValue _val, MvSet _state)
           
BelowFormula(CTLNode _ctl, AlgebraValue _val, MvSet _state)
           
ComparisonFormula(CTLNode _ctl, AlgebraValue _val, MvSet _state)
           
EqualFormula(CTLNode _ctl, AlgebraValue _val, MvSet _state)
           
Formula(CTLNode _ctl, AlgebraValue _val, MvSet _state)
           
VisitedEXProofRule(MvSetModelChecker mc, MvSet _visited)
           
 

Uses of MvSet in edu.toronto.cs.simulator
 

Methods in edu.toronto.cs.simulator that return MvSet
 MvSet XCStateInfo.getVariables()
          Retrieves the state variables.
 

Constructors in edu.toronto.cs.simulator with parameters of type MvSet
XCStateInfo(MvSet vars)
          Constructs the state info from the MvSet identifying the state.
XCStateInfo(java.lang.String l, MvSet vars)
          Constructs the state info from the MvSet identifying the state and a label.
 

Uses of MvSet in edu.toronto.cs.smv
 

Methods in edu.toronto.cs.smv that return MvSet
 MvSet VariableTable.EnumeratedVariable.__eq(VariableTable.EnumeratedVariable v)
           
 MvSet SMVModule.AlgebraDefine.and(MvSet v)
           
 MvSet SMVModule.AlgebraDefine.and(SMVModule.AlgebraVariable v)
           
 MvSet SMVModule.IntDefine.buildMvSet()
           
 MvSet SMVModule.IntVariable.buildMvSet()
           
 MvSet VariableTable.CaseTranslator.compute()
           
 MvSet SMVModule.CaseStatement.compute()
           
 MvSet SMVModule.BoolCaseStatement.compute()
           
 MvSet Lift.computeCall(Lift.Button[] buttons)
           
 MvSet LiftAbstract.computeCall(LiftAbstract.Button[] buttons)
           
 MvSet MainLift.computeCall(MainLift.Button[] buttons)
           
 MvSet Lift.computeInit()
           
 MvSet Lift.Button.computeInit()
           
 MvSet Lift.LiftCabin.computeInit()
           
abstract  MvSet SMVModule.computeInit()
           
 MvSet AxelEx1b.computeInit()
           
 MvSet MainLift.computeInit()
           
 MvSet MainLift.Button.computeInit()
           
 MvSet MainLift.Lift.computeInit()
           
 MvSet FairTester.computeInit()
           
 MvSet LiftAbstract.computeInit()
           
 MvSet LiftAbstract.Button.computeInit()
           
 MvSet LiftAbstract.LiftCabin.computeInit()
           
 MvSet OneBtn.computeInit()
           
 MvSet ConcurExample.computeInit()
           
 MvSet MyGame.computeInit()
           
 MvSet AxelEx2.computeInit()
           
 MvSet Game.computeInit()
           
 MvSet Helmut.computeInit()
           
 MvSet Simple.computeInit()
           
 MvSet AxelEx1a.computeInit()
           
 MvSet AxelEx4.computeInit()
           
 MvSet AxelEx1b.computeInitSingleState()
           
 MvSet AxelEx2.computeInitSingleState()
           
 MvSet Lift.computeTrans()
           
 MvSet Lift.Button.computeTrans()
           
 MvSet Lift.LiftCabin.computeTrans()
           
abstract  MvSet SMVModule.computeTrans()
           
 MvSet AxelEx1b.computeTrans()
           
 MvSet MainLift.computeTrans()
           
 MvSet MainLift.Button.computeTrans()
           
 MvSet MainLift.Lift.computeTrans()
           
 MvSet FairTester.computeTrans()
           
 MvSet LiftAbstract.computeTrans()
           
 MvSet LiftAbstract.Button.computeTrans()
           
 MvSet LiftAbstract.LiftCabin.computeTrans()
           
 MvSet OneBtn.computeTrans()
           
 MvSet ConcurExample.computeTrans()
           
 MvSet MyGame.computeTrans()
           
 MvSet AxelEx2.computeTrans()
           
 MvSet Game.computeTrans()
           
 MvSet Helmut.computeTrans()
           
 MvSet Simple.computeTrans()
           
 MvSet AxelEx1a.computeTrans()
           
 MvSet AxelEx4.computeTrans()
           
 MvSet SMVModule.IntDefine.eq(int num)
           
abstract  MvSet VariableTable.Variable.eq(MvSet v)
           
 MvSet VariableTable.EnumeratedVariable.eq(MvSet v)
           
 MvSet VariableTable.StateVariable.eq(MvSet v)
           
 MvSet SMVModule.Variable.eq(MvSet v)
           
 MvSet SMVModule.Variable.eq(SMVModule.Variable v)
           
abstract  MvSet VariableTable.Variable.eq(java.lang.String v)
           
 MvSet VariableTable.EnumeratedVariable.eq(java.lang.String v)
           
 MvSet VariableTable.StateVariable.eq(java.lang.String v)
           
 MvSet VariableTable.EnumeratedVariable.eq(VariableTable.EnumeratedVariable v)
           
 MvSet VariableTable.StateVariable.eq(VariableTable.StateVariable v)
           
abstract  MvSet VariableTable.Variable.eq(VariableTable.Variable v)
           
 MvSet VariableTable.EnumeratedVariable.eq(VariableTable.Variable v)
           
 MvSet VariableTable.StateVariable.eq(VariableTable.Variable v)
           
abstract  MvSet VariableTable.Variable.eqNext()
           
 MvSet VariableTable.EnumeratedVariable.eqNext()
           
 MvSet VariableTable.StateVariable.eqNext()
           
 MvSet SMVModule.IntDefine.geq(int num)
           
 MvSet VariableTable.StateVariable.getMvSet()
           
 MvSet SMVModule.IntDefine.gt(int num)
           
 MvSet SMVModule.intConstant(int i)
           
 MvSet SMVModule.IntDefine.leq(int num)
           
 MvSet SMVModule.IntDefine.lt(int num)
           
 MvSet SMVModule.IntDefine.minus(int num)
           
 MvSet SMVModule.Variable.mvSet()
           
 MvSet SMVModule.AlgebraDefine.not()
           
 MvSet SMVModule.AlgebraDefine.or(MvSet v)
           
 MvSet SMVModule.AlgebraDefine.or(SMVModule.AlgebraVariable v)
           
 MvSet SMVModule.IntDefine.plus(int num)
           
 

Methods in edu.toronto.cs.smv with parameters of type MvSet
 VariableTable.CaseTranslator VariableTable.CaseTranslator.addCase(MvSet cond, MvSet stmt)
           
 SMVModule.CaseStatement SMVModule.CaseStatement.addCase(MvSet cond, MvSet stmt)
           
 SMVModule.BoolCaseStatement SMVModule.BoolCaseStatement.addCase(MvSet cond, MvSet stmt)
           
 SMVModule.CaseStatement SMVModule.CaseStatement.addCase(SMVModule.Variable v, MvSet stmt)
           
 VariableTable.CaseTranslator VariableTable.CaseTranslator.addDefault(MvSet stmt)
           
 SMVModule.CaseStatement SMVModule.CaseStatement.addDefault(MvSet stmt)
           
 SMVModule.BoolCaseStatement SMVModule.BoolCaseStatement.addDefault(MvSet stmt)
           
 MvSet SMVModule.AlgebraDefine.and(MvSet v)
           
 VariableTable.DefineVariable VariableTable.declareDefine(java.lang.String name, MvSet value)
           
abstract  MvSet VariableTable.Variable.eq(MvSet v)
           
 MvSet VariableTable.EnumeratedVariable.eq(MvSet v)
           
 MvSet VariableTable.StateVariable.eq(MvSet v)
           
 MvSet SMVModule.Variable.eq(MvSet v)
           
 MvSet SMVModule.AlgebraDefine.or(MvSet v)
           
 void SMVModule.Variable.setMvSet(MvSet v)
           
 void Lift.Button.setReset(MvSet v)
           
 void MainLift.Button.setReset(MvSet v)
           
 void LiftAbstract.Button.setReset(MvSet v)
           
 CTLNode[] SMVModule.SMVStatePresenter.toCTL(MvSet cube)
           
 

Constructors in edu.toronto.cs.smv with parameters of type MvSet
SMVModule.BoolCaseStatement(MvSet _mvBot)
           
VariableTable.DefineVariable(java.lang.String name, MvSet value)
           
VariableTable.StateVariable(java.lang.String name, MvSet _mvSet)
           
 

Uses of MvSet in edu.toronto.cs.smv.parser
 

Methods in edu.toronto.cs.smv.parser that return MvSet
 MvSet DDBuilder.aset(antlr.collections.AST _t)
           
 MvSet DDBuilder.astmt(antlr.collections.AST _t)
           
 MvSet FullDDBuilder.expression(antlr.collections.AST _t, VariableTable.Variable var)
           
 MvSet DDBuilder.getInit()
           
 MvSet DDBuilder.getTrans()
           
 MvSet DDBuilder.init(antlr.collections.AST _t)
           
 MvSet DDBuilder.kase(antlr.collections.AST _t)
           
 MvSet DDBuilder.next(antlr.collections.AST _t)
           
 MvSet DDBuilder.predicate(antlr.collections.AST _t)
           
 

Uses of MvSet in edu.toronto.cs.tlq
 

Methods in edu.toronto.cs.tlq that return MvSet
 MvSet MvSetCrossProductAlgebra.CrossProductValue.getValue(int i)
           
 

Methods in edu.toronto.cs.tlq with parameters of type MvSet
 MvSetUpsetAlgebra.MvSetUpsetValue MvSetUpsetAlgebra.getJoinIrreducible(int i, MvSet mvSet)
          Convinience method to produce an join irreducible element of this algebra without creating a cross-product element first.
 CTLNode MvSetPlaceholderReWriter.getOneSolution(MvSet v, StatePresenter presenter, boolean negated)
           
 MvSetCrossProductAlgebra.CrossProductValue MvSetCrossProductAlgebra.newValue(int idx, MvSet v)
           
 

Uses of MvSet in edu.toronto.cs.xkripke
 

Methods in edu.toronto.cs.xkripke that return MvSet
static MvSet XKripkeMvSetBuilder.buildMvSet(MvSetFactory mvSetFactory, XKripke kripke)
          mvSetFactory -- needed to create MvSets kripke -- the XKripke model to convert propOrder -- interface to order the atomic props
static MvSet XKripkeMvSetBuilder.buildTransition(MvSetFactory mvSetFactory, IAlgebra algebra, XKripke.XKripkeTransition trans, VariableTable vt)