Program Development Schemata as Derived Rules

@article{Anderson2000ProgramDS,
  title={Program Development Schemata as Derived Rules},
  author={Penny Anderson and David A. Basin},
  journal={J. Symb. Comput.},
  year={2000},
  volume={30},
  pages={5-36}
}
We show how the formalization and application of schemata for program development can be reduced to the formalization and application of derived rules of inference. We formalize and derive schemata as rules in theories that axiomatize program data and programs themselves. We reduce schema-based program development to ordinary theorem proving, where higher-order unification is used to apply rules. Conceptually, our formalization is simple and unifies divergent views of schemata, program… 

Abstracting Refinements for Transformation

TLDR
A method is proposed to incrementally construct a set of correctness preserving transformation rules for refinement relations in arbitrary specification formalisms in Isabelle theorem prover and demonstrated on an example of data refinement.

Schema-Guided Synthesis of Imperative Programs by Constraint Solving

TLDR
This work presents a method for schema-guided synthesis of imperative programs computing polynomial functions and their inverses, and reduces schema instantiation to non-linear constraint solving, based on the theory of polynomials ideals.

Program schemas as proof methods.

TLDR
This unification enhances schema-guided synthesis with features of proof planning, such as the use of heuristics and the separation between object-level and meta-level reasoning, and allows program schemas andHeuristics to be implemented as proof planning methods.

Synthesis of Programs in Computational Logic

TLDR
This paper analyzes and compares three state-of-the-art methods for synthesizing recursive programs in computational logic, constructive/deductive synthesis, schema-guided synthesis, and inductive synthesis and explores the synergies between the approaches.

An Abstract Programming System

TLDR
The system PL permits the translation of abstract proofs of program correctness into programs in a variety of programming languages, and permits reasoning about nonterminating programs using Scott-Strachey style denotational semantics.

Wellfounded Schematic Definitions

TLDR
This paper presents a simple and general way to define program schemes, based on a particular form of the wellfounded recursion theorem, and specifies a schematic induction theorem, which is automatically derived by formal proof from the well founded induction theorem.

Theorem Reuse by Proof Term Transformation

TLDR
This paper proposes an approach where theorems are generalised by abstracting their proofs from the original setting, based on a representation of proofs as logical framework proof terms, using the theorem prover Isabelle.

Evaluation of Knowledge, Skills and Competencies of Community-Based Child Growth Monitors and Promoters in Zambia

TLDR
The researchers determined that the CCGMPs had acquired acceptable levels of knowledge, but had compromised skills and competencies probably as a result of many possible factors including duration and methods of training process and shortage of equipment to use.

Structured Formal Development in Isabelle

TLDR
This paper presents a constructive approach to adding theory morphisms and parametrisation to theorem provers, while preserving the proof support and consistency of the prover.

References

SHOWING 1-10 OF 75 REFERENCES

Deriving and Applying Logic Program Transformers

TLDR
This work uses the Isabelle Logical Framework to formalize transformation templates as inference rules in higher-order logic and afterwards uses higher- order unification to apply them to develop programs in a deductive synthesis style.

Generic System Support for Deductive Program Development

TLDR
Within a conservative extension of higher-order logic implemented in the Isabelle system, rules for program development are derived that can simulate those of the deductive tableau proposed by Manna and Waldinger.

Logic Frameworks for Logic Programs

TLDR
It is shown how logical frameworks can provide a basis for logic program synthesis by using Paulson's Isabelle system to derive and use a simple synthesis calculus based on equivalence preserving transformations.

Representing Proof Transformations for Program Optimizations

TLDR
A method for implementing transformations of formal proofs and it is shown that it is applicable to the optimization of extracted programs, based on the representation of derived logical rules in Elf.

A framework for program development based on schematic proof

TLDR
It is proposed that calculi for manipulating and reasoning about programs should be implemented in logical frameworks that support this kind of proof construction and that such an implementation can unify program verification and synthesis.

The Synthesis of Logic Programs from Inductive Proofs

TLDR
To make the technique work it is necessary to synthesise pure logic programs, without the closed world assumption, and then compile these into Prolog programs.

Steps Toward Mechanizing Program Transformations Using PVS

  • N. Shankar
  • Computer Science
    Sci. Comput. Program.
  • 1996

Logic Program Synthesis and Transformation

  • Y. Deville
  • Computer Science
    Workshops in Computing
  • 1994
TLDR
In this framework, the distinction between specification, deductive synthesis and transformation and their inter-relationships is distinguished.

Fundamentals of Deductive Program Synthesis

TLDR
An informal tutorial for program synthesis is presented, with an emphasis on deductive methods, based on the deductive-tableau system, a theorem-proving framework particularly suitable forprogram synthesis.

Towards Stepwise, Schema-guided Synthesis of Logic Programms

TLDR
This work justifies some design choices for the development of a particular synthesis mechanism that is guided by a Divide-and-Conquer schema, is inductive and deductive, is interactive, and features a non-incremental presentation of examples.
...