		Search-engine friendly clone of the ACL2 documentation.

Basic-expt-normalization

Basic rules for normalizing and simplifying exponents.

Definitions and Theorems

Theorem: right-unicity-of-1-for-expt

(defthm right-unicity-of-1-for-expt
  (equal (expt r 1) (fix r)))

Theorem: expt-minus

(defthm expt-minus
  (equal (expt r (- i)) (/ (expt r i))))

Theorem: exponents-add-for-nonneg-exponents

(defthm exponents-add-for-nonneg-exponents
  (implies (and (<= 0 i)
                (<= 0 j)
                (fc (integerp i))
                (fc (integerp j)))
           (equal (expt r (+ i j))
                  (* (expt r i) (expt r j)))))

Theorem: exponents-add

(defthm exponents-add
  (implies (and (syntaxp (not (and (quotep i)
                                   (integerp (cadr i))
                                   (or (equal (cadr i) 1)
                                       (equal (cadr i) -1)))))
                (syntaxp (not (and (quotep j)
                                   (integerp (cadr j))
                                   (or (equal (cadr j) 1)
                                       (equal (cadr j) -1)))))
                (not (equal 0 r))
                (fc (acl2-numberp r))
                (fc (integerp i))
                (fc (integerp j)))
           (equal (expt r (+ i j))
                  (* (expt r i) (expt r j)))))

Theorem: exponents-add-unrestricted

(defthm exponents-add-unrestricted
  (implies (and (not (equal 0 r))
                (fc (acl2-numberp r))
                (fc (integerp i))
                (fc (integerp j)))
           (equal (expt r (+ i j))
                  (* (expt r i) (expt r j)))))

Theorem: distributivity-of-expt-over-*

(defthm distributivity-of-expt-over-*
  (equal (expt (* a b) i)
         (* (expt a i) (expt b i))))

Theorem: expt-1

(defthm expt-1 (equal (expt 1 x) 1))

Theorem: exponents-multiply

(defthm exponents-multiply
  (implies (and (fc (integerp i))
                (fc (integerp j)))
           (equal (expt (expt r i) j)
                  (expt r (* i j)))))

Theorem: functional-commutativity-of-expt-/-base

(defthm functional-commutativity-of-expt-/-base
  (equal (expt (/ r) i) (/ (expt r i))))

Theorem: equal-constant-+

(defthm equal-constant-+
  (implies (syntaxp (and (quotep c1) (quotep c2)))
           (equal (equal (+ c1 x) c2)
                  (if (acl2-numberp c2)
                      (if (acl2-numberp x)
                          (equal x (- c2 c1))
                        (equal (fix c1) c2))
                    nil))))