CHASE MCP Server
Server Configuration
Describes the environment variables required to run the server.
| Name | Required | Description | Default |
|---|---|---|---|
| CHASE_NUSMV | No | Path to the NuSMV model checker if it is not in the PATH. | |
| CHASE_NUXMV | No | Path to the nuXmv model checker if it is not in the PATH. |
Instructions
Guidance the server publishes about itself, which clients place ahead of the tool catalog so the model reads it before choosing anything.
This server publishes no instructions, or was last inspected before Glama recorded them.
Capabilities
Features and capabilities supported by this server
Protocol revision2025-11-25
| Capability | Details |
|---|---|
| tools | {
"listChanged": false
} |
| prompts | {
"listChanged": false
} |
| resources | {
"subscribe": false,
"listChanged": false
} |
Tools
Functions exposed to the LLM to take actions
| Name | Description |
|---|---|
| composeA | Parallel composition of two or more contracts (the contract of the system made of the components). Variables with the same name are connected; no variable can be an output of two contracts. By default the closed form ((A1 & A2) | !(G1 & G2), G1 & G2). With discharge, the result keeps the terms of the contracts: an assumption of a component implied by the component that drives its inputs is dropped, then the redundant terms; each test is one model-checking call. That result is an abstraction of the composition: a refinement proved on it holds for the composition, a failed one may not. |
| conjoinB | Conjunction (greatest lower bound) of two or more contracts: a contract that refines all of them, (A1 | A2, G1 & G2). With discharge, the result keeps the terms (the same contract): each guarantee under the assumptions of its contract that the others do not imply; with the same assumptions, (A, G1 & G2). Each test is one model-checking call. |
| disjoinB | Disjunction (least upper bound) of two or more contracts: a contract refined by all of them, (A1 & A2, G1 | G2). |
| mergeA | Merging of two or more viewpoints of the same component (e.g. function and timing): (A1 & A2, (G1 & G2) | !(A1 & A2)). With discharge, the result keeps the terms of the contracts, (A1 & A2, G1 & G2), which is the same contract, then drops the redundant terms; each test is one model-checking call. Use it before is_realizable or synthesize, which need the terms. |
| divideC | The contract of the missing component: the largest contract C such that part composed with C refines system. (A & G', (G & A') | !(A & G')). With discharge, the result keeps the terms: it assumes the assumptions of system and the guarantees of part (under the assumptions of part that system does not give), and guarantees the guarantees of system and the assumptions of part. It is the same contract, then the redundant terms are dropped; each test is one model-checking call. |
| separateC | Separation, the adjoint of merging: the smallest contract C such that system refines the merging of part and C. ((A & G') | !(G & A'), G & A'). |
| implyC | Implication, the adjoint of conjunction: the largest contract C such that the conjunction of C and premise refines conclusion. ((A2 & !A1) | (G1 & !G2), G2 | !G1), with premise = (A1, G1). |
| coimplyB | Coimplication, the adjoint of disjunction: the smallest contract C such that second refines the disjunction of C and first. (A2 | !A1, (G2 & !G1) | (A1 & !A2)), with first = (A1, G1). |
| invertC | Reciprocal (G, A): the contract seen from its environment. Inputs become outputs and outputs inputs. |
| assumeB | Add an assumption b to the contract: (b & A, b -> G). The result is an abstraction of the contract (it is refined by it). |
| ensureC | Add a guarantee b to the contract: (b -> A, b & G). The result refines the contract. |
| saturateC | Saturation: the equivalent contract (A, A -> G). The other operations saturate their operands themselves. |
| simplifyB | Simplify the formulas of the contract, as the simplify command of logics_tool: negations are moved towards the atoms, and temporal operators are grouped (G f & G g becomes G (f & g)). The result is equivalent; no model checker is needed. |
| refinesA | Does |
| verifyA | Can the assumptions and the guarantees hold together (A & G
satisfiable, the verify command of logics_tool)? status is that of
feasible: sat with a witness trace, which also shows compatibility (A
satisfiable) and consistency (A -> G satisfiable); unsat when the
guarantees cannot hold when the assumptions do, and then compatible and
consistent say whether the assumptions alone cannot hold. With core, an
unsat result carries the terms that conflict (in feasible.core).
|
| is_consistentA | Consistency: is there a behavior allowed by the contract (A -> G
satisfiable)? sat with a witness trace, or unsat when the guarantees
contradict each other; with core, the guarantees that contradict each
other.
|
| is_compatibleB | Compatibility: is there an environment that satisfies the assumptions?
sat with a witness trace, or unsat when the assumptions contradict each
other; with core, the assumptions that contradict each other.
|
| is_implementationA | Is the implementation an implementation of the contract (M |=_M C)? The
implementation is an LTL formula ( |
| is_environmentB | Is the environment an environment of the contract (E |=_E C)? The
environment is an LTL formula over the variables of the contract
( |
| repairB | The values of named constants, within their ranges, that make a check
pass, at the least change from their present values (the sum of
|new - present|), or at the least |
| is_receptiveA | Does the state machine accept every input that the assumptions of the
contract allow? A machine that refuses an input has no behavior with it,
so is_implementation may hold only because it blocks the inputs. receptive, or
not_receptive with the trace to the state after which it refuses an
input (details: state and input). Uses the initial and safety
assumptions; the inputs must be Boolean or integer ranges.
The state machine is given as one of: |
| remove_redundantA | Drop the assumptions implied by the other assumptions, and the
guarantees implied by the assumptions and the other guarantees.
Returns the contract and the terms removed ( |
| impliesB | On formulas: validity. Is the LTL formula phi -> psi valid, i.e. true
for every behavior? Returns valid, or invalid with a counterexample trace
satisfying phi and violating psi.
|
| is_satisfiableA | On formulas: satisfiability. Does some behavior satisfy the LTL formula?
sat with a witness trace, or unsat; with core, the conjuncts of the
formula that cannot hold together. This is not the satisfaction of a
contract by a component, which is is_implementation.
|
| unsat_coreC | On formulas: a minimal set of terms that cannot hold together. Give a contract (its
assumptions and guarantees, A & G, are searched: the core says whether
the assumptions contradict each other, the guarantees do, or the
guarantees cannot hold when the assumptions do), or formulas with their
variables. status is found with core, none when they can hold together,
or unknown with the reason.
|
| is_realizableA | GR(1) synthesis (slugs): realizability. Can a component choose its outputs so that the guarantees hold for every environment satisfying the assumptions? realizable, or unrealizable with the counter-strategy of the environment; with core, also the unrealizable core (see unrealizable_core). Needs slugs; the formulas must be in the GR(1) fragment. |
| synthesizeA | GR(1) synthesis (slugs): the controller (an explicit strategy) when the contract is realizable, or the counter-strategy of the environment. Needs slugs; the formulas must be in the GR(1) fragment. |
| unrealizable_coreB | GR(1) synthesis (slugs): a minimal set of guarantees that is unrealizable under all the assumptions: removing any of them makes the contract realizable. status is found with core (the contract with those guarantees), none when the contract is realizable, or unknown with the reason. Needs slugs. |
| is_well_separatedA | GR(1) synthesis (slugs): well-separation. Can the component win by forcing the environment to violate its assumptions? separated when it cannot; not_separated with the controller that forces the violation, which means the assumptions are too weak or depend on the outputs; with core, a minimal set of assumptions that causes it. The component must keep its initial and safety guarantees while it forces the violation (with with_guarantees false, the guarantees are left out). Only violations forced from every initial state are detected. |
| is_vacuousA | GR(1) synthesis (slugs): vacuity. Can the component win without an
output that a liveness guarantee asks for (Bloem et al., FMSD 2021)?
vacuous lists each such output with its mode, never (a winning strategy
never sets it: the guarantee that names it is discharged by the
assumptions) or eventually (a winning strategy stops setting it), and the
strategy; with core, a minimal set of assumptions that lets it.
not_vacuous; unrealizable when the contract itself is; unknown. The
outputs checked are |
| parse_specB | Read the contracts of a specification in the logics language of CHASE (the .ltl files of logics_tool), given as text or as a file path. |
| to_specB | Write contracts as a specification in the logics language of CHASE, which logics_tool and the other CHASE tools read. |
| rtl_portsB | The ports of a Verilog or SystemVerilog module read as a state machine:
the inputs and the outputs with their types ("bool", "word[n]"), as the
variables of a contract checked against it, the reset (not an input when
given), and |
| parse_cA | Read the contracts written in a C file (text or a file path), one per function: the clauses of ESBMC (__ESBMC_requires, __ESBMC_ensures in the body), of CBMC (__CPROVER_requires, __CPROVER_ensures after the signature), or of ACSL (/*@ requires ...; ensures ...; */). The inputs are the parameters, the outputs FUNCTION_out (the return value) and the pointers written (*p is p). A function with no clause has a contract with no terms: check_c checks it for overflow, division by zero, and the like. |
| check_cA | Check each function of a C file (text or a file path) against the
contract written in its clauses (see parse_c), one call at a time, with
ESBMC or CBMC (whichever is installed): valid, or invalid with the values
of a failing call. A function with no clause is checked as code alone
(safe: no overflow, division by zero, or bad pointer). |
| parse_smvA | Read an SMV model with its specifications (LTLSPEC, INVARSPEC; text or
a file path) as a contract: the IVAR are its inputs, the VAR its outputs
(a VAR with no ASSIGN is still an output: write an input as IVAR), the
specifications its guarantees. is_implementation with |
| parse_svaA | Read the assume property and assert property statements of
SystemVerilog (a module, a bind file, or the statements alone; text or
a file path) as a contract: assumptions and guarantees, with the widths
of Verilog, $past, bounded sequences, and disable iff. The directions
come from the module ports, or from |
| to_svaA | Write a contract as a SystemVerilog checker module: assumptions as
assume property, guarantees as assert property, clocked by
@(edge clock); a formula G p is checked at every cycle, any other once
(initial). |
| visualizeA | Draw contracts as a web page: the contracts given as JSON, or the
contracts of a specification in the logics language of CHASE (text, or
the path of a file). Without |
Prompts
Interactive templates invoked by user choice
| Name | Description |
|---|---|
No prompts | |
Resources
Contextual data attached and managed by the client
| Name | Description |
|---|---|
No resources | |
TDQS
Scored across 39 tools
The tools are all in a coherent formal-methods domain, but several have subtle boundaries: verify vs. is_consistent vs. is_compatible vs. is_satisfiable, and imply vs. implies are easy to confuse. The contract-algebra operations compose/conjoin/disjoin/merge/divide/separate are mathematically distinct, yet an agent must read carefully to choose correctly.
Names are consistently snake_case and mostly follow recognizable patterns such as is_*, parse_*, to_*, and bare verb operations. The main deviations are mixed imperative and predicate styles, plus the near-collision of imply and implies, which slightly weakens predictability.
Thirty-nine tools is far above the typical well-scoped range and creates a high cognitive load even for a rich formal-verification domain. Many tools are specialized and justified individually, but as a set it feels too large rather than neatly scoped.
The surface covers parsing from C, SMV, SVA, and CHASE specs; exporting to specs and SVA; contract algebra; satisfiability, refinement, implementation, and environment checks; synthesis and repair; and visualization. It is hard to identify an obvious lifecycle gap for the stated formal-methods purpose.