Formal methods

In computer science, Abstract interpretation is a theory of sound approximation of the semantics of computer programs, based on monotonic functions over ordered sets, especially lattices. It can be viewed as a partial execution of a computer program which gains information about its semantics (e.g. control structure, flow of information) without performing all the calculations. ...more on Wikipedia about "Abstract interpretation"

Abstract Machine Notation (AMN) is a specification language and (abstract) programming language for specifying abstract machines in the B-Method, based on the mathematical theory of Generalised Substitutions. ...more on Wikipedia about "Abstract Machine Notation"

An abstract state machine is most often used as a synonym for a finite state machine with regards to abstract algorithms (for sorting, etc.). ...more on Wikipedia about "Abstract state machine"

Abstract State Machines (ASM), formerly known as Evolving Algebras, are a formal method for specification and verification. The approach was originally developed by Yuri Gurevich, based around the concept of an abstract state machine, and is also espoused by Egon Börger. ASM theory is the basis for AsmL, the Abstract State Machine Language by Microsoft and XASM, an open source implementation. A number of support tools are available. ...more on Wikipedia about "Abstract State Machines"

In computer science, abstraction is a mechanism and practice to reduce and factor out details so that one can focus on few concepts at a time. ...more on Wikipedia about "Abstraction (computer science)"

ACL2 is a software system consisting of a programming language, an extensible theory in a first-order logic, and a mechanical theorem prover. ACL2 is designed to support automated reasoning in inductive logical theories, mostly for the purpose of software and hardware verification. The input language and implementation of ACL2 are built on Common Lisp. ACL2 is free, open source ( GPL) software. ...more on Wikipedia about "ACL2 theorem prover"

Action semantics is a framework for the formal specification of semantics of programming languages invented by David Watt and Peter D. Mosses. It is a mixture of denotational and operational semantics. ...more on Wikipedia about "Action semantics"

Who is shortopedia?

An algebraic semantics of a programming language is a form of axiomatic semantics based on algebraic laws for describing and reasoning about program semantics in a formal manner. ...more on Wikipedia about "Algebraic semantics"

The Alloy specification language is a simple structural modelling tool based on first-order logic. Alloy is targeted at the creation of micro-models of software systems that can then be automatically checked for correctness. ...more on Wikipedia about "Alloy language"

In computer programming, an assertion is a programming language construct that indicates an assumption on which the program is based. It takes the form of an expression which is intended to be true. Most languages only use assertions to check such assumptions, but others use them to document design decisions. If an assertion proves false, it indicates a possible bug in the program. This is called an "assertion failure." ...more on Wikipedia about "Assertion (computing)"

asynchronous digital system, in contrast, has no global clock: instead, ...more on Wikipedia about "Asynchronous Systems"

Automated theorem proving (currently the most important subfield of automated reasoning) is the proving of mathematical theorems by a computer program. Depending on the underlying logic, the problem of deciding the validity of a theorem varies from trivial to impossible. For the frequent case of propositional logic, the problem is decidable but NP-complete, and hence only exponential-time algorithms exist for general solutions. For first-order logic it is recursively enumerable, i.e., given unbounded resources, any valid theorem can eventually be proven. Invalid statements, i.e. formulas that are not entailed by a given theory, cannot always be recognized. In these cases, a first-order theorem prover will fail to terminate while searching for a proof. Despite these theoretical limits, practical theorem provers can solve many hard problems in these logics. ...more on Wikipedia about "Automated theorem proving"

Axiomatic Semantics is an approach based on mathematical logic to proving the correctness of computer programs. It is closely related to Hoare logic. ...more on Wikipedia about "Axiomatic semantics"

(B-Method) B is a tool-supported formal method based around AMN ( Abstract Machine Notation), used in the development of computer software. It was originally developed by Jean-Raymond Abrial in France and the UK. B is related to the Z notation (also originated by Abrial) and supports development of programming language code from specifications. B has been used in major safety-critical system applications in Europe (such as the Paris Metro Line 14), and is attracting increasing interest in industry. It has robust, commercially available tool support for specification, design, proof and code generation. ...more on Wikipedia about "B-Method"

The article you are reading is from shortopedia

(BCS-FACS) :For other uses of the abbreviation BCS, please see BCS (disambiguation). ...more on Wikipedia about "BCS-FACS"

In theoretical computer science a bisimulation is an equivalence relation between state transition systems, associating systems which behave in the same way in the sense that one system simulates the other and vice-versa. ...more on Wikipedia about "Bisimulation"

BLAST is a software model checking tool for C programs. The goal of BLAST is to be able to check that software satisfies behavioral properties of the interfaces it uses. BLAST uses counterexample-driven automatic abstraction refinement to construct an abstract model which is model checked for safety properties. The abstraction is constructed on the fly, and only to the requested precision. ...more on Wikipedia about "BLAST model checker"

CHIC is a modular verifier for behavioral compatibility checking of hardware and software systems. The goal of CHIC is to be able to check that the interfaces for software or hardware components provide guarantees that satisfy the assumptions they make about each other. CHIC supports a variety of interface property specification formalisms for a variety of application domains, such as resource-usage analysis for embedded systems, behavioral compatibility of web service applications, etc. ...more on Wikipedia about "CHIC"

CICS® (Customer Information Control System) is a transaction server that runs primarily on IBM mainframe systems under z/OS or z/VSE. CICS is available for other operating systems, notably i5/OS, OS/2, and as the closely related IBM TXSeries software on AIX, Windows, and Linux, among others. The z/OS implementation is by far the most popular and significant. ...more on Wikipedia about "CICS"

The Common Algebraic Specification Language (CASL) is a general-purpose specification language ...more on Wikipedia about "Common Algebraic Specification Language"

The Community Z Tools (CZT) project is a SourceForge project to build a set of tools for the Z notation, a formal method useful in software engineering. Tools include support for editing, typechecking and animating Z specifications. There is some support for extensions such as Object-Z and TCOZ. The tools are built using the Java programming language. ...more on Wikipedia about "Community Z Tools"

Enjoy shortopedia.

A computer-assisted proof is a mathematical proof that has been generated by computer. ...more on Wikipedia about "Computer-assisted proof"

In computer science, concurrency semantics is a way to give ...more on Wikipedia about "Concurrency semantics"

The European research project DAEDALUS ( 2000– 2002) dealt with the "validation of software components embedded in future generation critical concurrent systems by exhaustive semantic-based static analysis and abstract testing methods based on abstract interpretation". ...more on Wikipedia about "DAEDALUS"

In computer science, denotational semantics is an approach to formalizing the semantics of computer systems by constructing mathematical objects (called denotations or meanings) which express the semantics of these systems. Other approaches to providing a formal semantics of programming languages include axiomatic semantics and operational semantics. The denotational approach to semantics was originally developed to deal only with systems defined by a single computer program. Later the field broadened to include systems composed of more than one program, such as those found in networking and concurrent systems. ...more on Wikipedia about "Denotational semantics"

This article is licensed under the GNU Free Documentation License.
It uses material from the Wikipedia . Direct links to the original articles are in the text.
If you use exact copy or modified of this article you should preserve above paragraph and put also : It uses material from the Shortopedia article about "Formal methods".

MAIN PAGE MAIN INDEX CONTACT US