1. 17 Sep, 2017 1 commit
2. 24 Mar, 2017 4 commits
• Make big_opL type class opaque. · 02a0929d
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.```
• Generic big operators that are no longer tied to CMRAs. · 6fbff46e
Robbert Krebbers authored
```Instead, I have introduced a type class `Monoid` that is used by the big operators:

Class Monoid {M : ofeT} (o : M → M → M) := {
monoid_unit : M;
monoid_ne : NonExpansive2 o;
monoid_assoc : Assoc (≡) o;
monoid_comm : Comm (≡) o;
monoid_left_id : LeftId (≡) monoid_unit o;
monoid_right_id : RightId (≡) monoid_unit o;
}.

Note that the operation is an argument because we want to have multiple monoids over
the same type (for example, on `uPred`s we have monoids for `∗`, `∧`, and `∨`). However,
we do bundle the unit because:

- If we would not, the unit would appear explicitly in an implicit argument of the
big operators, which confuses rewrite. By bundling the unit in the `Monoid` class
it is hidden, and hence rewrite won't even see it.
- The unit is unique.

We could in principle have big ops over setoids instead of OFEs. However, since we do
not have a canonical structure for bundled setoids, I did not go that way.```
• Remove Hints and Instances that are no longer needed. · c52ff261
Robbert Krebbers authored
```Big ops over list with a cons reduce, hence these just follow
immediately from conversion.```
3. 15 Mar, 2017 1 commit
4. 14 Mar, 2017 1 commit
5. 09 Feb, 2017 2 commits
6. 06 Feb, 2017 1 commit
7. 22 Jan, 2017 1 commit
8. 06 Jan, 2017 1 commit
• Renaming in prelude/list. · ddf8ef49
Robbert Krebbers authored
```Rename:

- prefix_of -> prefix and suffix_of -> suffix because that saves keystrokes
in lemma names. However, keep the infix notations with l1 `prefix_of` l2 and
l1 `suffix_of` l2 because those are easier to read.
- change the notation l1 `sublist` l2 into l1 `sublist_of` l2 to be consistent.
- rename contains -> submseteq and use the notation ⊆+```
9. 05 Jan, 2017 1 commit
10. 03 Jan, 2017 1 commit
11. 20 Dec, 2016 1 commit
12. 09 Dec, 2016 2 commits
13. 06 Dec, 2016 1 commit
14. 05 Dec, 2016 1 commit
15. 02 Dec, 2016 1 commit
16. 29 Nov, 2016 1 commit
17. 27 Nov, 2016 2 commits
18. 24 Nov, 2016 2 commits
19. 22 Nov, 2016 2 commits
20. 21 Nov, 2016 3 commits
21. 20 Nov, 2016 1 commit
22. 19 Nov, 2016 1 commit
23. 03 Nov, 2016 1 commit
• Use symbol ∗ for separating conjunction. · cc31476d
Robbert Krebbers authored
```The old choice for ★ was a arbitrary: the precedence of the ASCII asterisk *
was fixed at a wrong level in Coq, so we had to pick another symbol. The ★ was
a random choice from a unicode chart.

The new symbol ∗ (as proposed by David Swasey) corresponds better to
conventional practise and matches the symbol we use on paper.```
24. 25 Oct, 2016 1 commit
25. 03 Oct, 2016 1 commit
26. 28 Sep, 2016 5 commits