1. 04 Nov, 2017 1 commit
  2. 01 Nov, 2017 1 commit
    • Robbert Krebbers's avatar
      Add an `AsVal` type class. · b2ed0162
      Robbert Krebbers authored
      This class, in combination with `TCForall`, turns out the useful in
      LambdaRust to express that lists of expressions are values.
  3. 29 Oct, 2017 2 commits
  4. 26 Oct, 2017 1 commit
  5. 25 Oct, 2017 3 commits
  6. 04 Oct, 2017 2 commits
  7. 27 Sep, 2017 1 commit
    • Robbert Krebbers's avatar
      Fix issue #99. · 7ed067a9
      Robbert Krebbers authored
      This causes a bit of backwards incompatibility: it may now succeed with
      later stripping below unlocked/TC transparent definitions. This problem
      actually occured for `wsat`.
  8. 26 Sep, 2017 1 commit
    • Robbert Krebbers's avatar
      Fix issue #98. · e17ac4ad
      Robbert Krebbers authored
      We used to normalize the goal, and then checked whether it was of
      a certain shape. Since `uPred_valid P` normalized to `True ⊢ P`,
      there was no way of making a distinction between the two, hence
      `True ⊢ P` was treated as `uPred_valid P`.
      In this commit, I use type classes to check whether the goal is of
      a certain shape. Since we declared `uPred_valid` as `Typeclasses
      Opaque`, we can now make a distinction between `True ⊢ P` and
      `uPred_valid P`.
  9. 25 Sep, 2017 6 commits
  10. 24 Sep, 2017 1 commit
  11. 20 Sep, 2017 1 commit
  12. 09 Sep, 2017 2 commits
  13. 20 Aug, 2017 1 commit
  14. 13 Apr, 2017 1 commit
  15. 24 Mar, 2017 2 commits
    • Robbert Krebbers's avatar
    • Robbert Krebbers's avatar
      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.
  16. 15 Mar, 2017 5 commits
  17. 14 Mar, 2017 4 commits
    • Robbert Krebbers's avatar
      Misc properties about languages. · 4e1bdcc7
      Robbert Krebbers authored
    • Robbert Krebbers's avatar
      Define `fill` in terms of a `foldl` over `fill_item`. · 6fc9c27e
      Robbert Krebbers authored
      This has some advantages:
      - Evaluation contexts behave like a proper "Huet's zipper", and thus:
        + We no longer need to reverse the list of evaluation context items in the
          `reshape_expr` tactic.
        + The `fill` function becomes tail-recursive.
      - It gives rise to more definitional equalities in simulation proofs using
        binary logical relations proofs.
        In the case of binary logical relations, we simulate an expressions in some
        ambient context, i.e. `fill K e`. Now, whenever we reshape `e` by turning it
        into `fill K' e'`, we end up with `fill K (fill K' e')`. In order to use the
        rules for the expression that is being simulated, we need to turn
        `fill K (fill K' e')` into `fill K'' e'` for some `K'`. In case of the old
        `foldr`-based approach, we had to rewrite using the lemma `fill_app` to
        achieve that. However, in case of the old `foldl`-based `fill`, we have that
        `fill K (fill K' e')` is definitionally equal to `fill (K' ++ K) e'` provided
        that `K'` consists of a bunch of `cons`es (which is always the case, since we
        obtained `K'` by reshaping `e`).
      Note that this change hardly affected `heap_lang`. Only the proof of
      `atomic_correct` broke. I fixed this by proving a more general lemma
      `ectxi_language_atomic` about `ectxi`-languages, which should have been there
      in the first place.
    • Robbert Krebbers's avatar
    • Robbert Krebbers's avatar
      Extend specialization patterns. · 87a8a19c
      Robbert Krebbers authored
      - Support for a `//` modifier to close the goal using `done`.
      - Support for framing in the `[#]` specialization pattern for
        persistent premises, i.e. `[# $H1 $H2]`
      - Add new "auto framing patterns" `[$]`, `[# $]` and `>[$]` that
        will try to solve the premise by framing. Hypothesis that are
        not framed are carried over to the next goal.
  18. 10 Mar, 2017 1 commit
  19. 09 Mar, 2017 2 commits
  20. 11 Feb, 2017 1 commit
  21. 27 Jan, 2017 1 commit