• Top
    • Documentation
    • Books
    • Recursion-and-induction
    • Boolean-reasoning
    • Projects
    • Debugging
    • Std
      • Std/lists
      • Std/alists
      • Obags
      • Std/util
      • Std/strings
      • Std/io
      • Std/osets
      • Std/system
        • Fresh-logical-name-with-$s-suffix
        • Irrelevant-formals-info
        • Std/system/function-queries
          • Defun-sk-queries
          • Tail-recursive-p
          • Termination-theorem$
          • Measure
          • Arity+
          • Unwrapped-nonexec-body+
          • Ubody
          • Ruler-extenders+
          • Recursive-calls
          • Guard-theorem-no-simplify$
          • Well-founded-relation+
            • Unwrapped-nonexec-body
            • Measured-subset+
            • Measure+
            • Ruler-extenders
            • Number-of-results+
            • Induction-machine+
            • Non-executablep+
            • Pure-raw-p
            • Irecursivep+
            • Formals+
            • Stobjs-out+
            • Induction-machine
            • Definedp+
            • Number-of-results
            • Ubody+
            • Guard-theorem-no-simplify
            • Uguard
            • Rawp
            • Irecursivep
            • Defchoose-queries
            • Uguard+
            • Stobjs-in+
            • No-stobjs-p+
            • Well-founded-relation
            • Definedp
            • Primitivep+
            • Guard-verified-p+
            • No-stobjs-p
            • Measured-subset
            • Guard-verified-p
            • Primitivep
            • Non-executablep
            • Fundef-enabledp
            • Fundef-disabledp
            • Ibody
            • Std/system/arity
          • Std/system/term-queries
          • Std/system/term-transformations
          • Std/system/enhanced-utilities
          • Install-not-normalized-event-lst
          • Install-not-normalized-event
          • Std/system/term-function-recognizers
          • Pseudo-tests-and-call-listp
          • Genvar$
          • Std/system/event-name-queries
          • Maybe-pseudo-event-formp
          • Add-suffix-to-fn-or-const
          • Chk-irrelevant-formals-ok
          • Std/system/good-atom-listp
          • Pseudo-tests-and-callp
          • Table-alist+
          • Add-suffix-to-fn-or-const-lst
          • Known-packages+
          • Add-suffix-to-fn-lst
          • Unquote-term
          • Event-landmark-names
          • Add-suffix-lst
          • Std/system/theorem-queries
          • Unquote-term-list
          • Std/system/macro-queries
          • Pseudo-event-landmark-listp
          • Pseudo-command-landmark-listp
          • Install-not-normalized$
          • Rune-disabledp
          • Known-packages
          • Std/system/partition-rest-and-keyword-args
          • Rune-enabledp
          • Included-books
          • Std/system/pseudo-event-formp
          • Std/system/plist-worldp-with-formals
          • Std/system/w
          • Std/system/geprops
          • Std/system/arglistp
          • Std/system-extensions
          • Std/system/constant-queries
        • Std/basic
        • Std/typed-lists
        • Std/bitsets
        • Std/testing
        • Std/typed-alists
        • Std/stobjs
        • Std-extensions
      • Proof-automation
      • Macro-libraries
      • ACL2
      • Interfacing-tools
      • Hardware-verification
      • Software-verification
      • Testing-utilities
      • Math
    • Std/system/function-queries

    Well-founded-relation+

    Enhanced variant of well-founded-relation.

    Signature
    (well-founded-relation+ fn wrld) → well-founded-relation
    Arguments
    fn — Guard (symbolp fn).
    wrld — Guard (plist-worldp wrld).
    Returns
    well-founded-relation — Type (symbolp well-founded-relation).

    This returns the same result as well-founded-relation, but it is guard-verified and includes a run-time check (which should always succeed) on the result that allows us to prove the return type theorem without strengthening the guard on wrld. This utility also includes a run-time check (which should always succeed) on the form of the justification property of the function that allows us to verify the guards without strengthening the guard of wrld. Furthermore, this utility causes an error if called on a symbol that does not name a recursive logic-mode function; the reason for ensuring logic-mode is that recursive program-mode functions do not have a well-founded relation.

    Definitions and Theorems

    Function: well-founded-relation+

    (defun
     well-founded-relation+ (fn wrld)
     (declare (xargs :guard (and (symbolp fn) (plist-worldp wrld))))
     (let
      ((__function__ 'well-founded-relation+))
      (declare (ignorable __function__))
      (if
       (not (irecursivep+ fn wrld))
       (raise "The function ~x0 is not recursive." fn)
       (b*
        ((justification (getpropc fn 'justification nil wrld))
         ((unless (weak-justification-p justification))
          (raise
           "Internal error: ~
                      the justification ~x0 of ~x1 is not well-formed."
           justification fn))
         (well-founded-relation
              (access justification justification :rel))
         ((unless (symbolp well-founded-relation))
          (raise
           "Internal error: ~
                      the well-founded relation ~x0 of ~x1 is not a symbol."
           well-founded-relation fn)))
        well-founded-relation))))

    Theorem: symbolp-of-well-founded-relation+

    (defthm
         symbolp-of-well-founded-relation+
         (b* ((well-founded-relation (well-founded-relation+ fn wrld)))
             (symbolp well-founded-relation))
         :rule-classes :rewrite)