[Hol-info] Type abstraction – Re: Mike Gordon bio

[Ken Kubota]

Not quite a correction, but an important addendum to the last part ("Legacy") 
is type abstraction, which Mike Gordon suggested for HOL (but didn't 
implement), shaping future research. He already foresaw a binding of variables 
connecting both term and type (subscript) level. (Gordon positively refers to 
Tom Melham's extension of HOL [Gordon, 2000, p. 175, fn. 7]. R0 incorporates 
type abstraction as a standard feature.)

Mike Gordon suggesting type abstraction for HOL: “The syntax and semantics of 
type variables are currently being studied by several logicians. A closely 
related area is the theory of ‘second order’ λ-terms like λα. λx:α. x, perhaps 
such terms should be included in the HOL logic.” [Gordon, 2001, p. 22]

http://www.owlofminerva.net/files/fom.pdf 
, p. 7

Besides this, the article is excellent.
I was astonished that it even mentions the awareness of social class 
distinctions (white vs. brown coats), as in

http://www.cl.cam.ac.uk/archive/mjcg/plans/NorthThamesGasBoard.html#white-versus-brown-coats
 

https://arxiv.org/pdf/1806.04002.pdf 
, p. 2


Ken Kubota




Ken Kubota
http://doi.org/10./100 



> Am 07.07.2018 um 16:16 schrieb Lawrence Paulson :
> 
> Colleagues may be interested in my biographical article on Mike Gordon, whose 
> promotion of higher-order logic has had such a profound impact on our field.
> 
> https://arxiv.org/abs/1806.04002
> 
> Corrections welcome.
> 
> Larry Paulson
> 
> 
> 
> 
> --
> Check out the vibrant tech community on one of the world's most
> engaging tech sites, Slashdot.org! http://sdm.link/slashdot
> ___
> hol-info mailing list
> hol-info@lists.sourceforge.net
> https://lists.sourceforge.net/lists/listinfo/hol-info

--
Check out the vibrant tech community on one of the world's most
engaging tech sites, Slashdot.org! http://sdm.link/slashdot___
hol-info mailing list
hol-info@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/hol-info

Re: [Hol-info] Extension of Co-algebraic Datatype

[Chun Tian (binghe)]

Hi Waqar,

I think you’re looking for a datatype package in which induction and 
coinduction types can be mixed naturally. This is currently not possible in 
HOL4, but it’s not the fault of Higher Order Logic itself. According to Andrei 
Popescu et al. [1] it’s in theory possible to port or (re)implement their BNF 
work in HOL4 as it doesn’t depend on Isabelle's type extensions to Higher Order 
Logic. However this is a huge work, nobody is doing this porting, as far as I 
know, although it is supposed to be a huge contribution once it’s done.

—Chun

[1] Traytel, D., Popescu, A.: Foundational, compositional (co) datatypes for 
higher-order logic: Category theory applied to theorem proving. 2012 27th 
Annual IEEE Symposium on Logic in Computer Science. 596–605 (2012).

