Skip to content
Snippets Groups Projects
Select Git revision
  • master default protected
1 result
Compare
Forked from Iris / Iris
5264 commits behind the upstream repository.
user avatar
Make big_opL type class opaque.
Robbert Krebbers authored 
This commit fixes the issues that refolding of big operators did not work nicely
in the proof mode, e.g., given:

    Goal forall M (P : nat → uPred M) l,
      ([∗ list] x ∈ 10 :: l, P x) -∗ True.
    Proof. iIntros (M P l) "[H1 H2]".

We got:

    "H1" : P 10
    "H2" : (fix
            big_opL (M0 : ofeT) (o : M0 → M0 → M0) (H : Monoid o) (A : Type)
                    (f : nat → A → M0) (xs : list A) {struct xs} : M0 :=
              match xs with
              | [] => monoid_unit
              | x :: xs0 => o (f 0 x) (big_opL M0 o H A (λ n : nat, f (S n)) xs0)
              end) (uPredC M) uPred_sep uPred.uPred_sep_monoid nat
             (λ _ x : nat, P x) l
    --------------------------------------∗
    True

The problem here is that proof mode looked for an instance of `IntoAnd` for
`[∗ list] x ∈ 10 :: l, P x` and then applies the instance for separating conjunction
without folding back the fixpoint. This problem is not specific to the Iris proof
mode, but more of a general problem of Coq's `apply`, for example:

    Goal forall x l, Forall (fun _ => True) (map S (x :: l)).
    Proof.
      intros x l. constructor.

Gives:

     Forall (λ _ : nat, True)
       ((fix map (l0 : list nat) : list nat :=
          match l0 with
          | [] => []
          | a :: t => S a :: map t
          end) l)

This commit fixes this issue by making the big operators type class opaque and instead
handle them solely via corresponding type classes instances for the proof mode tactics.

Furthermore, note that we already had instances for persistence and timelessness. Those
were really needed; computation did not help to establish persistence when the list in
question was not a ground term. In fact, the sitation was worse, to establish persistence
of `[∗ list] x ∈ 10 :: l, P x` it could either use the persistence instance of big ops
directly, or use the persistency instance for `∗` first. Worst case, this can lead to an
exponential blow up because of back tracking.
02a0929d
History
user avatar 02a0929d
History
Name Last commit Last update
benchmark
build
docs
theories
.gitignore
.gitlab-ci.yml
CHANGELOG.md
CONTRIBUTING.md
LICENSE
LICENSE-CODE
LICENSE-DOCS
Makefile
ProofMode.md
README.md
_CoqProject
awk.Makefile
naming.txt
opam
opam.pins
README.md

IRIS COQ DEVELOPMENT

This is the Coq development of the Iris Project.

Prerequisites

This version is known to compile with:

  • Coq 8.6
  • Ssreflect 1.6.1
  • A development version of std++

The easiest way to install the correct versions of the dependencies is through opam. Coq packages are available on the coq-released repository, set up by the command:

opam repo add coq-released https://coq.inria.fr/opam/released

Once you got opam set up, just run make build-dep to install the right versions of the dependencies. When the dependencies change, just run make build-dep again.

If you need to work with Coq 8.5, please check out the iris-3.0 branch.

Building Instructions

Run make to build the full development.

Structure

  • The folder algebra contains the COFE and CMRA constructions as well as the solver for recursive domain equations.
  • The folder base_logic defines the Iris base logic and the primitive connectives. It also contains derived constructions that are entirely independent of the choice of resources.
    • The subfolder lib contains some generally useful derived constructions. Most importantly, it defines composeable dynamic resources and ownership of them; the other constructions depend on this setup.
  • The folder program_logic specializes the base logic to build Iris, the program logic. This includes weakest preconditions that are defined for any language satisfying some generic axioms, and some derived constructions that work for any such language.
  • The folder proofmode contains the Iris proof mode, which extends Coq with contexts for persistent and spatial Iris assertions. It also contains tactics for interactive proofs in Iris. Documentation can be found in ProofMode.md.
  • The folder heap_lang defines the ML-like concurrent heap language
  • The folder tests contains modules we use to test our infrastructure. Users of the Iris Coq library should not depend on these modules; they may change or disappear without any notice.

Documentation

A LaTeX version of the core logic definitions and some derived forms is available in docs/iris.tex. A compiled PDF version of this document is available online.