• Top
  • Documentation
  • Books
  • Boolean-reasoning
  • Projects
  • Debugging
  • Std
  • Proof-automation
  • Macro-libraries
  • ACL2
    • Theories
    • Rule-classes
    • Proof-builder
    • Recursion-and-induction
    • Hons-and-memoization
    • Events
    • Parallelism
    • History
    • Programming
    • Operational-semantics
    • Real
    • Start-here
      • Gentle-introduction-to-ACL2-programming
      • ACL2-tutorial
      • About-ACL2
        • Recursion-and-induction
        • Operational-semantics
        • Soundness
        • Release-notes
          • Note-2-8
          • Note-2-7
          • Note-8-6
          • Note-8-2
          • Note-7-0
          • Note-8-5
          • Note-8-3
          • Note-8-1
          • Note-8-0
          • Note-7-1
          • Note-6-4
          • Note-2-9-3
          • Note-2-9-1
          • Note-8-4
          • Note-7-2
          • Note-6-5
          • Note-4-0
          • Note-2-9-2
          • Note-3-6
          • Note-3-3
          • Note-3-2-1
          • Note-3-0-1
          • Note-2-9-5
          • Note-2-5
          • Note-1-5
          • Note-6-1
          • Note-4-3
          • Note-4-2
          • Note-4-1
          • Note-3-5
          • Note-3-4
          • Note-3-2
          • Note-3-0-2
          • Note-2-9-4
          • Note-2-9
          • Note-1-8
          • Note-1-7
          • Note-1-6
          • Note-1-4
          • Note-1-3
          • Note-7-4
          • Note-7-3
          • Note-6-3
          • Note-6-2
          • Note-6-0
          • Note-5-0
          • Note-1-9
          • Note-2-2
          • Note-1-8-update
          • Note-3-5(r)
          • Note-2-3
          • Note-3-6-1
          • Release-notes-books
          • Note-1-2
          • Note-2-4
          • Note-2-6
          • Note-2-0
          • Note-3-0
          • Note-3-2(r)
          • Note-2-7(r)
          • Note-1-1
          • Note-3-4(r)
          • Note-3-1
          • Note-2-8(r)
          • Note-2-1
          • Note-2-9(r)
          • Note-2-6(r)
          • Note-3-1(r)
          • Note-3-0(r)
          • Note-3-0-1(r)
          • Note-2-5(r)
          • Note-4-3(r)
          • Note-4-2(r)
          • Note-4-1(r)
          • Note-4-0(r)
          • Note-3-6(r)
          • Note-3-3(r)
          • Note-3-2-1(r)
        • Version
        • Acknowledgments
        • Pre-built-binary-distributions
        • Common-lisp
        • Git-quick-start
        • Copyright
        • Building-ACL2
        • ACL2-help
        • Bibliography
    • Debugging
    • Miscellaneous
    • Output-controls
    • Macros
    • Interfacing-tools
  • Interfacing-tools
  • Hardware-verification
  • Software-verification
  • Math
  • Testing-utilities

• Release-notes

Note-3-5(r)

ACL2 Version 3.5(r) (May, 2009) Notes

Please also see note-3-5 for changes in Version 3.5 of ACL2.

This release incorporates improvements from Ruben Gamboa in support for non-standard analysis in ACL2(r), in the following ways:

ACL2(r) now supports non-classical objects that are not also numeric, e.g., non-classical cons pairs. Consequently, the built-in standard-numberp has been replaced with standardp.

If f is a classical function, the value (f x1 ... xn) is guaranteed to be standard when the xi are standard. ACL2(r) can now recognize this fact automatically, using defun-std. For example, the following can be used to assert that the square root of 2 is a standard value.

(defthm-std sqrt-2-rational
  (standardp (acl2-sqrt 2)))

More generally, the expression (f x1 ... xn) can contain free variables, but the result is guaranteed to be standard when the variables take on standard variables, as in the following:

(defthm-std sqrt-x-rational
  (implies (standardp x)
           (standardp (acl2-sqrt x))))

A potential soundness bug in encapsulate was fixed. Specifically, when a classical, constrained function is instantiated with a lambda expression containing free variables, it may produce non-standard values depending on the values of the free variables. This means that the functional instantiation cannot be used to justify a non-classical theorem. For example, consider the following sequence:

(encapsulate
  ((f (x) t))
  (local (defun f (x) x)))
(defthm-std f-x-standard
  (implies (standardp x)
           (standardp (f x))))
(defthm plus-x-standard
  (implies (standardp x)
           (standardp (+ x y)))
  :hints (("Goal"
           :use ((:functional-instance f-x-standard
                                       (f (lambda (x) (+ x y))))))))
(defthm plus-x-eps-not-standard
  (implies (standardp x)
           (not (standardp (+ x (/ (i-large-integer)))))))
(defthm nil-iff-t
  nil
  :hints (("Goal"
          :use ((:instance plus-x-standard
                           (y (/ (i-large-integer))))
                (:instance plus-x-eps-not-standard)))))

ACL2(r) also supports the introduction of non-classical functions with defchoose. These behave just as normal functions introduced with defchoose, but they have a non-classical choice property.

Finally, ACL2(r) now comes with a revamped library supporting non-standard analysis, still distributed separately as books/nonstd/. The new library uses defchoose to state more natural and useful versions of the IVT, MVT, etc. It also supports the introduction of inverse functions, e.g., logarithms. Finally, the library has much more extensive support for differentiation.