Formalization of CTL* in Calculus of Inductive Constructions

@inproceedings{Tsai2006FormalizationOC,
  title={Formalization of CTL* in Calculus of Inductive Constructions},
  author={Ming-Hsien Tsai and Bow-Yaw Wang},
  booktitle={ASIAN},
  year={2006}
}
A modular formalization of the branching time temporal logic CTL* is presented. Our formalization subsumes prior formalizations of propositional linear temporal logic (PTL) and computation tree logic (CTL). Moreover, the modularity allows to instantiate our formalization for different formal security models. Validity of axioms and soundness of inference rules in axiomatizations of PTL, UB, CTL, and CTL* are discussed as well. 

Modular Formalization of Reactive Modules in COQ

TLDR
The advantages of modular formalizations of the model specification language Reactive Modules and the temporal logic CTL* in the proof assistant Coq are illustrated by proving the mutual exclusion property of the Bakery algorithm in different embeddings.

Formal Proof of a Machine Closed Theorem in Coq

TLDR
A shallow embedding scheme is employed for the proof which is independent of concrete syntax and a useful proof pattern of constructing a trace with desired properties is devised.

A Proof Pearl with the Fan Theorem and Bar Induction - Walking through Infinite Trees with Mixed Induction and Coinduction

TLDR
A systematic study of the relationships of the path-based and tree-based versions of "eventually always blueness" and mixed inductive-coinductive "almost always bluness" and arrives at a diagram relating these properties to each other in terms of implications that hold either unconditionally or under specific assumptions.

Deductive Verification of State-Space Algorithms

TLDR
This paper focuses on using a verification condition generator that takes annotated algorithms and ensures their termination and correctness and study four algorithms of state-space construction as a first step towards mechanically-assisted deductive verification of model-checkers.

A Mechanized Theory of Regular Trees in Dependent Type Theory

TLDR
This paper describes an implementation of regular trees in dependent type theory, semantically characterised as a coinductive type and syntactically as a nested datatype, and shows how tree transducers can be used to define regular tree homomorphisms by guarded corecursion.

BSP-Why, un outil pour la vérification déductive de programmes BSP : machine-checked semantics and application to distributed state-space algorithms. (BSP-Why, a tool for deductive verification of BSP programs : sémantiques mécanisées et application aux algorithmes d'espace d'états distribués)

TLDR
This thesis based themselves on Why, a VCG (verification condition generator) that has the advantage of being able to interface with several automatic provers and proof assistants to discharge the proof obligations, and chose to extend an existing tool to adapt it for the proof of BSP programs.

Source-free Machine-checked Validation of Native Code in Coq

Picinæ is an infrastructure for machine-proving properties of raw native code programs without sources within the Coq program-proof co-development system. This facilitates formal reasoning about

References

SHOWING 1-10 OF 23 REFERENCES

An Axiomatization of Linear Temporal Logic in the Calculus of Inductive Constructions

TLDR
A shallow embedding of Linear Temporal Logic in the Calculus of Inductive Constructions based on a co-inductive representation of program executions is presented, resulting in several reusable libraries in the Coq proof-assistant.

Modular Formalization of Reactive Modules in COQ

TLDR
The advantages of modular formalizations of the model specification language Reactive Modules and the temporal logic CTL* in the proof assistant Coq are illustrated by proving the mutual exclusion property of the Bakery algorithm in different embeddings.

On the Formalization of the Modal µ-Calculus in the Calculus of Inductive Constructions

TLDR
This work addresses several problematic issues, such as the use of higher-order abstract syntax in inductive sets in the presence of recursive constructors, and the formalization of modal (sequent-style) rules and of context sensitive grammars in the calculus of inductive constructions.

An axiomatization of full Computation Tree Logic

TLDR
A sound and complete axiomatization for the full computation tree logic of R-generable models is given and solves a long standing open problem in branching time temporal logic.

A Verified Model Checker for the Modal µ-calculus in Coq

TLDR
This work reports on the formalisation and correctness proof of a model checker for the modal Μ-calculus in Coq's constructive type theory and obtains an executable Caml program, which is added as a safe decision procedure to the system.

Combining Model Checking and Deduction for I/O-Automata

We propose a combination of model checking and interactive theorem proving where the theorem prover is used to represent finite and infinite state systems, reason about them compositionally and

I/O Automata and Beyond: Temporal Logic and Abstraction in Isabelle

TLDR
Using a tailored combination of Isabelle's logics HOL and HOLCF, a verification framework for I/O automata in Isabelle is described, achieving two complementary goals: expressiveness for proving meta theory (HolCF) and simplicity and efficiency for system verification (HOL).

Traces of I/O-Automata in Isabelle/HOLCF

TLDR
A formalization of finite and infinite sequences in domain theory carried out in the theorem prover Isabelle is presented and the correctness of a generalized refinement concept in I/O automata is proved.

A Temporal Logic of Nested Calls and Returns

TLDR
This work introduces a temporal logic of calls and returns (CaRet) for specification and algorithmic verification of correctness requirements of structured programs and presents a tableau construction that reduces the model checking problem to the emptiness problem for a Buchi pushdown system.

The temporal logic of actions

TLDR
This report introduces TLA and describes how it is used to specifying and verify concurrent algorithms and the use of TLA to specify and reason about open systems will be described elsewhere.