Skip to main content
Glama
CHASE MCP Server

CHASE MCP Server

by chase-cps

Server Configuration

Describes the environment variables required to run the server.

NameRequiredDescriptionDefault
CHASE_NUSMVNoPath to the NuSMV model checker if it is not in the PATH.
CHASE_NUXMVNoPath 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

CapabilityDetails
tools
{
  "listChanged": false
}
prompts
{
  "listChanged": false
}
resources
{
  "subscribe": false,
  "listChanged": false
}

Tools

Functions exposed to the LLM to take actions

NameDescription
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 refined refine abstract (can it replace it)? Checks that the assumptions of abstract imply those of refined, and that the guarantees of refined imply those of abstract. status is valid, invalid (with failed and a counterexample trace), or unknown. context: formulas that every behavior satisfies (e.g. an axiom of an encoding, a physical law); the behaviors that violate them are left out. Continuous time: when a step is a sample taken every period seconds and each variable changes at most lipschitz per second (one number, or {variable: number}), the refinement is checked between the samples too: what refined assumes and abstract guarantees is made stricter, what is known is made weaker (chase_cps.sampled). Intervals may then be written with times: G[0s,2s], F[0ms,500ms]. The margins are a sufficient condition: valid shows it in continuous time; otherwise the status is unknown (not shown), never invalid; check without lipschitz to see whether it fails at the samples.

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). context: formulas that every behavior satisfies (e.g. an axiom of an encoding, a physical law); the behaviors that violate them are left out.

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. context: formulas that every behavior satisfies (e.g. an axiom of an encoding, a physical law); the behaviors that violate them are left out.

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. context: formulas that every behavior satisfies (e.g. an axiom of an encoding, a physical law); the behaviors that violate them are left out.

is_implementationA