> Il giorno 03 lug 2018, alle ore 17:09, Waqar Ahmad via hol-info 
>  ha scritto:
> 
> Hi,
> 
> In Isabelle, besides coinduction, the normal induction procedure on 
> lazylist/stream datatype appears to be allowed.. Can a same behaviour is 
> possible with the 'a llist type in HOL4.
> 
> Secondly, unlike lazy list, the "stream" are defined without having the empty 
> "LNIL". I see a similar formalization in  HOL example directory 
> "...examples/Crypto/TEA/lazy_teaScript.sml"
> 
> 
> val RoundFun_def =
>  Define
>`RoundFun (s: state) = SOME (Round s, FST (Round s))`;
> 
> val StreamG_def = new_specification
>  ("StreamG",
>   ["StreamG"],
>   ISPEC ``RoundFun`` llist_Axiom_1);
> 
> I defined it using LUNFOLD as
> 
> StreamD xs = LUNFOLD (λn. SOME (THE (LTL n),THE (LHD n))) x
> 
> Is it possible, that when an induction scheme is applied, the base case 
> (LNIL) can be discharged/skipped? I'm aware of llist_bisumulation, which is 
> extremely useful in proving that two lazy lists are equal. However, in many 
> cases, its not applicable
> 
> 
> 
> On Sun, May 13, 2018 at 6:19 AM  > wrote:
> If you want the coinductively defined streams predicate over lllist, you can 
> write
> 
> 
> 
> >  CoIndDefLib.Hol_coreln `!a s. a IN A /\ streams A s ==> streams A (LCONS a 
> > s)`;
> 
> <>
> 
> <>
> 
> val it =
> 
>(⊢ ∀A a s. a ∈ A ∧ streams A s ⇒ streams A (a:::s),
> 
> ⊢ ∀A streams'.
> 
>   (∀a0. streams' a0 ⇒ ∃a s. (a0 = a:::s) ∧ a ∈ A ∧ streams' s) ⇒
> 
>   ∀a0. streams' a0 ⇒ streams A a0,
> 
> ⊢ ∀A a0. streams A a0 ⇔ ∃a s. (a0 = a:::s) ∧ a ∈ A ∧ streams A s):
> 
> 
> 
> I think the last theorem of the triple is the cases theorem you want.
> 
> 
> 
> Note that if you are going to define Stream with
> 
> 
> 
>   Stream L = LFILTER (\n. T) L
> 
> 
> 
> You might as well write the equivalent
> 
> 
> 
>   Stream L = L
> 
> 
> 
> Best wishes,
> 
> Michael
> 
> 
> 
> 
> 
> 
> 
> From: Waqar Ahmad <12phdwah...@seecs.edu.pk >
> Date: Saturday, 12 May 2018 at 05:45
> To: "Norrish, Michael (Data61, Acton)"  >
> Cc: hol-info  >
> Subject: Re: [Hol-info] Extension of Co-algebraic Datatype
> 
> 
> 
> Thanks!. I understand that the working of LNIL and LCONS constructors since 
> I'm exploring "llistTheory" for quite some time. To be very clear, I'm in the 
> process of porting "stream theory" form Isabelle  
> <>https://www.isa-afp.org/browser_info/current/HOL/HOL-Library/Stream.html 
>  
> which is formalized as coinductive "stream":
> 
> 
> 
> codatatype (sset: 'a) stream =
> 
>   SCons (shd: 'a) (stl: "'a stream") (infixr "##" 65)
> 
> for
> 
>   map: smap
> 
>   rel: stream_all2
> 
> 
> 
>  I can see that its datatype is very similar to lazy list (llistTheory) 
> datatype so rather defining a new type I defined a function that returns the 
> same 'a llist-typed (lazy) list as given to its input:
> 
> 
> 
> ∀​​L. Stream L = LFILTER (λ​​n. T) L:
> 
> 
> 
> type_of ``stream``;
> 
> 
> 
>  ``:α​​ llist -> α​​ llist``:
> 
> 
> 
> 
> 
> Later in Isabelle "stream theory", a coinductive set "streams" is defined 
> based on "stream" datatype as:
> 
> 
> 
> coinductive_set
> 
>   streams :: "'a set ⇒​​  'a stream set"
> 
>   for A :: "'a set"
> 
> where
> 
>   Stream[intro!, simp, no_atp]: "[[a ∈​​ A; s ∈​​ streams A]] ⟹ a ## s ∈​​ 
> streams A"
> 
> end
> 
> 
> 
> Using llistTheory functions, I'm able to define a similar function as:
> 
> 
> 
> ∀​​A. streams A = IMAGE (λ​​a. Stream a) {llist_abs (λ​​n. SOME x) | x ∈​​ A}:
> 
> 
> 
> type_of ``streams``;
> 
> 
> 
>  ``:('a -> bool) -> 'a llist -> bool``:
> 
> 
> 
> However, by using shallow embedding approach, I'm not able to use some 
> essential properties that are accompanied when a new coinductive datatype is 
> defined. For instance, if a streams datatype is define, I may have this 
> property of form:
> 
> 
> 
> streams.cases (Isabelle):
> 
> 
> 
> a ∈​​ streams A ⇒​​ (? a s. a = a ##s ⇒​​ a ∈​​ A ⇒​​ s ∈​​  streams A ⇒​​ P) 
> ⇒​​ P
> 
> 
> 
> I'm having 

[Hol-info] 1st Call for Papers Software Verification and Testing Track @ ACM SAC 2019

[Matthias Güdemann]

 34th Annual ACM Symposium on Applied Computing
Software Verification and Testing Track
Limassol, Cyprus
   April 8 – 12, 2019

   https://www.sigapp.org/sac/sac2019/
  https://sites.google.com/site/sacsvt2019/home
 svt.sac.2...@gmail.com
   https://twitter.com/SvtSac

Important dates
===

Sep. 10, 2018 - Submission of regular papers and SRC research abstracts
Nov. 10, 2018 - Notification of paper / SRC abstract acceptance/rejection
Nov. 25, 2018 - Camera-ready copies of accepted papers/SRC
Dec. 10, 2018 - Author registration due date


ACM Symposium on Applied Computing
==

The ACM Symposium on Applied Computing (SAC) has gathered scientists from
different areas of computing over the last thirty years. The forum represents an
opportunity to interact with different communities sharing an interest in
applied computing.

SAC 2019 is sponsored by the ACM Special Interest Group on Applied Computing
(SIGAPP), and will be hosted by the University of Cyprus, Limassol, Cyprus.

Software Verification and Testing Track
===

The Software Verification and Testing track aims at contributing to the
challenge of improving the usability of formal methods in software
engineering. The track covers areas such as formal methods for verification and
testing, based on theorem proving, model checking, static analysis, and run-time
verification. We invite authors to submit new results in formal verification and
testing, as well as development of technologies to improve the usability of
formal methods in software engineering. Also are welcome detailed descriptions
of applications of mechanical verification to large scale software. Possible
topics include, but are not limited to:

* model checking
* theorem proving
* correct by construction development
* model-based testing
* software testing
* symbolic execution
* static and dynamic analysis
* abstract interpretation
* analysis methods for dependable systems
* software certification and proof carrying code
* fault diagnosis and debugging
* verification and validation of large scale software systems
* real world applications and case studies applying software testing
and verification
* benchmarks and data sets for software testing and verification

Submission Guidelines
=

Paper submissions must be original, unpublished work. Author(s) name(s) and
address(es) must not appear in the body of the paper, and self-reference should
be avoided and made in the third person. Submitted paper will undergo a blind
review process. Authors of accepted papers should submit an editorial revision
of their papers that fits within eight two-column pages (an extra two pages, to
a total of ten pages, may be available at a charge). Please comply to this page
limitation already at submission time. Accepted papers will be published in the
ACM SAC 2019 proceedings.

Paper registration is required, allowing the inclusion of papers, posters, or
SRC abstracts in the conference proceedings. An author or a proxy attending SAC
MUST present the work. This is a requirement for the presented work to be
included in the ACM/IEEE digital library. No-show of registered papers, posters,
and SRC abstracts will result in excluding them from the ACM/IEEE digital
library.

After the Symposium we will organize a special issue of the Software Quality
Journal (SQJ) on the topics of SVT.

Student Travel Award


The SIGAPP Student Travel Award Program (STAP) was established to provide
financial support for SIGAPP student members to attend SIGAPP primary conference
(SAC) to present their accepted work. Student primary authors and co-authors are
eligible to apply for these awards. For details please see:
https://www.sigapp.org/stawards.html

Student Research Competition


As previous editions, SAC 2019 organises a Student Research Competition (SRC)
Program to provide graduate students the opportunity to meet and exchange ideas
with researchers and practitioners in their areas of interest. Guidelines and
information about the SRC program can be found at
http://www.sigapp.org/sac/sac2019/.

Program Committee Chairs


Leonardo Mariani, University of Milano Bicocca
Matthias Guedemann, Diffblue Ltd.

Program Committee
=

will be announced in time on the webpage

--
Check out the vibrant tech community on one of the world's most
engaging tech sites, Slashdot.org! http://sdm.link/slashdot
___
hol-info mailing list
hol-info@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/hol-info

[Hol-info] Second Call for Papers: FSEN 2019

[Maurice ter Beek]

##
SECOND CALL FOR PAPERS

Eighth International Conference on
Fundamentals of Software Engineering 2019 -
Theory and Practice (FSEN '19)
http://fsen.ir/2019
Tehran, Iran
May 1-3, 2019
##

-- About FSEN --

Fundamentals of Software Engineering (FSEN) is an international 
conference that aims to bring together researchers, engineers, 
developers, and practitioners from academia and industry to present and 
discuss their research work in the area of formal methods for software 
engineering. Additionally, this conference seeks to facilitate the 
transfer of experience, adaptation of methods, and where possible, 
foster collaboration among different groups. The topics of interest 
cover all aspects of formal methods, especially those related to 
advancing the application of formal methods in the software industry and 
promoting their integration with practical engineering techniques. 
Following the success of the previous FSEN editions, the next edition of 
the FSEN conference will take place in Tehran, Iran, May 1-3, 2019.


-- Important Dates --

Abstract Submission (optional): October 19, 2018 (AoE)
Paper Submission: October 28, 2018 (AoE)
Notification: December 18, 2018
Final pre-Conference Version: January 20, 2019 (AoE)
Conference: May 1-3, 2019

-- Keynote Speakers --

Rocco De Nicola - IMT School for Advanced Studies Lucca, Italy
Giovanna Di Marzo Serugendo - University of Geneva, Switzerland
Martin Wirsing - LMU Munich, Germany

-- Topics of Interest --

The topics of this conference include, but are not restricted to, the 
following:


* Models of programs and software systems
* Software specification, validation, and verification
* Software testing
* Software architectures and their description languages
* Object, actor and multi-agent systems
* Coordination, feature interaction and software product lines
* Integration of formal and informal methods
* Integration of different formal methods
* Component-based and Service-oriented software systems
* Collective, self-adaptive and cyber-physical software systems
* Model checking and theorem proving
* Quantitative formal methods
* Software and hardware verification
* CASE tools and tool integration
* Industrial Applications

-- Paper Submission --

Authors are invited to submit full papers (up to 15 pages including 
references) describing original research, applications and tools; or 
short papers (up to 6 pages including references) describing ongoing 
research or new ideas that have not yet been fully validated.
Both categories of papers must be submitted electronically in Postscript 
or PDF using the online submission process via the Easychair conference 
system at the following link: 
https://www.easychair.org/conferences/?conf=fsen2019.


Contributions must be written in English, should be formatted according 
to the Springer LNCS style (LaTeX2e Proceedings Templates) that can be 
found at the following link 
(http://www.springer.com/gp/computer-science/lncs/conference-proceedings-guidelines) 
and not exceed the page limit for the category (including figures and 
references).


Each submission will be thoroughly reviewed by at least three reviewers 
considering scientific originality, significance, relevance to the FSEN 
conference, technical soundness, clarity, self-containedness and 
discussion of appropriate related work.


The reviewers will be asked to rate the submissions and evaluate whether 
they can be accepted as:

1) Full paper for the LNCS post-proceedings and conference pre-proceedings
2) Short paper for the LNCS post-proceedings and conference pre-proceedings
3) Poster included only in the pre-proceedings
Papers accepted in the first 2 categories will be invited for 
presentation at the conference. Posters will be illustrated by the 
authors in separate poster sessions.


Submissions are required to report on original, unpublished work and 
should not be submitted simultaneously for publication elsewhere (cf. 
IFIP's Author Code of Conduct, see http://www.ifip.org/ under 
Publications/Links).


-- Proceedings and Special Issue --

The post-proceedings of FSEN'19 will be published by Springer Verlag in 
the LNCS series (to be confirmed). Pre-proceedings, printed locally by 
IPM, will be available at the conference. Following the tradition of 
FSEN, we plan to have a special issue of the Science of Computer 
Programming journal devoted to FSEN'19 (to be confirmed). After the 
conference a selection of papers will be invited for this special issue. 
The invited papers should be revised and extended and will undergo a new 
round of review by an international program committee. Please see the 
websites of previous editions of FSEN for more information on 
post-proceedings and special issues related to those editions.


-- General Chairs --

Farhad Arbab - CWI, Netherlands; Leiden University, Netherlands

[Hol-info] PPDP 2018: Call for Participation

[David Sabel]

==
    PPDP 2018: Call for Participation
==
 20th International Symposium on
    Principles and Practice of Declarative Programming

 Frankfurt am Main, Germany, 3-5 September 2018

http://ppdp-lopstr-18.cs.uni-frankfurt.de/ppdp18.html

    (co-located with LOPSTR 2018 and WFLP 2018)
 http://ppdp-lopstr-18.cs.uni-frankfurt.de
==

Registration

 http://www.ppdp-lopstr-18.cs.uni-frankfurt.de/#registration
 Early registration ends on 15 August, 2018.


Session in Honour of Martin Hofmann
===
PPDP will include a session in honour of Martin Hofmann including a talk
given by Nick Benton, Facebook on Semantic Equivalence Checking for HHVM 
Bytecode



Invited Talks
=
-   Philippa Gardner, Imperial College.
    Testing and Verification for JavaScript (joint with LOPSTR)

-   Jorge Navas, SRI International.
    Constrained Horn Clauses for Verification (joint with LOPSTR)

-   Chung-Chieh Shan, University of Indiana.
    Calculating Distributions


Accepted Papers
===
-   Maciej Bendkowski and Pierre Lescanne.
    Combinatorics of explicit substitutions

-   Manfred Schmidt-Schauss, David Sabel and Nils Dallmeyer.
    Sequential and Parallel Improvements in a Concurrent Functional 
Programming Language


-   Magnus Madsen and Ondrej Lhotak.
    Implicit Parameters for Logic Programming

-   Mistral Contrastin, Dominic Orchard and Andrew Rice.
    Automatic reordering for dataflow safety of Datalog

-   Danil Annenkov and Martin Elsman.
    Certified Compilation of Financial Contracts

-   José Fragoso Santos, Petar Maksimović, Théotime Grohens, Julian 
Dolby and Philippa Gardner.

    Cosette: Symbolic Execution for JavaScript

-   Michael Hanus.
    Verifying Fail-Free Declarative Programs

-   Dmitri Rozplokhas and Dmitry Boulytchev.
    Improving Refutational Completeness of Relational Search via 
Divergence Test


-   Martin Sulzmann and Kai Stadtmüller.
    Two-Phase Dynamic Analysis of Message-Passing Go Programs based on 
Vector Clocks


-   Sylvia Grewe, Sebastian Erdweg, André Pacak and Mira Mezini.
    An Infrastructure for Combining Domain Knowledge with Automated 
Theorem Provers


-   Gopalan Nadathur and Yuting Wang.
    Schematic Polymorphism in the Abella Proof Assistant

-   Stephan Adelsberger, Anton Setzer and Eric Walkingshaw.
    Declarative GUIs: Simple, Consistent, and Verified

-   Genki Sakanashi and Masahiko Sakai.
    Transformation of combinatorial optimization problems written in 
extended SQL into constraint problems


-   Yuki Nishida and Atsushi Igarashi.
    Nondeterministic Manifest Contracts

-   Alberto Pardo, Emmanuel Gunther, Miguel Pagano and Marcos Viera.
    An Internalist Approach to Correct-by-Construction Compilers

-   Falco Nogatz, Jona Kalkus and Dietmar Seipel.
    Web-based Visualisation for Definite Clause Grammars using Prolog 
Meta-Interpreters


-   Helmut Seidl and Ralf Vogler.
    Three improvements to the top-down solver

-   Flavien Breuvart and Ugo Dal Lago.
    On Intersection Types and Probabilistic Lambda Calculi

-   Taku Terao.
    Lazy Abstraction for Higher-Order Program Verification

-   Maximiliano Klemen, Nataliia Stulova, Pedro Lopez-Garcia, Jose F. 
Morales and Manuel V. Hermenegildo.

    Static Performance Guarantees for Programs with Run-time Checks

-   Abhishek Dang and Piyush Kurur.
    Verse: An EDSL for cryptographic primitives

-   Pablo Barenbaum, Eduardo Bonelli and Kareem Mohamed.
    Pattern Matching and Fixed Points: Resources Types and Strong 
Call-By-Need


Sponsors

 PPDP is financially supported by the
 Deutsche Forschungsgemeinschaft (DFG, German Research Foundation) - 
407531063,

 and by the Goethe-University Frankfurt am Main.

Conference Organisers
=
 Program Committee
   See http://www.ppdp-lopstr-18.cs.uni-frankfurt.de/ppdp18.html#pc

 Program Chair
   Peter Thiemann, Universität Freiburg, Germany

 Organizing Committee (Goethe-University Frankfurt am Main, Germany)
    Ehud Cseresnyes
    Nils Dallmeyer
    Bircan Dölek
    Ronja Düffel
    Lars Huth
    Leonard Priester
    David Sabel (General Chair)





--
Check out the vibrant tech community on one of the world's most
engaging tech sites, Slashdot.org! http://sdm.link/slashdot
___
hol-info mailing list
hol-info@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/hol-info

Re: [Hol-info] Extension of Co-algebraic Datatype

[Waqar Ahmad via hol-info]

Hi,

In Isabelle, besides coinduction, the normal induction procedure on
lazylist/stream datatype appears to be allowed.. Can a same behaviour is
possible with the 'a llist type in HOL4.

Secondly, unlike lazy list, the "stream" are defined without having the
empty "LNIL". I see a similar formalization in  HOL example directory
"...examples/Crypto/TEA/lazy_teaScript.sml"


val RoundFun_def =
 Define
   `RoundFun (s: state) = SOME (Round s, FST (Round s))`;

val StreamG_def = new_specification
 ("StreamG",
  ["StreamG"],
  ISPEC ``RoundFun`` llist_Axiom_1);

I defined it using LUNFOLD as

StreamD xs = LUNFOLD (λn. SOME (THE (LTL n),THE (LHD n))) x

Is it possible, that when an induction scheme is applied, the base case
(LNIL) can be discharged/skipped? I'm aware of llist_bisumulation, which is
extremely useful in proving that two lazy lists are equal. However, in many
cases, its not applicable



On Sun, May 13, 2018 at 6:19 AM  wrote:

> If you want the coinductively defined streams predicate over lllist, you
> can write
>
>
>
> >  CoIndDefLib.Hol_coreln `!a s. a IN A /\ streams A s ==> streams A
> (LCONS a s)`;
>
> <>
>
> <>
>
> val it =
>
>(⊢ ∀A a s. a ∈ A ∧ streams A s ⇒ streams A (a:::s),
>
> ⊢ ∀A streams'.
>
>   (∀a0. streams' a0 ⇒ ∃a s. (a0 = a:::s) ∧ a ∈ A ∧ streams' s) ⇒
>
>   ∀a0. streams' a0 ⇒ streams A a0,
>
> ⊢ ∀A a0. streams A a0 ⇔ ∃a s. (a0 = a:::s) ∧ a ∈ A ∧ streams A s):
>
>
>
> I think the last theorem of the triple is the cases theorem you want.
>
>
>
> Note that if you are going to define Stream with
>
>
>
>   Stream L = LFILTER (\n. T) L
>
>
>
> You might as well write the equivalent
>
>
>
>   Stream L = L
>
>
>
> Best wishes,
>
> Michael
>
>
>
>
>
>
>
> *From: *Waqar Ahmad <12phdwah...@seecs.edu.pk>
> *Date: *Saturday, 12 May 2018 at 05:45
> *To: *"Norrish, Michael (Data61, Acton)" 
> *Cc: *hol-info 
> *Subject: *Re: [Hol-info] Extension of Co-algebraic Datatype
>
>
>
> Thanks!. I understand that the working of LNIL and LCONS constructors
> since I'm exploring "llistTheory" for quite some time. To be very clear,
> I'm in the process of porting "stream theory" form Isabelle
> https://www.isa-afp.org/browser_info/current/HOL/HOL-Library/Stream.html which
> is formalized as coinductive "stream":
>
>
>
> codatatype (sset: 'a) stream =
>
>   SCons (shd: 'a) (stl: "'a stream") (infixr "##" 65)
>
> for
>
>   map: smap
>
>   rel: stream_all2
>
>
>
>  I can see that its datatype is very similar to lazy list (llistTheory)
> datatype so rather defining a new type I defined a function that returns
> the same 'a llist-typed (lazy) list as given to its input:
>
>
>
> *∀**​*​L. Stream L = LFILTER (*λ​*​n. T) L:
>
>
>
> type_of ``stream``;
>
>
>
>  ``:*α​*​ llist -> *α​*​ llist``:
>
>
>
>
>
> Later in Isabelle "stream theory", a coinductive set "streams" is defined
> based on "stream" datatype as:
>
>
>
> coinductive_set
>
>   streams :: "'a set *⇒**​​ * 'a stream set"
>
>   for A :: "'a set"
>
> where
>
>   Stream[intro!, simp, no_atp]: "[[a *∈**​*​ A; s *∈**​*​ streams A]] ⟹ a
> ## s *∈**​*​ streams A"
>
> end
>
>
>
> Using llistTheory functions, I'm able to define a similar function as:
>
>
>
> *∀**​*​A. streams A = IMAGE (*λ​*​a. Stream a) {llist_abs (*λ​*​n. SOME
> x) | x *∈**​*​ A}:
>
>
>
> type_of ``streams``;
>
>
>
>  ``:('a -> bool) -> 'a llist -> bool``:
>
>
>
> However, by using shallow embedding approach, I'm not able to use some
> essential properties that are accompanied when a new coinductive datatype
> is defined. For instance, if a streams datatype is define, I may have this
> property of form:
>
>
>
> streams.cases (Isabelle):
>
>
>
> a *∈**​*​ streams A *⇒**​*​ (? a s. a = a ##s *⇒**​​ a **∈**​​ A **⇒*
> *​​ s **∈**​​  *streams A *⇒**​*​ P) *⇒**​*​ P
>
>
>
> I'm having the issues of defining these types in HOL4. Is there any way
> that I can replicate the same in HOL4?
>
>
>
>
>
> On Mon, May 7, 2018 at 8:49 PM,  wrote:
>
> You can probably define a function of that type, but you can’t define a *
> *constructor** of that type for llist.   (Contrast what I’d consider to
> be llist’s standard constructors, LNIL and LCONS. They have types α llist,
> and α -> α llist -> α llist respectively.)
>
>
>
> You said you wanted a stream type, does this mean you want a constructor
> for stream of type
>
>
>
>   (α -> bool) -> α stream
>
>
>
> ?
>
>
>
> Such a constructor is not recursive, so I can just write
>
>
>
> Datatype`stream = SetConstructor (α -> bool)`
>
>
>
> The SetConstructor term then has the desired type.
>
>
>
> So I’m afraid I still don’t understand your question.
>
>
>
> Michael
>
>
>
> *From: *Waqar Ahmad <12phdwah...@seecs.edu.pk>
> *Date: *Monday, 7 May 2018 at 11:38
> *To: *"Norrish, Michael (Data61, Acton)" 
> *Cc: *hol-info 
> *Subject: *Re: [Hol-info] Extension of Co-algebraic Datatype
>
>
>
> Thanks for the explanation. Let me state it clearly. Can I write down a
> constructor of type
>
>
>
> (*α​*​*​*​ -> bool) -> *α​*​ llist
>
>
>
>

Re: [Hol-info] VTSA 2018: call for applications

[Stephan Merz]

Although the deadline for application has passed, a few places remain 
available. If you are interested, please send the indicated documents to 
stephan.m...@loria.fr : registrations remain 
possible until the remaining slots have been filled.

Thank you,
Stephan Merz


> On 6 Jun 2018, at 14:34, Stephan Merz  wrote:
> 
> UniGR Summer School on Verification Technology, Systems and Applications 
> (VTSA 2018)
> 
> August 27-31, 2018, Nancy, France
> 
> The summer school on verification technology, systems & applications focuses 
> on fundamental aspects of verification techniques, their implementation, and 
> their use for concrete applications. It is organized by Inria Nancy, the 
> Max-Planck-Institut für Informatik in Saarbrücken, and  the Universities of 
> Liège and of Luxembourg, and will take place at the research center Inria 
> Nancy – Grand Est in Nancy, France, from August 27 to 31, 2018.
> 
> The following speakers have agreed to lecture at the school:
> 
> - David Basin: Formal Methods for Security Protocols
> - Jean-Christophe Filliâtre: An Introduction to Deductive Program Verification
> - Peter Lammich: Algorithm Verification with the Isabelle Refinement Framework
> - Anca Muscholl: Distributed Synthesis
> - Carsten Sinz: Bounded Model Checking of Software for Real-World Applications
> 
> Participation to the school is free to anybody holding at least a bachelor 
> degree or equivalent; it includes the lectures, coffee and lunch breaks, and 
> a school dinner. Attendance is limited to 40 participants. Please apply 
> electronically by sending an email to Stephan Merz (stephan.m...@loria.fr) 
> including
> 
> - a one-page CV,
> - an application letter explaining your interest in the school and your 
> experience in the area, and
> - a copy of your bachelor (or equivalent or higher) certificate.
> 
> The deadline for application is July 8, 2018. Notification of acceptance will 
> be given by July 11, 2018.
> 
> Full details can be found on the school Web page at 
> https://www.mpi-inf.mpg.de/vtsa18.
> 

--
Check out the vibrant tech community on one of the world's most
engaging tech sites, Slashdot.org! http://sdm.link/slashdot___
hol-info mailing list
hol-info@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/hol-info