Nabble - Mathematical Logics

Re: variable not found in the current environment

2009-12-16T07:10:50Z

Le Wed, 16 Dec 2009 15:19:58 +0100, Keiko Nakata
<keiko@...> a écrit:

> Hello,
>
> Trying to define a function with the Program command,
> I got an error
>
> The variable s0' was not found in the current environment.

This kind of error can occur in case you overwrite some variable,
coq doesn't do it and generate another variable with same prefix
(I bet you have a `s'` variable somewhere in your program).

Try the following:
------------------------------------
Definition truc (a : option bool) :=
match a with
| Some a => a = None
| None => a = Some true
end.
-------------------------------------
There is an obvious error, and the error is:
-------------------------------------
Error: In environment
a : option bool
a0 : bool
The term "None" has type "option ?13" while it is expected to have type
"bool".
-------------------------------------
as you can see, a variable a0 is created and doesn't appear in your
program;
in fact, coq rewrites your function in:
------------------------------------
Definition truc (a : option bool) :=
match a with
| Some a0 => a0 = None
| None => a = Some true
end.
-------------------------------------
with more complex definitions (for example with dependant types, this
error refers explicitly to a0)
-------------------------------------
Definition succ (n : nat) : {m : nat | m = S n } :=
match n as n return {m : nat | m = S n} with
| O => exist _ (S O) (refl_equal _)
| S n => exist _ (S n) (refl_equal _)
end.
-------------------------------------
returns an error with n0 which doesn't appear
-------------------------------------
Error: In environment
n : nat
n0 : nat
The term "exist ?72 (S n0) (eq_refl ?74)" has type "sig ?72"
while it is expected to have type "sig (fun m : nat => eq m (S (S n0)))".
--------------------------------------
With huge terms it is not easy to debug, renaming the overwritting
variables may be sufficient:
--------------------------------------
Definition succ (n : nat) : {m : nat | m = S n } :=
match n as n_return return {m : nat | m = S n_return} with
| O => exist _ (S O) (refl_equal _)
| S n_pred => exist _ (S n_pred) (refl_equal _)
end.
---------------------------------------
Now errors are clear.
It is sad, but these renaming are necessary, since the overwritten
variable cannot be generally
removed from environnement, as it may be used by other useful terms
defined before the overwritting.
What should be done is to inform in the error report that s0' comes from
s'.

But in your case if a variable is generated, it should be defined in the
environnement.
If you show us your code, maybe we can solve your problem.

This error may also be due to things I don't think of...

>
> But my code does not contain any occurrence of s0'.
> What would be my problem?
>
> I am not sure if this is relevant,
> but I am defining a corecursive function, i.e. Program CoFixpoint.
>
> Best,
> Keiko
>
> --------------------------------------------------------
> Bug reports: http://logical.saclay.inria.fr/coq-bugs
> Archives: http://pauillac.inria.fr/pipermail/coq-club
> http://pauillac.inria.fr/bin/wilma/coq-club
> Info: http://pauillac.inria.fr/mailman/listinfo/coq-club

--
Cédric AUGER

Univ Paris-Sud, Laboratoire LRI, UMR 8623, F-91405, Orsay

--------------------------------------------------------
Bug reports: http://logical.saclay.inria.fr/coq-bugs
Archives: http://pauillac.inria.fr/pipermail/coq-club
http://pauillac.inria.fr/bin/wilma/coq-club
Info: http://pauillac.inria.fr/mailman/listinfo/coq-club

From forum: Coq

Positions in theoretical computer science at Chalmers

2009-12-16T06:51:09Z

We invite theoretical computer scientists (with a PhD degree no more than 5 years old) to apply for two tenure-track assistant professorships in "basic science" at Chalmers University of Technology (deadline 1 February 2001):

http://www.chalmers.se/en/sections/about_chalmers/advance/job-positions-in/positions/two-assistant-professors

We also invite applications for PhD students in basic science (including theoretical computer science) at Chalmers University of Technology (deadline 15 February 2001):

http://www.chalmers.se/en/sections/about_chalmers/advance/job-positions-in/positions/5-phd-student-positions

Best regards,
Peter

--------------------------------------------------------
Bug reports: http://logical.saclay.inria.fr/coq-bugs
Archives: http://pauillac.inria.fr/pipermail/coq-club
http://pauillac.inria.fr/bin/wilma/coq-club
Info: http://pauillac.inria.fr/mailman/listinfo/coq-club

From forum: Coq

variable not found in the current environment

2009-12-16T06:19:58Z

Hello,

Trying to define a function with the Program command,
I got an error

The variable s0' was not found in the current environment.

But my code does not contain any occurrence of s0'.
What would be my problem?

I am not sure if this is relevant,
but I am defining a corecursive function, i.e. Program CoFixpoint.

Best,
Keiko

--------------------------------------------------------
Bug reports: http://logical.saclay.inria.fr/coq-bugs
Archives: http://pauillac.inria.fr/pipermail/coq-club
http://pauillac.inria.fr/bin/wilma/coq-club
Info: http://pauillac.inria.fr/mailman/listinfo/coq-club

From forum: Coq

CFP: International Workshop on Hybrid Logic and Applications (HyLo 2010)

2009-12-16T05:45:23Z

*******************************************************************
FIRST CALL FOR PAPERS
International Workshop on Hybrid Logic and Applications (HyLo 2010)
Affiliated with LICS 2010
July 10, 2010, Edinburgh, Scotland
*******************************************************************

Scope
-----
Hybrid logic is an extension of modal logic which allows us to refer
explicitly to states of the model in the syntax of formulas.
This extra capability, very natural in the realm of temporal logics,
where one usually wants to refer to specific times, has been shown
very effective in other domains too. Although they date back to the
late 1960s, and have been sporadically investigated ever since,
it was only in the 1990s that work on them really got into its stride.

It is easy to justify interest in hybrid logic on applied grounds,
with the usefulness of the additional expressive power.
For example, when reasoning about time one often wants to build up
a series of assertions about what happens at a particular instant,
and standard modal formalisms do not allow this. What is less obvious
is that the route hybrid logic takes to overcome this problem
(the basic mechanism being to add nominals - atomic symbols true
at a unique point - together with extra modalities to exploit them)
often actually improves the behaviour of the underlying modal formalism.
For example, it becomes far simpler to formulate modal tableau,
resolution, and natural deduction in hybrid logic, and completeness
and interpolation results can be proved of a generality that is
simply not available in modal logic. That is, hybridization -
adding nominals and related apparatus - seems a fairly reliable
way of curing many known weaknesses in modal logic.

Hybrid logic is now a mature field with significant impact on a range
of other fields, including

- description logic,
- applied modal logics,
- temporal logic,
- memory logics,
- memoryful logics,
- reactive logic,
- labelled deduction, and
- feature logic.

The topic of the HyLo workshop of 2010 is hybrid logic and its
applications, for instance within the fields mentioned above.
The scope is not only standard hybrid-logical machinery like nominals,
satisfaction operators, and the downarrow binder but, more generally,
extensions of modal logic that increase its expressive power.