Is the implementation an implementation of the contract (M |=_M C)? The implementation is an LTL formula (implementation): implementation & A -> G must be valid; or a state machine, every behavior of which must satisfy A -> G. A machine that refuses inputs can implement a contract only because of that: check it with is_receptive. valid, or invalid with a trace and, in details.violated, the guarantees that this trace breaks (others may fail on other behaviors: check a term alone to know). context: formulas that every behavior satisfies (e.g. an axiom of an encoding, a physical law); the behaviors that violate them are left out. The state machine is given as one of: smv, a program in SMV (the input language of nuXmv: MODULE main with VAR/IVAR, INIT, TRANS..., no specification) that declares the variables of the contract; machine, a state machine in JSON {"name", "inputs", "outputs", "states", "initial", "transitions": [{"from", "when", "outputs", "to"}]}: at each step, in its state, the machine takes a transition whose when (a formula over the variables) holds, sets the outputs of that step, and moves to to; or controller, the controller returned by synthesize, with the contract it was synthesized from in synthesized_from (default: the contract); or rtl, a Verilog or SystemVerilog module (see rtl_ports for its ports).

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 (environment): environment -> A must be valid; or a state machine (smv, machine, or rtl, as for is_implementation) every behavior of which must satisfy A. context: formulas that every behavior satisfies (e.g. an axiom of an encoding, a physical law); the behaviors that violate them are left out.

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 minimize / the greatest maximize (a term over the constants). parameters: the constants that may change, {name: {low, high, integer}}; they are among the constants of the contracts. The check: refines (refined, abstract), impl or env (contract and implementation / environment as a formula, or smv, machine, rtl), verify, compat, consist (contract). status: holds (the present values pass), repaired (values, cost, optimal), impossible (no values in the ranges pass), or unknown with a reason. check is the result of the check with the values; the method (projection, counterexamples, witnesses, enumeration) and its rounds are given. time_limit (seconds) stops the whole repair: unknown, with the least cost proved so far (bound).

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: smv, a program in SMV (the input language of nuXmv: MODULE main with VAR/IVAR, INIT, TRANS..., no specification) that declares the variables of the contract; machine, a state machine in JSON {"name", "inputs", "outputs", "states", "initial", "transitions": [{"from", "when", "outputs", "to"}]}: at each step, in its state, the machine takes a transition whose when (a formula over the variables) holds, sets the outputs of that step, and moves to to; or controller, the controller returned by synthesize, with the contract it was synthesized from in synthesized_from (default: the contract); or rtl, a Verilog or SystemVerilog module (see rtl_ports for its ports).

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 (removed: each term with its part, and with core the terms that imply it); terms whose check did not finish are kept and listed in unknown. Choose synth by what the contract is for next. false (the default) keeps A -> G: before the algebra and the checks (compose, refines, verify, ...). true keeps realizability and the controllers: before synthesis (is_realizable, synthesize, is_well_separated, is_vacuous); a term is dropped only when it is implied in the GR(1) game, and each removed term has its kind (init, safety, justice). With synth the terms must be GR(1), and there is no context. The two differ only when the assumptions are wrong (unsatisfiable, or constraining the outputs). context: formulas that every behavior satisfies (e.g. an axiom of an encoding, a physical law); the behaviors that violate them are left out.

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. context: formulas that every behavior satisfies (e.g. an axiom of an encoding, a physical law); the behaviors that violate them are left out.

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. context: formulas that every behavior satisfies (e.g. an axiom of an encoding, a physical law); the behaviors that violate them are left out.

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. context: formulas that every behavior satisfies (e.g. an axiom of an encoding, a physical law); the behaviors that violate them are left out.

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 outputs, by default those that occur only positively in a liveness guarantee (G F ...).

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 start, the step from which the contracts are checked.

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). functions: the ones to check (default: all).

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 smv set to the model (its specifications are left out) checks it. An enumerated type is read as the integers 0, 1, ... in the order written (in the traces too), a DEFINE in a specification as its definition. Not read: CTL, past operators, and a DEFINE written with case ... esac; the error says which.

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 inputs or outputs (the other signals are of the other kind). Returns the contract, the properties read (label, kind, formula, from_cycle: the cycle from which a property with $past is checked), skipped (statements not read, with the reason), covers, the clock, and undeclared (signals read as 1 bit), and names (hierarchical names: u1__state is u1.state; give them to to_sva). One clock per contract: clock ("posedge clk") chooses it.

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). reset (e.g. "rst" or "!rst_n") disables the properties while it holds; bind, the name of a design module, adds a bind statement (ports connected by name; names, from parse_sva, connects the hierarchical names). Any tool that reads SVA can check the module. Real variables cannot be written.

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 draw and refines, the contracts are put together by their ports: an output and an input of the same name are wired; contracts with the same ports are versions of one part, and the first one is wired; a contract whose outputs several parts drive, and which gives them what they read from outside, has the parts drawn inside it. draw names the contracts to draw instead; NAME+NAME draws their composition, a box with the contracts inside, wired by the names of their variables. refines lists [refined, abstract] pairs: the refined one is drawn inside the abstract one, and checked against it. A decomposition is drawn and checked only when a pair names it: refines: [["Sensor+Controller", "Cruise"]]. An input of a part that no other part or input of the box drives is marked (its name in orange). environments lists [model file, contract] pairs: the state machine (SMV, JSON, or a controller of slugs) is drawn on the left of the contract, as an environment. check (the default) checks that the assumptions and the guarantees of each contract can hold together (A ∧ G, with the core when they cannot), and the refinements and the environments drawn; for a file (path), the results are kept next to it (FILE.results.json), and a check of contracts that have not changed is not run again. verify and realizable check each contract drawn, and mark the terms of a core when a check fails. open names the contracts drawn open (their terms, and the core of a check that fails). The page is written to output (default: a new temporary file) and opens in any browser. Returns its path, and for each box its checks.

Prompts

Interactive templates invoked by user choice

NameDescription

No prompts

Resources

Contextual data attached and managed by the client

NameDescription

No resources

TDQS

B3.2/5.0

Scored across 39 tools

Disambiguation3/5

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.

Naming Consistency4/5

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.

Tool Count2/5

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.

Completeness5/5

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.

Maintenance

ActivityMaintained
ResponsivenessOutdated data