		Search-engine friendly clone of the ACL2 documentation.

Renaming-variables

Var-renamevar

Check if two variables are related by variable renaming.

Signature
(var-renamevar old new ren) → _
Arguments: old — Guard (identifierp old).; new — Guard (identifierp new).; ren — Guard (renamingp ren).
Returns: _ — Type (reserr-optionp _).

We check if the two variables form a pair in the renaming list.

Definitions and Theorems

Function: var-renamevar

(defun var-renamevar (old new ren)
  (declare (xargs :guard (and (identifierp old)
                              (identifierp new)
                              (renamingp ren))))
  (let ((__function__ 'var-renamevar))
    (declare (ignorable __function__))
    (b* ((old (identifier-fix old))
         (new (identifier-fix new)))
      (if (member-equal (cons old new)
                        (renaming->list ren))
          nil
        (reserrf (list :mismatch
                       old new (renaming-fix ren)))))))

Theorem: reserr-optionp-of-var-renamevar

(defthm reserr-optionp-of-var-renamevar
  (b* ((_ (var-renamevar old new ren)))
    (reserr-optionp _))
  :rule-classes :rewrite)

Theorem: var-renamevar-of-identifier-fix-old

(defthm var-renamevar-of-identifier-fix-old
  (equal (var-renamevar (identifier-fix old)
                        new ren)
         (var-renamevar old new ren)))

Theorem: var-renamevar-identifier-equiv-congruence-on-old

(defthm var-renamevar-identifier-equiv-congruence-on-old
  (implies (identifier-equiv old old-equiv)
           (equal (var-renamevar old new ren)
                  (var-renamevar old-equiv new ren)))
  :rule-classes :congruence)

Theorem: var-renamevar-of-identifier-fix-new

(defthm var-renamevar-of-identifier-fix-new
  (equal (var-renamevar old (identifier-fix new)
                        ren)
         (var-renamevar old new ren)))

Theorem: var-renamevar-identifier-equiv-congruence-on-new

(defthm var-renamevar-identifier-equiv-congruence-on-new
  (implies (identifier-equiv new new-equiv)
           (equal (var-renamevar old new ren)
                  (var-renamevar old new-equiv ren)))
  :rule-classes :congruence)

Theorem: var-renamevar-of-renaming-fix-ren

(defthm var-renamevar-of-renaming-fix-ren
  (equal (var-renamevar old new (renaming-fix ren))
         (var-renamevar old new ren)))

Theorem: var-renamevar-renaming-equiv-congruence-on-ren

(defthm var-renamevar-renaming-equiv-congruence-on-ren
  (implies (renaming-equiv ren ren-equiv)
           (equal (var-renamevar old new ren)
                  (var-renamevar old new ren-equiv)))
  :rule-classes :congruence)