The workshop continues a series of previous workshops on
hybrid logic and applications, for example the LICS-affiliated
HyLo 2002 (http://floc02.diku.dk/HYLO) and HyLo 2006
(http://hylomol.ruc.dk/HyLo2006) which both were held as part of FLoC.

Submissions
-----------
Please use the HyLo 2010 submission page to submit papers
(https://www.easychair.org/login.cgi?conf=hylo2010).
Papers should not exceed 15 pages including references.
The revised versions of accepted papers will be published online
in a volume of Elsevier Electronic Notes in Theoretical
Computer Science (ENTCS). A preliminary version of the proceedings
will be distributed at the workshop. Authors are invited to submit
papers in the following two categories:

- Regular papers describing original research.
- Presentation-only papers describing work recently published or submitted.

The presentation-only papers will be included in the preliminary
proceedings, but not in the final proceedings in ENTCS.
One author for each accepted paper must attend the workshop in order
to present the paper. Authors are strongly encouraged to prepare their
submissions according to the ENTCS guidelines (http://www.entcs.org).

Important Dates
---------------
Deadline for submissions: March 30, 2010
Notification of acceptance: May 1, 2010
Deadline for final versions: June 15, 2006

Invited Speakers
----------------
- Moshe Vardi, Rice University, USA
- NN

Program Committee
-----------------
Carlos Areces (INRIA Lorraine, France)
Patrick Blackburn (INRIA Lorraine, France)
Thomas Bolander (Technical University of Denmark), Co-chair
Torben Braüner (Roskilde University, Denmark), Co-chair
Stephane Demri (ENS de Cachan, France)
Mai Gehrke (Radboud Universiteit Nijmegen, The Netherlands)
Valentin Goranko (Technical University of Denmark)
Valeria de Paiva (Cuil Inc., USA)
Thomas Schneider (University of Manchester)

Contact Details
---------------
See the workshop home page (http://hylocore.ruc.dk/HyLo2010.html) for
further information. Please send all correspondence regarding the
workshop to the organizers:

Thomas Bolander
http://www.imm.dtu.dk/~tb

Torben Braüner
http://www.ruc.dk/~torben

--------------------------------------------------------
Bug reports: http://logical.saclay.inria.fr/coq-bugs
Archives: http://pauillac.inria.fr/pipermail/coq-club
http://pauillac.inria.fr/bin/wilma/coq-club
Info: http://pauillac.inria.fr/mailman/listinfo/coq-club

From forum: Coq

Re: information

2009-12-16T03:37:58Z

Hi,

Le 16 déc. 2009 à 12:22, Andrea Poles a écrit :

Fixpoint divide (a b:nat) {struct b} : bool :=
match lwt b a with
true => false
match a with
O => false
match b with
   a => true
   | _ => divide a minus(b a)
   end
end
end.

Divide should return true if b%a =0 false otherwise, but the Coqide
returns "Error: This clause is redundant." on this line:
   | _ => divide a minus(b a).

You are misunderstanding pattern-matching in the clause

a => true.

Here you want to test equality between a and b. You shoud use

a function testing equality between natural numbers. Like dec_eq_nat

defined in the library Peano_dec.

Here, the clause a => true matches all natural numbers; the fact that

there is another variable named a is irrelevant.

This way to handle pattern-matching is not specific to Coq but shared by

most functional languages (ML, Haskell, etc).

Benjamin

From forum: Coq

information

2009-12-16T03:22:54Z

Hi all, we need to prove the euclid theorem (on infitite primes) on
natural numbers.
We start writing some definitions and functions but we found many problems.
The divide function is not "compiling":
Require Import Arith.
Open Scope nat_scope.

Definition minus (n m : nat) := n-m.

Fixpoint lwt (n: nat) (m: nat) {struct n}: bool :=

match n with

O =>

match m with

O => false

| (S m1) => true

end

| (S n1) =>

match m with

O => false

| (S m1) => (lwt n1 m1)

end

end.

Fixpoint divide (a b:nat) {struct b} : bool :=
match lwt b a with
true => false
match a with
O => false
match b with
a => true
| _ => divide a minus(b a)
end
end
end.

Divide should return true if b%a =0 false otherwise, but the Coqide
returns "Error: This clause is redundant." on this line:
| _ => divide a minus(b a).

Do you know why? (consider that we are starting coq in theese days).
Is there anything ready-to-use to prove this theorem ?

Regards,
Andrea.

--------------------------------------------------------
Bug reports: http://logical.saclay.inria.fr/coq-bugs
Archives: http://pauillac.inria.fr/pipermail/coq-club
http://pauillac.inria.fr/bin/wilma/coq-club
Info: http://pauillac.inria.fr/mailman/listinfo/coq-club

From forum: Coq

LPAR-16 - Dakar, Senegal - April 2010

2009-12-15T05:01:15Z

CALL FOR PAPERS

LPAR-16

16th International Conference on Logic for
Programming, Artificial Intelligence and Reasoning

April 25 - May 1, 2010
Dakar, Senegal
http://www.lpar.net/lpar-16/

The series of International Conferences on Logic for Programming, Artificial
Intelligence and Reasoning (LPAR) is a forum where, year after year, some of
the most renowned researchers in the areas of logic, automated reasoning,
computational logic, programming languages and their applications come to
present cutting-edge results, to discuss advances in these fields, and to
exchange ideas in a scientifically emerging part of the world. The 16th
edition will be held in Dakar, Senegal.

Logic is a fundamental organizing principle in nearly all areas in Computer
Science. It runs a multifaceted gamut from the foundational to the applied.
At one extreme, it underlies computability and complexity theory and the
formal semantics of programming languages. At the other, it drives billions
of gates every day in the digital circuits of processors of all kinds. Logic
is in itself a powerful programming paradigm but it is also the quintessential
specification language for anything ranging from real-time critical systems
to networked infrastructures. Logical techniques link implementation and
specification through formal methods such as automated theorem proving and
model checking. Logic is also the stuff of knowledge representation and
artificial intelligence. Because of its ubiquity, logic has acquired a
central role in Computer Science education.

Topics
------
New results in the fields of computational logic and applications are welcome.
Also welcome are more exploratory presentations, which may examine open
questions and raise fundamental concerns about existing theories and practices.

Topics of interest include, but are not limited to:
* Automated reasoning
* Verification
* Interactive theorem proving and proof assistants
* Model checking
* Implementations of logic
* Satisfiability modulo theories
* Rewriting and unification
* Logic programming
* Satisfiability checking
* Constraint programming
* Decision procedures
* Logic and the Web
* Ontologies and large knowledge bases
* Logic and databases
* Modal and temporal logics
* Program analysis
* Foundations of security
* Description logics
* Non-monotonic reasoning
* Specification using logics
* Logic in artificial intelligence
* Logic and types
* Logical foundations of programming
* Logical aspects of concurrency
* Logic and computational complexity
* Knowledge representation and reasoning
* Logic of distributed systems

Programme Chairs
----------------
* Ed Clarke
* Andrei Voronkov

Programme Committee
-------------------
* Rajeev Alur
* Matthias Baaz
* Peter Baumgartner
* Armin Biere
* Nikolaj Bjorner
* Iliano Cervesato
* Agata Ciabattoni
* Hubert Comon-Lundh
* Nachum Dershowitz
* Juergen Giesl
* Guillem Godoy
* Georg Gottlob
* Jean Goubault-Larrecq
* Reiner Haehnle
* Claude Kirchner
* Michael Kohlhase
* Konstantin Korovin
* Laura Kovacs
* Orna Kupferman
* Leonid Libkin
* Aart Middeldorp
* Luke Ong
* Frank Pfenning
* Andreas Podelski
* Andrey Rybalchenko
* Helmut Seidl
* Geoff Sutcliffe
* Ashish Tiwari
* Toby Walsh
* Christoph Weidenbach

Submission Details
------------------
Submissions of two kinds are welcome:

* Regular papers containing new results;
* Experimental papers describing implementation or evaluation of systems.

All submitted papers must be original, and not submitted concurrently to a
journal or another conference. The page limit for all papers is 15 pages
using the EasyChair class file that can be obtained at ....
http://www.easychair.org/easychair.zip.

All papers must be submitted through the EasyChair system using the Web page

http://www.easychair.org/conferences/?conf=3Dlpar16

Important Dates
---------------
* Abstract submission: January 5, 2010
* Paper submission: January 12, 2010
* Notification of acceptance: March 1, 2010
* Proceedings version: March 15, 2010
* Short papers submission: March 17, 2010
* Short papers notification: March 25, 2010
* Conference: April 25-May 1, 2010

--------------------------------------------------------
Bug reports: http://logical.saclay.inria.fr/coq-bugs
Archives: http://pauillac.inria.fr/pipermail/coq-club
http://pauillac.inria.fr/bin/wilma/coq-club
Info: http://pauillac.inria.fr/mailman/listinfo/coq-club

From forum: Coq

VMCAI 2010 - Call for Participation - Early Reg: Dec 22

2009-12-13T17:20:37Z

----------------------------------------------------------------------
*** CALL FOR PARTICIPATION ***
[ Please redistribute. Apologies for multiple postings. ]

VMCAI 2010

The Eleventh International Conference on
Verification, Model Checking, and Abstract Interpretation

Madrid, Spain, January 17-19, 2010
(Co-located with POPL 2010)

http://software.imdea.org/events/vmcai10/

Early registration deadline: December 22, 2009
Hotel registration deadline: December 28, 2009
----------------------------------------------------------------------

VMCAI provides a forum for researchers from the communities of
Verification, Model Checking, and Abstract Interpretation,
facilitating interaction, cross-fertilization, and advancement of
hybrid methods. The program of VMCAI'10 will consist of invited
lectures, invited tutorials, and 21 contributed talks. The full
programme is available at the conference web site.

* Invited Talks:

Javier Esparza (Technical University of Munich):
Analysis of Systems with Stochastic Process Creation

Rustan Leino (Microsoft Research):
Verifying Concurrent Programs with Chalice

Reinhard Wilhelm (Saarland University):
Static Timing Analysis for Hard Real-Time Systems

* Invited Tutorials:

Roberto Giacobazzi (University of Verona):
Abstract Interpretation-based Protection

Joost Pieter Katoen (Aachen University):
Advances in Probabilistic Model Checking

Viktor Kuncak (EPFL Lausanne):
Building a Calculus of Data Structures

* Registration:

Further information on registration for VMCAI is available at the
conference web site: http://software.imdea.org/events/vmcai10/

Further information on accommodation is available at the POPL web
site: http://www.cse.psu.edu/popl/10/

* Program:

Sunday, January 17, 2010
9:00-10:00 Invited Talk

* Reinhardt Wilhelm (Saarland University)
Static Timing Analysis for Hard Real-Time Systems

Coffee break

10:30-11:30 Automata and Monitors

* RoLei Bu, Jianhua Zhao and Xuandong Li.
Path-Oriented Reachability Verification of a Class of Nonlinear
Hybrid Automata Using Convex Programming
* Meera Sridhar and Kevin Hamlen.
Model-Checking In-lined Reference Monitors

Coffee break

12.00-13.30 Abstract interpretation

* Liqian Chen, Antoine Mine, Ji Wang and Patrick Cousot.
An abstract domain for discovering interval linear equalities
* Valentin Perrelle and Nicolas Halbwachs.
An analysis of permutations in arrays
* Andy King and Harald Sondergaard.
Automatic Abstraction for Congruences

Lunch break

15.30-16.30 Model Checking

* Jori Dubrovin.
Checking Bounded Reachability in Asynchronous Systems by
Symbolic Event Tracing
* Benjamin Aminof, Orna Kupferman and Aniello Murano.
Improved Model Checking of Hierarchical Systems

Coffee break

17:00-18.30 Invited Tutorial

* Roberto Giaccobazzi (University of Verona)
Abstract Interpretation-based Protection

Monday, January 18, 2010

9.00-10.00 Invited Talk

* Rustan Leino (Microsoft Research)
Verifying Concurrent Programs with Chalice

Coffee break

10.30-11:30 Logical Methods

* Vijay D'silva, Daniel Kroening, Mitra Purandare and Georg Weissenbacher.
Interpolant Strength
* Kuat Yessenov, Ruzica Piskac and Viktor Kuncak.
Collections, Cardinalities, and Relations

Coffee break

12.00-13.30 Program Verification

* Alexander Summers and Sophia Drossopoulou.
A Considerate Specification of the Composite Pattern
* Thomas Henzinger, Thibaud B. Hottelier, Laura Kovacs and Andrei Voronkov.
Invariant and Type Inference for Matrices
* Yungbum Jung, Soonho Kong, Bow-Yaw Wang and Kwangkeun Yi.
Deriving Invariants in Propositional Logic by Algorithmic
Learning, Decision Procedure, and Predicate Abstraction

Lunch break

15.30-16.30 Quantitative Analysis

* Bjorn Wachter and Lijun Zhang.
Best Probabilistic Transformers
* Rohit Chadha, Axel Legay, Pavithra Prabhakar and Mahesh Viswanathan.
Complexity bounds for the verification of real-time software

Coffee break

17:00-18.30 Invited Tutorial

* Joost Pieter Katoen (University of Twente)
Advances in Probabilistic Model Checking

Tuesday, January 19, 2010

9.00-10.00 Invited Talk

* Javier Esparza (Technical University of Munich)
Analysis of Systems with Stochastic Process Creation

Coffee break

10.30-11:30 Temporal Logic

* Rajeev Alur and Swarat Chaudhuri.
Temporal Reasoning for Procedural Programs
* Cesar Sanchez and Martin Leucker.
Regular Linear Temporal Logic with Past

Coffee break

12.00-13.30 Shape Analysis

* Matthew Might.
Shape Analysis of Higher-Order Programs via Abstract Interpretation
* Mark Marron, Rupak Majumdar, Darko Stefanovic and Deepak Kapur.
Shape Analysis with Reference Set Relations
* Jorg Kreiker, Helmut Seidl and Vesal Vojdani.
Shape Analysis of Low-level C with Overlapping Structures

Lunch break

15.30-16.30 Concurrency

* Viktor Vafeiadis.
RGSep Action Inference
* Alexander Malkis, Shaz Qadeer and Shuvendu Lahiri.
Abstract Threads

Coffee break

17:00-18.30 Invited Tutorial

* Viktor Kuncak (EPF Lausanne)
Building a Calculus of Data Structures

----------------------------------------------------------------------

--------------------------------------------------------
Bug reports: http://logical.saclay.inria.fr/coq-bugs
Archives: http://pauillac.inria.fr/pipermail/coq-club
http://pauillac.inria.fr/bin/wilma/coq-club
Info: http://pauillac.inria.fr/mailman/listinfo/coq-club

From forum: Coq

International Workshop: DATICS-FutureTech'10 (EI Indexed)

2009-12-13T02:15:56Z

Dear Authors:

============================================================================
International Workshop: DATICS-FutureTech'10
CALL FOR PAPERS
http://digilander.libero.it/systemcfl/datics10-futuretech
Busan, South Korea, May 21-23, 2010
============================================================================

Aims and Scope of DATICS-FutureTech’10 Workshop:

DATICS Workshops were initially created by a network of researchers
and engineers both from academia and industry in the areas of Design,
Analysis and Tools for Integrated Circuits and Systems. Recently,
DATICS has been extended to the fields of Communication, Computer
Science, Software Engineering and Information Technology.
The main target of DATICS-FutureTech’10 is to bring together
software/hardware engineering researchers, computer scientists,
practitioners and people from industry to exchange theories, ideas,
techniques and experiences related to all aspects of DATICS.

Topics of interest include, but are not limited to, the following:

Circuits, Systems and Communications:
* digital, analog, mixed-signal, VLSI, asynchronous and RF design
* processor and memory
* DSP and FPGA/ASIC-based design
* synthesis and physical design
* embedded system hardware/software co-design
* CAD/EDA methodologies and tools
* statistical timing analysis and low power design methodologies
* network/system on-a-chip and applications
* hardware description languages, SystemC and SystemVerilog
* simulation, verification and test technology
* semiconductor devices and solid-state circuits
* fuzzy and neural networks
* communication signal processing
* mobile and wireless communications
* multimedia communications

Computer Science, Software Engineering and Information Technology:
* equivalence checking, model checking, SAT-based methods,
compositional methods and probabilistic methods
* graph theory, process algebras, petri-nets, automaton theory, BDDs and UML
* formal methods
* distributed, real-time and hybrid systems
* reversible computing and biocomputing
* software architecture and design
* software testing and analysis
* software dependability, safety and reliability
* programming languages, tools and environments
* face detection and recognition
* database and data mining
* image and video processing
* watermarking
* artificial intelligence
* average-case analysis and worst-case analysis
* design and programming methodologies for network protocols and
applications
* coding, cryptography algorithms and security protocols
* evolutionary computation
* numerical algorithms

Please note that all accepted papers will be included in IEEE Xplore
and indexed by EI Compendex.
After workshop, several special issues of international journals such
Journal of Supercomputing, JIT, IJITCC and IJDATICS will be arranged
for selected papers.

For more details about DATICS-FutureTech'10, please visit
http://digilander.libero.it/systemcfl/datics10-futuretech.

--------------------------------------------------------
Bug reports: http://logical.saclay.inria.fr/coq-bugs
Archives: http://pauillac.inria.fr/pipermail/coq-club
http://pauillac.inria.fr/bin/wilma/coq-club
Info: http://pauillac.inria.fr/mailman/listinfo/coq-club

From forum: Coq

Properties on mutual definitions

2009-12-10T08:30:49Z

Thanks, to all. :)

The last two ideas from Cédric work for me and I decided to use the "trick", since I do not want to change my definitions.

So long,
Thomas

--------------------------------------------------------
Bug reports: http://logical.saclay.inria.fr/coq-bugs
Archives: http://pauillac.inria.fr/pipermail/coq-club
http://pauillac.inria.fr/bin/wilma/coq-club
Info: http://pauillac.inria.fr/mailman/listinfo/coq-club

From forum: Coq

Re: Properties on mutual definitions

2009-12-10T01:52:06Z

(* please, remove me when you "reply all" as I am already in
coq-club@...,
I need only one exemplar of this mail;
I know, this mailing list is not the best configured one... *)

(* Le Wed, 09 Dec 2009 22:55:49 +0100, Thomas Thüm
<thomas.thuem@...> a écrit:

> Thanks for your answers. I cannot imagine how to use your ideas, when f
> and
> g do not relate exactly identical expressions.
>
>> For simplicity, only identical expression (lists of expressions) are in
> the relation f (g).
>
> Let me describe, how I would prove my theorem in informal math.
>
> Assume, we want to prove the two theorems A and B, where f and g are
> defined
> mutually inductive.
>
> A: forall a, exists a', f a a'
> B: forall l, exists l', g l l'
>
> First, I would prove A by assuming B using induction on a.
>
> Second, I would prove B by assuming A using induction on l.

*)

Require Export List.

Inductive exp : Type :=
| e_var : nat -> exp
| e_meth : exp -> nat -> list_exp -> exp
with list_exp : Type :=
| nil : list_exp
| cons : exp -> list_exp -> list_exp.

(* For simplicity, only identical expression (lists of expressions) are in
the relation f (g). *)

Inductive f : exp -> exp -> Prop :=
| f_var : forall n,
f (e_var n) (e_var n)
| f_meth : forall a a' l l' n,
f a a' ->
g l l' ->
f (e_meth a n l) (e_meth a' n l')

with g : list_exp -> list_exp -> Prop :=
| g_nil :
g nil nil
| g_cons : forall a a' l l',
f a a' ->
g l l' ->
g (cons a l) (cons a' l').

Fact totalf :
forall a, exists a', f a a'
with totalg :
forall l, exists l', g l l'.
Proof.
destruct a as [n|a n l].
exists (e_var n); left.
destruct (totalf a) as [a' Ha].
destruct (totalg l) as [l' Hl].
exists (e_meth a' n l').
exact (f_meth a a' l l' n Ha Hl).
(**)
destruct l as [|a l].
exists nil; left.
destruct (totalf a) as [a' Ha].
destruct (totalg l) as [l' Hl].
exists (cons a' l').
exact (g_cons a a' l l' Ha Hl).
Qed.

(*
> My question is, how do I do this in Coq? (The "Fact ... with ..." looks
> pretty close to what I need, but I couldn't get it working without a=a'
> and
> l=l'.)
>
> Thomas
>

I had to modify the Inductive exp, to tell Coq that list_exp and exp are
structurally related,
thing that the Fact ... with ... . doesn't infer.

> --------------------------------------------------------
> Bug reports: http://logical.saclay.inria.fr/coq-bugs
> Archives: http://pauillac.inria.fr/pipermail/coq-club
> http://pauillac.inria.fr/bin/wilma/coq-club
> Info: http://pauillac.inria.fr/mailman/listinfo/coq-club
*)

(* another way is to make induction "by hand" which needs well
understanding of the induction mechanism, since you don't rely
on automatically guardedness of the "induction" tactic
(that is, if you are not cautious, the proof can fail when you call "Qed")
*)

Require Export List.

Inductive exp : Type :=
| e_var : nat -> exp
| e_meth : exp -> nat -> list exp -> exp.

(* For simplicity, only identical expression (lists of expressions) are in
the relation f (g). *)

Inductive f : exp -> exp -> Prop :=
| f_var : forall n,
f (e_var n) (e_var n)
| f_meth : forall a a' l l' n,
f a a' ->
g l l' ->
f (e_meth a n l) (e_meth a' n l')

with g : list exp -> list exp -> Prop :=
| g_nil :
g nil nil
| g_cons : forall a a' l l',
f a a' ->
g l l' ->
g (cons a l) (cons a' l').

Definition g_trick (REC : forall a, exists a', f a a') :
forall (l : list exp), exists l', g l l'.
Proof.
intro H.
induction l.
eexists; left.
destruct IHl; destruct (H a).
eexists; right; eassumption.
Defined.
(* Note the trick to keep transparent, necessary for a good induction *)

Fact totalf : forall a, exists a', f a a'.
Proof.
refine (fix totalf (a : exp) := _); destruct a.
eexists; left.
destruct (g_trick totalf l). (* g_trick totalf is totalg, see later *)
destruct (totalf a).
eexists; right; eassumption.
Qed.

Fact totalg : forall l, exists l', g l l'.
Proof.
exact (g_trick totalf). (* g_trick totalf can be used as totalg, see
sooner *)
Qed.

(* so for this case, I assume that Scheme is not a bad idea;
but the Scheme pros will tell you more about it than I *)

(*
--
Cédric AUGER

Univ Paris-Sud, Laboratoire LRI, UMR 8623, F-91405, Orsay
*)

--------------------------------------------------------
Bug reports: http://logical.saclay.inria.fr/coq-bugs
Archives: http://pauillac.inria.fr/pipermail/coq-club
http://pauillac.inria.fr/bin/wilma/coq-club
Info: http://pauillac.inria.fr/mailman/listinfo/coq-club

From forum: Coq

Re: Properties on mutual definitions

2009-12-09T14:23:50Z

Thomas Thüm wrote:

> Assume, we want to prove the two theorems A and B, where f and g are defined
> mutually inductive.
>
> A: forall a, exists a', f a a'
> B: forall l, exists l', g l l'
>
> First, I would prove A by assuming B using induction on a.
>
> Second, I would prove B by assuming A using induction on l.
>
> My question is, how do I do this in Coq?

I think you are looking for nested induction, as described here:
http://adam.chlipala.net/cpdt/html/InductiveTypes.html#lab28

--------------------------------------------------------
Bug reports: http://logical.saclay.inria.fr/coq-bugs
Archives: http://pauillac.inria.fr/pipermail/coq-club
http://pauillac.inria.fr/bin/wilma/coq-club
Info: http://pauillac.inria.fr/mailman/listinfo/coq-club

From forum: Coq

Properties on mutual definitions

2009-12-09T13:55:49Z

Thanks for your answers. I cannot imagine how to use your ideas, when f and
g do not relate exactly identical expressions.

> For simplicity, only identical expression (lists of expressions) are in
the relation f (g).

Let me describe, how I would prove my theorem in informal math.

Assume, we want to prove the two theorems A and B, where f and g are defined
mutually inductive.

A: forall a, exists a', f a a'
B: forall l, exists l', g l l'

First, I would prove A by assuming B using induction on a.

Second, I would prove B by assuming A using induction on l.

My question is, how do I do this in Coq? (The "Fact ... with ..." looks
pretty close to what I need, but I couldn't get it working without a=a' and
l=l'.)

Thomas

--------------------------------------------------------
Bug reports: http://logical.saclay.inria.fr/coq-bugs
Archives: http://pauillac.inria.fr/pipermail/coq-club
http://pauillac.inria.fr/bin/wilma/coq-club
Info: http://pauillac.inria.fr/mailman/listinfo/coq-club

From forum: Coq

Re: Properties on mutual definitions

2009-12-09T13:32:20Z

On Wed, Dec 9, 2009 at 7:36 AM, Thomas Thüm <thomas.thuem@...> wrote:
> You are right. How do I solve it?

I think the key thing here is that the proof you were using was an
existence proof. That has to be strengthened before it can be easily
proved. What you need is this:

(forall a : exp, f a a) /\ (forall l : list exp, g l l).

--
Taral <taralx@...>
"Please let me know if there's any further trouble I can give you."
-- Unknown

--------------------------------------------------------
Bug reports: http://logical.saclay.inria.fr/coq-bugs
Archives: http://pauillac.inria.fr/pipermail/coq-club
http://pauillac.inria.fr/bin/wilma/coq-club
Info: http://pauillac.inria.fr/mailman/listinfo/coq-club

From forum: Coq

Re: Properties on mutual definitions

2009-12-09T12:32:49Z

muad wrote:

> I just have to suggest this alternative way to prove it.
>
>
> Ltac mark H := let T := type of H in change (id T) in H.
> Ltac unmark := unfold id in *.
>
> Fact totalf {a a'} (F : f a a') : a = a'
> with totalg {l l'} (G : g l l') : l = l'.
> Proof.
>
> Ltac information f f' := repeat match goal with F : f _ _ |- _ => pose (f'
> _ _ F); mark F end.
>
> intros; destruct F; information f totalf; information g totalg;
> congruence.
> intros; destruct G; information f totalf; information g totalg;
> congruence.
>

The theorem doesn't seem to need so complex a proof.

Scheme f_mut := Minimality for f Sort Prop
with g_mut := Minimality for g Sort Prop.
Combined Scheme fg_mut from f_mut, g_mut.

Fact total :
(forall a a', f a a' -> a = a')
/\ (forall l l', g l l' -> l = l').
apply fg_mut; intros; subst; reflexivity.
Qed.

--------------------------------------------------------
Bug reports: http://logical.saclay.inria.fr/coq-bugs
Archives: http://pauillac.inria.fr/pipermail/coq-club
http://pauillac.inria.fr/bin/wilma/coq-club
Info: http://pauillac.inria.fr/mailman/listinfo/coq-club

From forum: Coq

Re: Properties on mutual definitions

2009-12-09T11:53:48Z

I just have to suggest this alternative way to prove it.

Ltac mark H := let T := type of H in change (id T) in H.
Ltac unmark := unfold id in *.

Fact totalf {a a'} (F : f a a') : a = a'
with totalg {l l'} (G : g l l') : l = l'.
Proof.

Ltac information f f' := repeat match goal with F : f _ _ |- _ => pose (f' _ _ F); mark F end.

intros; destruct F; information f totalf; information g totalg; congruence.
intros; destruct G; information f totalf; information g totalg; congruence.

Qed.

From forum: Coq

Re: Sets in Coq

2009-12-09T11:30:58Z

Dear Christian Doczkal,
I did something like this. See the files at the top of the
page
http://math.unice.fr/~carlos/themes/verif.html

The project is explained in some preprints and papers:

---Explaining Gabriel-Zisman localization to the computer
Journal of Automated Reasoning, Volume 36 number 3
(2006), 259 - 285

---Files for Gabriel-Zisman localization , arXiv:math/0506470

---Set-theoretical mathematics in Coq , arXiv:math/0402336

A more in-depth study has recently been done by Jose Grimm, see:
J. Grimm,
Implementation of Bourbaki's Elements of Mathematics in Coq: Part One, Theory
of Sets,
HAL : inria-00408143, version 2

---Carlos Simpson
http://hal.archives-ouvertes.fr/inria-00408143/

Selon Christian Doczkal <doczkal@...>:

> Hello
>
> I'm planning some development with uses sets in various places and my
> (preliminary) experience is that the Sets libraries that ship with Coq
> are somewhat cumbersome to work with.
>
> Has anyone used this for some (larger) development? I'm not overly
> worried about having to assume classical logic and various
> extensionality axioms. I'm more interested in increased automation for
> the set reasoning part.
>
> The tactic "eauto with sets" only works in relatively few cases, even
> after including Finete_sets_faacts which in turn exports almost about
> the whole library on sets.
>
> (Notation is also not an issue, this I have taken care of)
>
> --
> Regards
> Christian Doczkal
>
> --------------------------------------------------------
> Bug reports: http://logical.saclay.inria.fr/coq-bugs
> Archives: http://pauillac.inria.fr/pipermail/coq-club
> http://pauillac.inria.fr/bin/wilma/coq-club
> Info: http://pauillac.inria.fr/mailman/listinfo/coq-club
>

--------------------------------------------------------
Bug reports: http://logical.saclay.inria.fr/coq-bugs
Archives: http://pauillac.inria.fr/pipermail/coq-club
http://pauillac.inria.fr/bin/wilma/coq-club
Info: http://pauillac.inria.fr/mailman/listinfo/coq-club

From forum: Coq

Re: Properties on mutual definitions

2009-12-09T09:10:13Z

(* As replied by Adam, you want to produce and not to consume.
Furthermore, as I show below, you have not a lot of choice in your
production
(only identity works), and what you wanted to produce cannot be produced
the way you thought as "exists l', g l l'" can never be structuraly
inferior
to "f a a'", as you break the induction by the introduction of the
"exists".

Here is maybe what you wanted to have.

I never use Scheme or Combined Scheme (but I don't have opinions on
whether
it is a good way or not to have
mutual
induction),
and I think that (when it is possible) using mutual Lemma is often a
simpler
to do what you want (I recognize it is not always the case as it is less
powerful than Scheme & co.),
as shown here.
*)

Require Export List.

Inductive exp : Type :=
| e_var : nat -> exp
| e_meth : exp -> nat -> list exp -> exp.

(* For simplicity, only identical expression (lists of expressions) are in
the relation f (g). *)

Inductive f : exp -> exp -> Prop :=
| f_var : forall n,
f (e_var n) (e_var n)
| f_meth : forall a a' l l' n,
f a a' ->
g l l' ->
f (e_meth a n l) (e_meth a' n l')

with g : list exp -> list exp -> Prop :=
| g_nil :
g nil nil
| g_cons : forall a a' l l',
f a a' ->
g l l' ->
g (a::l) (a'::l').

Fact totalf :
forall a a', f a a' -> a = a'
with totalg :
forall l l', g l l' -> l = l'.
Proof.
(* the totalf proof *)
intros a a' H; destruct H as [n | a a' l l' n Ha Hl].
reflexivity.
rewrite (totalf a a' Ha).
rewrite (totalg l l' Hl).
reflexivity.
(* the totalg proof *)
intros l l' H; destruct H as [| a a' l l' Ha Hl].
reflexivity.
rewrite (totalf a a' Ha).
rewrite (totalg l l' Hl).
reflexivity.
Qed.
(*
Le Wed, 09 Dec 2009 12:26:50 +0100, Thomas Thüm <thomas.thuem@...>
a écrit:

> Hi all,
>
> I was wondering how to create a useful induction principle to prove
> properties on mutual definitions. It is clear how to generate induction
> principles for mutual definitions, but I cannot apply them in my case. I
> could imagine to write an induction principle by hand, but hopefully
> there
> is an automatic way?
>
> Thanks,
> Thomas
>
> -----
>
> Require Export List.
>
> Inductive exp : Type :=
> | e_var : nat -> exp
> | e_meth : exp -> nat -> list exp -> exp.
>
> (* For simplicity, only identical expression (lists of expressions) are
> in
> the relation f (g). *)
>
> Inductive f : exp -> exp -> Prop :=
> | f_var : forall n,
> f (e_var n) (e_var n)
> | f_meth : forall a a' l l' n,
> f a a' ->
> g l l' ->
> f (e_meth a n l) (e_meth a' n l')
>
> with g : list exp -> list exp -> Prop :=
> | g_nil :
> g nil nil
> | g_cons : forall a a' l l',
> f a a' ->
> g l l' ->
> g (a::l) (a'::l').
>
> Scheme f_ind2 := Minimality for f Sort Prop
> with g_ind2 := Minimality for g Sort Prop.
> Combined Scheme fg_mutind from f_ind2, g_ind2.
>
> Fact total :
> ( forall a, exists a', f a a' ) /\
> ( forall l, exists l', g l l' ).
> Proof.
>
> (* fg_mutind cannot be applied... *)
>
> --------------------------------------------------------
> Bug reports: http://logical.saclay.inria.fr/coq-bugs
> Archives: http://pauillac.inria.fr/pipermail/coq-club
> http://pauillac.inria.fr/bin/wilma/coq-club
> Info: http://pauillac.inria.fr/mailman/listinfo/coq-club

--
Cédric AUGER

Univ Paris-Sud, Laboratoire LRI, UMR 8623, F-91405, Orsay
*)

--------------------------------------------------------
Bug reports: http://logical.saclay.inria.fr/coq-bugs
Archives: http://pauillac.inria.fr/pipermail/coq-club
http://pauillac.inria.fr/bin/wilma/coq-club
Info: http://pauillac.inria.fr/mailman/listinfo/coq-club

From forum: Coq

Re: Sets in Coq

2009-12-09T09:04:19Z

In my opinion the type "Set" in Coq is redundant. So if you plan to develop such a library it is much more useful to do it for Type.

Vladimir.

On Dec 9, 2009, at 10:46 AM, Christian Doczkal wrote:

From forum: Coq

Re: Sets in Coq

2009-12-09T08:35:05Z

Christian Doczkal wrote:
> I'm planning some development with uses sets in various places and my
> (preliminary) experience is that the Sets libraries that ship with Coq
> are somewhat cumbersome to work with.
>
> Has anyone used this for some (larger) development? I'm not overly
> worried about having to assume classical logic and various
> extensionality axioms. I'm more interested in increased automation for
> the set reasoning part.
>

I don't know if anyone has implemented one for Coq yet, but there are
some very effective automated decision procedures for set expressions.
It's pretty straightforward to reduce most relations between sets (e.g.,
subset) into statements about membership of abstract elements in sets,
and then, applying the definitions of set operators, you quickly arrive
at formulas that standard SAT and SMT solvers can discharge quickly.

--------------------------------------------------------
Bug reports: http://logical.saclay.inria.fr/coq-bugs
Archives: http://pauillac.inria.fr/pipermail/coq-club
http://pauillac.inria.fr/bin/wilma/coq-club
Info: http://pauillac.inria.fr/mailman/listinfo/coq-club

From forum: Coq

Re: Modules and Inductive types

2009-12-09T08:33:21Z

Le Wed, 09 Dec 2009 16:36:27 +0100, Christian Doczkal
<doczkal@...> a écrit:

> I just stumbled across the following:
>
> Module Type S.
> Parameter X : Type.
> End S.
>
> Module False : S.
> Inductive X := .
> End False.
>
> (* Error: The kernel does not recognize yet that a parameter can be
> instantiated by an inductive type. Hint: you can rename the inductive
> type and give a definition to map the old name to the new name. *)
>
> (* Of course one can circumvent the problem like this, but it removes a
> lot of the structuring effect one would like Modules to have ...
>
> Inductive FalseT : Type := .
>
> Module FT : S.
> Definition X := FalseT.
> Definition R := @eq FalseT.
> End FT.

>
> Is there any work being done on the subject?
> Are there any theoretical issues?
>
I agree with you that the False module should be accepted;
about the structuring, it is not clear that it is really a problem.

Module FT : S.
Inductive FalseT : Type := .
Definition X := FalseT.
Definition R := @eq FalseT.
End FT.

Note that you won't be able to acces the R field... as it doesn't appear
in the signature of S.

If you want to know the structure of X outside FT (for your structuring
problems), use rather:

Module FT : S with Definition X := FalseT.
Definition X := FalseT.
Definition R := @eq FalseT.
End FT.

--
Cédric AUGER

Univ Paris-Sud, Laboratoire LRI, UMR 8623, F-91405, Orsay

--------------------------------------------------------
Bug reports: http://logical.saclay.inria.fr/coq-bugs
Archives: http://pauillac.inria.fr/pipermail/coq-club
http://pauillac.inria.fr/bin/wilma/coq-club
Info: http://pauillac.inria.fr/mailman/listinfo/coq-club

From forum: Coq

Re: Modules and Inductive types

2009-12-09T07:47:58Z

Hi Christian,

Try:

Module Type S.

Parameter X : Type.
End S.

Module False : S.
Inductive XX := .

Definition X := XX.
End False.

That's what the hint was trying to tell you, I think.

Cheers,

Adam

On Wed, Dec 9, 2009 at 16:36, Christian Doczkal <doczkal@...> wrote:

I just stumbled across the following:

Module Type S.
Parameter X : Type.
End S.

Module False : S.
Inductive X := .
End False.

(* Error: The kernel does not recognize yet that a parameter can be
instantiated by an inductive type. Hint: you can rename the inductive
type and give a definition to map the old name to the new name. *)

(* Of course one can circumvent the problem like this, but it removes a
lot of the structuring effect one would like Modules to have ...

Inductive FalseT : Type := .

Module FT : S.
Definition X := FalseT.
Definition R := @eq FalseT.
End FT.

Is there any work being done on the subject?
Are there any theoretical issues?

--
Regards
Christian Doczkal

--------------------------------------------------------
Bug reports: http://logical.saclay.inria.fr/coq-bugs
Archives: http://pauillac.inria.fr/pipermail/coq-club
http://pauillac.inria.fr/bin/wilma/coq-club
Info: http://pauillac.inria.fr/mailman/listinfo/coq-club

--
Adam Koprowski [http://www.cs.ru.nl/~Adam.Koprowski]
R&D @ MLstate [15 rue Berlier, 75013 Paris, France]

From forum: Coq

Sets in Coq

2009-12-09T07:46:06Z

Hello

I'm planning some development with uses sets in various places and my
(preliminary) experience is that the Sets libraries that ship with Coq
are somewhat cumbersome to work with.

Has anyone used this for some (larger) development? I'm not overly
worried about having to assume classical logic and various
extensionality axioms. I'm more interested in increased automation for
the set reasoning part.

The tactic "eauto with sets" only works in relatively few cases, even
after including Finete_sets_faacts which in turn exports almost about
the whole library on sets.

(Notation is also not an issue, this I have taken care of)

--
Regards
Christian Doczkal

--------------------------------------------------------
Bug reports: http://logical.saclay.inria.fr/coq-bugs
Archives: http://pauillac.inria.fr/pipermail/coq-club
http://pauillac.inria.fr/bin/wilma/coq-club
Info: http://pauillac.inria.fr/mailman/listinfo/coq-club

From forum: Coq

Re: Properties on mutual definitions

2009-12-09T07:36:42Z

You are right. How do I solve it?

--------------------------------------------------------
Bug reports: http://logical.saclay.inria.fr/coq-bugs
Archives: http://pauillac.inria.fr/pipermail/coq-club
http://pauillac.inria.fr/bin/wilma/coq-club
Info: http://pauillac.inria.fr/mailman/listinfo/coq-club

From forum: Coq

Modules and Inductive types

2009-12-09T07:36:27Z

I just stumbled across the following:

Module Type S.
Parameter X : Type.
End S.

Module False : S.
Inductive X := .
End False.

(* Error: The kernel does not recognize yet that a parameter can be
instantiated by an inductive type. Hint: you can rename the inductive
type and give a definition to map the old name to the new name. *)

(* Of course one can circumvent the problem like this, but it removes a
lot of the structuring effect one would like Modules to have ...

Inductive FalseT : Type := .

Module FT : S.
Definition X := FalseT.
Definition R := @eq FalseT.
End FT.

Is there any work being done on the subject?
Are there any theoretical issues?

--
Regards
Christian Doczkal

--------------------------------------------------------
Bug reports: http://logical.saclay.inria.fr/coq-bugs
Archives: http://pauillac.inria.fr/pipermail/coq-club
http://pauillac.inria.fr/bin/wilma/coq-club
Info: http://pauillac.inria.fr/mailman/listinfo/coq-club

From forum: Coq

Re: Properties on mutual definitions

2009-12-09T07:26:26Z

Thomas Thüm wrote:

> Scheme f_ind2 := Minimality for f Sort Prop
> with g_ind2 := Minimality for g Sort Prop.
> Combined Scheme fg_mutind from f_ind2, g_ind2.
>
> Fact total :
> ( forall a, exists a', f a a' ) /\
> ( forall l, exists l', g l l' ).
> Proof.
>
> (* fg_mutind cannot be applied... *)
>

This doesn't look like an opportunity to apply induction over [f] or
[g], even in informal math. An induction principle _consumes_ an object
of its associated type, while here you want to _produce_ such an object.

--------------------------------------------------------
Bug reports: http://logical.saclay.inria.fr/coq-bugs
Archives: http://pauillac.inria.fr/pipermail/coq-club
http://pauillac.inria.fr/bin/wilma/coq-club
Info: http://pauillac.inria.fr/mailman/listinfo/coq-club

From forum: Coq

RE: Reset Induction Principle

2009-12-09T04:18:50Z

Try using Unset Elimination Schemes (8.14.1 in the manual) instead.

Cheers.

From: coq-club-admin@... [mailto:coq-club-admin@...] On Behalf Of Qiang Liu
Sent: 09 December 2009 01:39
To: coq-club@...
Subject: [Coq-Club] Reset Induction Principle

Hello, everyone:

i defined a inductive type, like : Inductive Term : Set. However, i do not want to use the induction principle Term_ind, because it is too weak. So how can i reset it in the CoqIDE ?

ps: I tried the command Reset, it says: Use CoqIDE navigation instead!

Thanks

From forum: Coq

Properties on mutual definitions

2009-12-09T03:26:50Z

Hi all,

I was wondering how to create a useful induction principle to prove
properties on mutual definitions. It is clear how to generate induction
principles for mutual definitions, but I cannot apply them in my case. I
could imagine to write an induction principle by hand, but hopefully there
is an automatic way?

Thanks,
Thomas

-----

Require Export List.

Inductive exp : Type :=
| e_var : nat -> exp
| e_meth : exp -> nat -> list exp -> exp.

(* For simplicity, only identical expression (lists of expressions) are in
the relation f (g). *)

Inductive f : exp -> exp -> Prop :=
| f_var : forall n,
f (e_var n) (e_var n)
| f_meth : forall a a' l l' n,
f a a' ->
g l l' ->
f (e_meth a n l) (e_meth a' n l')

with g : list exp -> list exp -> Prop :=
| g_nil :
g nil nil
| g_cons : forall a a' l l',
f a a' ->
g l l' ->
g (a::l) (a'::l').

Scheme f_ind2 := Minimality for f Sort Prop
with g_ind2 := Minimality for g Sort Prop.
Combined Scheme fg_mutind from f_ind2, g_ind2.

Fact total :
( forall a, exists a', f a a' ) /\
( forall l, exists l', g l l' ).
Proof.

(* fg_mutind cannot be applied... *)

--------------------------------------------------------
Bug reports: http://logical.saclay.inria.fr/coq-bugs
Archives: http://pauillac.inria.fr/pipermail/coq-club
http://pauillac.inria.fr/bin/wilma/coq-club
Info: http://pauillac.inria.fr/mailman/listinfo/coq-club

From forum: Coq

Call for Papers: ICLP 2010

2009-12-09T01:49:46Z

[Sorry, in case of multiple postings]

------------------------------------------------------------------------
CALL FOR PAPERS
26th International Conference on Logic Programming (ICLP 2010)

Edinburgh, Scotland, U.K., July 16-19, 2010
ICLP 2009 will be held as part of the
Fifth Federated Logic Conference (FLoC 2010)
Submission deadline: January 26, 2010

http://www.floc-conference.org/ICLP-home.html
----------------------------------------------------------------------

CONFERENCE SCOPE

Since the first conference held in Marseilles in 1982, ICLP has been
the premier international conference for presenting research in logic
programming. Contributions (papers and posters) are sought in all
areas of logic programming including but not restricted to:

Theory: Semantic Foundations, Formalisms, Non-monotonic Reasoning,
Knowledge Representation.
Implementation: Compilation, Memory Management, Virtual Machines,
Parallelism.
Environments: Program Analysis, Transformation, Validation,
Verification, Debugging, Profiling, Testing.
Language Issues: Concurrency, Objects, Coordination, Mobility, Higher
Order, Types, Modes, Assertions, Programming Techniques.
Related Paradigms: Abductive Logic Programming, Inductive Logic
Programming, Constraint Logic Programming, Answer-Set Programming.
Applications: Databases, Data Integration and Federation, Software
Engineering, Natural Language Processing, Web and Semantic Web,
Agents, Artificial Intelligence, Bioinformatics.

In addition to the presentations of accepted papers, the technical
program will include plenary invited talks in association with other
FLoC conferences, as well as ICLP invited talks, advanced tutorials,
the doctoral consortium, and several workshops.

SUBMISSION DETAILS

The four broad categories for submissions are: (1) technical papers
for describing technically sound, innovative ideas that can advance
the state of the art of logic programming; (2) application papers,
where the emphasis will be on their impact on the application domain;
(3) system and tool papers, where the emphasis will be on the novelty,
practicality, usability and general availability of the systems and
tools described; and (4) short papers/posters, for ongoing work not
yet ready for full publication and research project overviews.

All papers must describe original, previously unpublished
research, and must not simultaneously be submitted for publication
elsewhere. They must be written in English. Technical papers,
application papers, and system and tool papers must not exceed 15
pages. The limit for short papers / posters is 5 pages. Submissions
must be made in TPLP format
(ftp://ftp.cup.cam.ac.uk/pub/texarchive/journals/latex/tlp-cls/) via
the Easychair submission system, available at
http://www.easychair.org/conferences/?conf=iclp2010.

IMPORTANT DATES
Paper registration deadline: January 26, 2010
Submission deadline: February 2, 2010
Notification to authors: March 20, 2010
Camera-ready copy due: April 21, 2010
Conference: July 16-19, 2010

PAPER PUBLICATION

All accepted long papers will be published in the journal Theory and
Practice of Logic Programming (TPLP), Cambridge U. Press (CUP), in one
or more special issues.

In order to ensure the quality of the final version, papers may be
subject to more than one round of refereeing (within the decision
period) and/or "shepherding."

At the time of the conference CUP will make the web page for
this(ese) TPLP issue(s) available including volume and issue numbers,
table of contents, page numbers, and the papers themselves. All
registered attendants at the conference will get a password for
on-line access to this web page during the conference and indefinitely
from then on ("lifetime access"), which can be used to read papers on
line, download them, or print them for personal use. Attendants will
also receive all the papers in a USB memory stick at the conference.

For short papers / posters the journal issue(s) will include a
listing of the titles and authors of these papers, as well as a URL
pointing to their printable copy. Short papers / posters will also get
space in the program for presentation.

ICLP'2010 ORGANIZATION

General Chair:
Veronica Dahl (Simon Fraser University, Canada)
Program Co-chairs:
Manuel Hermenegildo (IMDEA Soft. and UPM, Spain)
Torsten Schaub (University of Potsdam, Germany)
Workshops Chair:
Veronica Dahl (Simon Fraser University, Canada)
Doctoral Consortium:
Marcello Balduccini (Kodak Research Labs, USA)
Prolog Programming Contest:
Tom Schrijvers (K.U. Leuven, Belgium)

PROGRAM COMMITTEE

Maria Alpuente (Technical U. of Valencia, Spain)
Pedro Cabalar (Corunya University, Spain)
Manuel Carro (Technical U. of Madrid, Spain)
Marina De Vos (University of Bath, UK)
James Delgrande (Simon Fraser University, Canada)
Marc Denecker (KU Leuven, Belgium)
Agostino Dovier (University of Udine, Italy)
Esra Erdem (Sabanci University, Istanbul, Turkey)
Wolfgang Faber (University of Calabria, Italy)
Thom Fruehwirth (University of Ulm, Germany)
Maurizio Gabbrielli (University of Bologna, Italy)
John Gallagher (Roskilde University, Denmark)
Samir Genaim (Complutense University, Spain)
Haifeng Guo (University of Nebraska at Omaha, USA)
Joxan Jaffar (National U. of Singapore, Singapore)
Tomi Janhunen (Helsinki U. of Technology, Finland)
Michael Leuschel (U. of Duesseldorf, Germany)
Stephen Muggleton (Imperial College London, UK)
Alan Mycroft (U. of Cambridge, UK)
Gopalan Nadathur (University of Minnesota, USA)
Lee Naish (Melbourne University, Australia)
Enrico Pontelli (New Mexico State University, USA)
Vitor Santos Costa (University of Porto, Portugal)
Tom Schrijvers (K.U. Leuven, Belgium)
Tran Cao Son (New Mexico State University, USA)
Peter J. Stuckey (Melbourne University, Australia)
Terrance Swift (CENTRIA, Portugal)
Peter Szeredi (Budapest U. of Tech. and E., Hungary)
Frank Valencia (Ecole Polytechnique, France)
Wim Vanhoof (University of Namur, Belgium)
Kewen Wang (Griffith University, Australia)
Stefan Woltran (Vienna U. of Technology, Austria)
Neng-Fa Zhou (City University of New York, USA)

SPONSOR

The conference is sponsored by the Association for Logic Programming.

FINANCIAL ASSISTANCE

The Association for Logic Programming has funds to assist financially
disadvantaged participants and, specially, students in order to be
able to attend the conference.

WORKSHOPS

The ICLP 2009 program will include several workshops, held also as
part of FLoC. They are perhaps the best places for the presentation of
preliminary work, undeveloped novel ideas, and new open problems to a
wide and interested audience with opportunities for intensive
discussions and project collaboration.

DOCTORAL CONSORTIUM

The 6th Doctoral Consortium (DC) on Logic Programming provides
research students with the opportunity to present and discuss their
research directions, and to obtain feedback from both peers and
world-renown experts in the field. Accepted participants will receive
partial financial support to attend the event and the main
conference. The best paper and presentation from the DC will be given
the opportunity to present in a special session of the main ICLP
conference.

CONFERENCE VENUE / CO-LOCATION

In 2010 (as in the previous two FLoC editions) ICLP will be held as
part of the Fifth Federated Logic Conference, FLoC 2010 in Edinburgh,
Scotland, U.K., July 16-19, 2010. FLoC is held every four years
bringing together several international conferences related to
mathematical logic and computer science. Other participating
conferences are:

- Computer-Aided Verification (CAV),
- Int'l Joint Conference on Automated Reasoning (IJCAR),
- Interactive Theorem Proving (ITP),
- Logic in Computer Science (LICS),
- Rewriting Techniques and Applications (RTA), and
- Theory and Applications of Satisfiability Testing (SAT).

Plenary events involving multiple conferences are planned.
------------------------------------------------------------------------

--------------------------------------------------------
Bug reports: http://logical.saclay.inria.fr/coq-bugs
Archives: http://pauillac.inria.fr/pipermail/coq-club
http://pauillac.inria.fr/bin/wilma/coq-club
Info: http://pauillac.inria.fr/mailman/listinfo/coq-club

From forum: Coq

Reset Induction Principle

2009-12-08T17:39:00Z

Hello, everyone:

i defined a inductive type, like : Inductive Term : Set. However, i do not want to use the induction principle Term_ind, because it is too weak. So how can i reset it in the CoqIDE ?

ps: I tried the command Reset, it says: Use CoqIDE navigation instead!

Thanks

From forum: Coq

Call for Papers: IWS 2010

2009-12-08T06:25:20Z

CALL FOR PAPERS
International Workshop on Strategies in Rewriting, Proving, and Programming
IWS 2010
iws2010.inria.fr
(A satellite workshop of FLoC 2010)
July 9 2010, Edinburgh, UK

Abstract submission: March 26, 2010
Notification date: April 11, 2010
Abstract final version: April 25, 2010
Workshop: July 9, 2010
Submission of full paper for the proceedings: September 5, 2010

Strategies are ubiquitous in programming languages, automated
deduction and reasoning systems, yet only since about ten years have
they been studied in their own right. In the two communities of
Rewriting and Programming on one side, and of Deduction and Proof
engines (Provers, Assistants, Solvers) on the other side, workshops
have been launched to make progress towards a deeper understanding of
the nature of strategies, their descriptions, their properties, and
their usage, in all kinds of computing and reasoning systems. Since
more recently, strategies are also playing an important role in
rewrite-based programming languages, verification tools and techniques
like SAT/SMT engines or termination provers. Moreover strategies have
come to be viewed more generally as expressing complex designs for
control in computing, modeling, proof search, program transformation,
and access control.

Possible topics to address in this workshop include:
* Foundations for the definition and semantic description of strategies:
models of search spaces, logical or mathematical formalisms
to define strategies and prove properties about them.
* Properties of strategies and corresponding computations:
logical or mathematical formalisms to prove properties about them.
* Analysis and optimization techniques for strategies:
analysis of the search space, evaluation and comparison of strategies.
* Integration of strategic deductions and/or strategic computations:
interrelations, combinations and applications of deduction and computation
under different strategies, control issues and strategies in the
integration
of systems, strategies in decision procedures for SMT.
* Strategy languages: essential constructs, meta-level features. Definition,
design, implementation and application. Comparison of strategies in
(existing) systems.
* Concrete types of (reduction/evaluation) strategies in rewriting
and programming, lambda calculi, normalization, narrowing, constraint
solving, as well as their properties and characteristics (complexity,
decidability, ...).
* Applications and case studies in which strategies play a major role.

FLoC 2010 provides an excellent opportunity to foster exchanges between
the communities of Rewriting and Programming on one side, and of Deduction
and Proof engines on the other side. This workshop is a joint follow-up of
two series of workshops, held since 1997: the Strategies workshops held by
the CADE-IJCAR community and the Workshops on Reduction Strategies (WRS)
held by the RTA-RDP community.

Submissions
----------

The submission process is in two stages.

1) Before the workshop, authors are invited to submit an extended abstract
(max. 5 pages) to be formatted in the EasyChair class style

http://www.easychair.org/easychair.zip

through the EasyChair submission site:

http://www.easychair.org/conferences/?conf=iws2010

Accepted abstracts will be presented at the workshop and included in
the preliminary proceedings, available at the workshop.

2) After the workshop, authors will be invited to submit a
full paper of their presentation (typically a 15-pages paper), which
will be refereed and considered for publication in the electronic
journal: Electronic Proceedings in Theoretical Computer Science
(http://eptcs.org).

Beyond original ideas and recent results not published nor submitted
elsewhere, we also invite authors to submit a 5-pages abstract describing
relevant work that has been or will be published elsewhere, or work in
progress. These submissions will be only considered for presentation
at the workshop and inclusion in the preliminary proceedings but not
in the final proceedings.

Organizers
---------
Helene Kirchner, INRIA Bordeaux - Sud-Ouest, France
Cesar Munoz, NASA Langley Research Center, Hampton, USA

Program Committee
-----------------
Maria Paola Bonacina, Univ. degli Studi di Verona, Italy
Jean-Christophe Filliatre, CNRS, France
Bernhard Gramlich, Technische Universitat Wien, Austria
Salvador Lucas, Universidad Politecnica de Valencia, Spain
Pierre-Etienne Moreau, LORIA-INRIA Nancy, France
Natarajan Shankar, SRI International, Menlo Park, CA, USA
Eelco Visser, Delft Univ. of Technology, The Netherlands
Christoph Weidenbach, MPI-INF, Saarbrucken, Germany

Web: iws2010.inria.fr
Email: iws2010@...

--------------------------------------------------------
Bug reports: http://logical.saclay.inria.fr/coq-bugs
Archives: http://pauillac.inria.fr/pipermail/coq-club
http://pauillac.inria.fr/bin/wilma/coq-club
Info: http://pauillac.inria.fr/mailman/listinfo/coq-club

From forum: Coq

Call for Participation: PLPV 2010

2009-12-07T12:37:46Z

*********************************************************************
CALL FOR PARTICIPATION

PLPV 2010

The Fourth ACM SIGPLAN Workshop
on
Programming Languages meets Program Verification

19 January 2010
Madrid, Spain

To be held in conjunction with POPL 2010

http://slang.soe.ucsc.edu/plpv10/
*********************************************************************

IMPORTANT DATES

Hotel reservation deadline: December 28, 2009 (Monday)

VENUE

PLPV'10 and all POPL'10 affiliated events will take place at the Melia
Castilla Hotel, Madrid.

REGISTRATION

To register for PLPV'10, follow the link from the POPL 2010 page, at

http://www.cse.psu.edu/popl/10/

SCOPE

The goal of PLPV is to foster and stimulate research at the
intersection of programming languages and program verification. Work
in this area typically attempts to reduce the burden of program
verification by taking advantage of particular semantic and/or
structural properties of the programming language. One example is
dependently typed programming languages, which leverage a language's
type system to specify and check richer than usual specifications,
possibly with programmer-provided proof terms. Another example is
extended static checking systems like ESC/Java and Spec#, which
incorporate pre- and postconditions along with a static verifier for
these contracts.

INVITED SPEAKER

Gilles Barthe, Madrid Instutite for Advanced Studies

PRELIMINARY PROGRAM

----------------------
Invited Talk (9:00 - 10:00)

* CertiCrypt: Formal Certification of Code-Based Cryptographic Proofs
Gilles Barthe, Madrid Instutite for Advanced Studies

Session 1 (10:30 - 12:00)

* Singleton types here, Singleton types there, Singleton types everywhere
Stefan Monnier and David Haguenauer

* Operating system development with ATS
Matthew Danish and Hongwei Xi

* Modular Reasoning about Invariants over Shared State with Interposed
Data Members
Stephanie Balzer and Thomas Gross

Session 2 (2:00 - 3:00)

* Resource Typing in Guru
Aaron Stump and Evan Austin

* Free Theorems for Functional Logic Programs
Jan Christiansen, Daniel Seidel and Janis VoigtlÃ¤nder

Discussion (3:00 - 3:30)

* Status update and discussion of the Trellys Project

Session 3 (4:00 - 5:00)

* Arity-generic datatype-generic programming
Stephanie Weirich and Chris Casinghino

* Challenge Benchmarks for Veriï¬cation of Real-time Programs
Tomas Kalibera, Gary Leavens and Jan Vitek

----------------------

PROGRAM CHAIRS

* Cormac Flanagan (University of California, Santa Cruz)
* Jean-Christophe FilliÃ¢tre (CNRS)

PROGRAM COMMITTEE

* Adam Chlipala (Harvard University)
* Ranjit Jhala (University of California, San Diego)
* Joseph Kiniry (University College Dublin)
* Rustan Leino (Microsoft Research)
* Xavier Leroy (INRIA Paris-Rocquencourt)
* Conor McBride (University of Strathclyde)
* Andrey Rybalchenko (Max Planck Institute for Software Systems)
* Tim Sheard (Portland State University)
* Stephanie Weirich (University of Pennsylvania)

--------------------------------------------------------
Bug reports: http://logical.saclay.inria.fr/coq-bugs
Archives: http://pauillac.inria.fr/pipermail/coq-club
http://pauillac.inria.fr/bin/wilma/coq-club
Info: http://pauillac.inria.fr/mailman/listinfo/coq-club

From forum: Coq

CoLoR: new release

2009-12-07T00:09:46Z

Hello!

On http://color.inria.fr, you will find a new release of CoLoR, a Coq
Library on Rewriting and termination.

Among the main new features since the last release on March 11, you will
find:

- the use of N. Dershowitz's improvement for computing dependency pairs,

- the basic flat context closure transformation,

- a formalization of semantic labelling with models or quasi-models, and
infinite or finite sets of rules,

- root labelling, a particular case of semantic labelling,

- collapsing argument filterings (non-collapsing argument filterings
were already formalized),

- a loop checker for (relative) TRSs or SRSs,

- non-termination when the variable condition is not satisfied,

- the conversion into SRSs of TRSs with unary symbols only,

- signature morphisms and their properties wrt termination,

- semi-rings, matrices and matrix interpretations now operate on setoids,

- a syntactic matching algorithm proved correct and complete,

- positions in a term,

- the list of reducts of a term,

- a translation of CoLoR terms into Coccinelle terms
(http://a3pat.ensiie.fr/).

You can browse the definitions and lemmas on
http://color.inria.fr/doc/main.html.

Enjoy!

--------------------------------------------------------
Bug reports: http://logical.saclay.inria.fr/coq-bugs
Archives: http://pauillac.inria.fr/pipermail/coq-club
http://pauillac.inria.fr/bin/wilma/coq-club
Info: http://pauillac.inria.fr/mailman/listinfo/coq-club

From forum: Coq

PhD studentships at Nottingham

2009-12-02T03:34:54Z

Hi,

the School of Computer Science at Nottingham is advertising 3 PhD
positions (see attached), areas include Functional Programming (in our
view this includes Applications of Category Theory and Type Theory) -
see the webpages of the Functional Programming Lab: http://fp.cs.nott.ac.uk/
. The deadline for applications is 8th of January 2010.

Please forward this to interested students.

Cheers,
Thorsten

The School of Computer Science of the University of Nottingham invites
applications for 3 PhD studentships. The studentships are for 3.5 years
and include 13,290 per year maintenance grant and UK/EU tuition fees.
The applicants need to apply through the University postgraduate
admissions system
http://pgstudy.nottingham.ac.uk/apply-for-postgraduate-courses.aspx
The deadline for applications is the 8th of January 2010.

The applications are invited in the areas listed below. Please contact
the academics listed for the research area first if you are interested
in applying for a PhD in their area.

Functional Programming (contact Henrik Nilsson, Graham Hutton, Thorsten
Altenkirch, Venanzio Capretta: {nhn, gmh, txa, vxc} at cs.nott.ac.uk)

Computational Photography and Content-based Image Retrieval (contact
Guoping Qiu, qiu at cs.nott.ac.uk)

Computer Vision and Graphics (contact Bai Li, bai at cs.nott.ac.uk)

Computational Finance (contact Rong Qu, rxq at cs.nott.ac.uk)

Adaptive and Learning Systems (contact Jon Garibaldi, jmg at cs.nott.ac.uk)

Intelligent Agents (contact Brian Logan and Natasha Alechina, {bsl, nza}
at cs.nott.ac.uk)

Computational Systems and Synthetic Biology (contact Natalio Krasnogor,
nxk at cs.nott.ac.uk)

Simulation of Complex Systems and Computational Modelling and Data
Mining (contact Uwe Aickelin, uxa at cs.nott.ac.uk)

Data mining (contact Jaume Bacardit, jqb at cs.nott.ac.uk)

Document Engineering (contact Steven Bagley, srb at cs.nott.ac.uk)

Opportunistic networking (contact Milena Radenkovic, mvr at cs.nott.ac.uk)

Reactive Environments (contact Holger Schnadelbach, Dave Kirk: hms,dsk at
cs.nott.ac.uk)

Intelligent Multilevel Search Methodologies (contact Ender Ozcan, exo at
cs.nott.ac.uk)

From forum: Coq

3 full professor positions at DIKU

2009-12-02T02:52:56Z

The Department of Computer Science at the University of Copenhagen
(DIKU, http://www.diku.dk) has openings for up to 3 full professor
positions in programming languages and systems (1 or 2 appointments),
respectively software development (1 appointment), starting May 2010.

For detailed information, including application procedures, please see
the full position announcements:

Professor in programming languages and systems:
http://www.diku.dk/ominstituttet/ledige_stillinger/professorinsoftware/

Professor in software development:
http://www.diku.dk/ominstituttet/ledige_stillinger/professorinprogramming/

Please note that the software development position is open to
outstanding candidates with a technically-oriented research record and
ambitions to bridge to user-oriented aspects.

Enquiries about the positions can be made to department head Martin
Zachariasen---see the announcements for contact information.

Deadline for application: December 17th, 2009, 12 noon (CET).

--------------------------------------------------------
Bug reports: http://logical.saclay.inria.fr/coq-bugs
Archives: http://pauillac.inria.fr/pipermail/coq-club
http://pauillac.inria.fr/bin/wilma/coq-club
Info: http://pauillac.inria.fr/mailman/listinfo/coq-club

From forum: Coq