Class VECTOR-QUANTITY


Slots on this class:

Documentation:
The class of quantities which are n-dimensional vectors (first order tensor-quantities). Each vector has an associated spatial dimension and an associated physical dimension. Each vector-quantity can be decomposed into scalar components for a given orthonormal basis of the proper dimension. The physical-dimension of a scalar component of the vector-quantity is equivalent to the physical-dimension of the vector-quantity.
Instance-Of: Class
Subclass-Of: Constant-quantity, Tensor-quantity
Superclass-Of: Unit-vec


Slots on instances of this class:

Tensor-Order: 1

Equivalence Axioms:

(<=> (Vector-Quantity ?V)
     (And (Constant-Quantity ?V)
          (Tensor-Quantity ?V)
          (= (Tensor-Order ?V) 1)
          (Forall (?B ?I)
                  (=> (And (Orthonormal-Basis ?B)
                           (= (Basis.Dimension ?B)
                              (Spatial.Dimension ?V))
                           (Positive-Integer ?I)
                           (=< ?I (Spatial.Dimension ?V)))
                      (And (Defined (Vector-Component ?V ?I ?B))
                           (= (Quantity.Dimension (Vector-Component ?V
                                                                    ?I
                                                                    ?B))
                              (Quantity.Dimension ?V)))))
          (Forall (?U)
                  (=> (And (Unit-Of-Measure ?U)
                           (= (Quantity.Dimension ?U)
                              (Quantity.Dimension ?V)))
                      (Numeric-Tensor (Magnitude ?V ?U))))))


Axioms:

(Forall (?U)
        (=> (And (Unit-Of-Measure ?U)
                 (= (Quantity.Dimension ?U) (Quantity.Dimension ?V)))
            (Numeric-Tensor (Magnitude ?V ?U))))

(Forall (?B ?I)
        (=> (And (Orthonormal-Basis ?B)
                 (= (Basis.Dimension ?B) (Spatial.Dimension ?V))
                 (Positive-Integer ?I)
                 (=< ?I (Spatial.Dimension ?V)))
            (And (Defined (Vector-Component ?V ?I ?B))
                 (= (Quantity.Dimension (Vector-Component ?V ?I ?B))
                    (Quantity.Dimension ?V)))))

(Tensor-Quantity ?V)

(Constant-Quantity ?V)


Other Related Axioms:

(<= (Tensor-Order $X 1) (Vector-Quantity $X))

(<=> (Vector-Quantity ?V)
     (And (Constant-Quantity ?V)
          (Tensor-Quantity ?V)
          (= (Tensor-Order ?V) 1)
          (Forall (?B ?I)
                  (=> (And (Orthonormal-Basis ?B)
                           (= (Basis.Dimension ?B)
                              (Spatial.Dimension ?V))
                           (Positive-Integer ?I)
                           (=< ?I (Spatial.Dimension ?V)))
                      (And (Defined (Vector-Component ?V ?I ?B))
                           (= (Quantity.Dimension (Vector-Component ?V
                                                                    ?I
                                                                    ?B))
                              (Quantity.Dimension ?V)))))
          (Forall (?U)
                  (=> (And (Unit-Of-Measure ?U)
                           (= (Quantity.Dimension ?U)
                              (Quantity.Dimension ?V)))
                      (Numeric-Tensor (Magnitude ?V ?U))))))

(<=> (Unit-Vec ?V)
     (And (Vector-Quantity ?V)
          (= (Quantity.Dimension ?V) Identity-Dimension)
          (= (Dot ?V ?V) 1)))

(Nth-Domain Vector-Component 1 Vector-Quantity)

(=> (= (Vector-Component ?V ?I ?B) ?S) (Vector-Quantity ?V))

(Nth-Domain The-Vector-Quantity 3 Vector-Quantity)

(=> (= (The-Vector-Quantity ?M ?B) ?V) (Vector-Quantity ?V))

(=> (And (Vector-Quantity ?X) (Vector-Quantity ?Y))
    (=> (+ ?X ?Y ?Z)
        (And (Vector-Quantity ?Z)
             (Forall (?B ?I)
                     (=> (And (Orthonormal-Basis ?B)
                              (= (Spatial.Dimension ?X)
                                 (Basis.Dimension ?B))
                              (Positive-Integer ?I)
                              (=< ?I (Spatial.Dimension ?X)))
                         (= (Vector-Component ?Z ?I ?B)
                            (+ (Vector-Component ?X ?I ?B)
                               (Vector-Component ?Y ?I ?B))))))))

(=> (And (Vector-Quantity ?X) (- ?X ?Y))
    (And (Vector-Quantity ?Y)
         (= (+ ?X ?Y)
            (The-Zero-Vector-Of-Type (Quantity.Dimension ?X)
                                     (Spatial.Dimension ?X)))))

(=> (And (Vector-Quantity ?V1) (Dyad ?T1))
    (<=> (Dot ?V1 ?T1 ?V)
         (And (Vector-Quantity ?V)
              (Forall (?B)
                      (= ?T
                         (The-Vector-Quantity (* (Tensor-To-Matrix ?V1
                                                                   ?B)
                                                 (Tensor-To-Matrix ?T1
                                                                   ?B))
                                              ?B)))
              (Forall 
                  (?B ?I ?J)
                  (=> (= (Basis.Dimension ?B)
                         (Spatial.Dimension ?V1))
                      (= ?T
                         (Summation 
                             (Lambda 
                                 (?I)
                                 (* (Basis.Vec ?B ?I)
                                    (Summation 
                                        (Lambda (?J)
                                                (* (Vector-Component 
                                                       ?V1
                                                       ?J
                                                       ?B)
                                                   (Dyad-Component ?T1
                                                                   ?J
                                                                   ?I
                                                                   ?B)))
                                        1
                                        (Spatial.Dimension ?V1))))
                             1
                             (Spatial.Dimension ?V1))))))))

(=> (And (Dyad ?T1) (Vector-Quantity ?V1))
    (<=> (Dot ?T1 ?V1 ?V)
         (And (Vector-Quantity ?V)
              (Forall 
                  (?B)
                  (= ?T
                     (The-Vector-Quantity 
                         (Transpose (* (Tensor-To-Matrix ?T1 ?B)
                                       (Transpose (Tensor-To-Matrix 
                                                      ?V1
                                                      ?B))))
                         ?B)))
              (Forall 
                  (?B ?I ?J)
                  (=> (= (Basis.Dimension ?B)
                         (Spatial.Dimension ?V1))
                      (= ?T
                         (Summation 
                             (Lambda 
                                 (?I)
                                 (* (Basis.Vec ?B ?I)
                                    (Summation 
                                        (Lambda (?J)
                                                (* (Dyad-Component ?T1
                                                                   ?I
                                                                   ?J
                                                                   ?B)
                                                   (Vector-Component 
                                                       ?V1
                                                       ?J
                                                       ?B)))
                                        1
                                        (Spatial.Dimension ?V1))))
                             1
                             (Spatial.Dimension ?V1))))))))

(=> (And (Vector-Quantity ?V1) (Vector-Quantity ?V2))
    (<=> (Dot ?V1 ?V2 ?S)
         (And (Scalar-Quantity ?S)
              (Forall (?B)
                      (= ?S
                         (Value (* (Tensor-To-Matrix ?V1 ?B)
                                   (Transpose (Tensor-To-Matrix ?V2
                                                                ?B)))
                                11)))
              (Forall (?B ?J)
                      (=> (= (Basis.Dimension ?B)
                             (Spatial.Dimension ?V1))
                          (= ?S
                             (Summation (Lambda (?J)
                                                (* (Vector-Component 
                                                       ?V1
                                                       ?J
                                                       ?B)
                                                   (Vector-Component 
                                                       ?V2
                                                       ?J
                                                       ?B)))
                                        1
                                        (Spatial.Dimension ?V1))))))))

(=> (And (Vector-Quantity ?V1) (Scalar-Quantity ?S))
    (= (* ?V1 ?S) (* ?S ?V1)))

(=> (And (Scalar-Quantity ?S) (Vector-Quantity ?V1) (* ?S ?V1 ?V))
    (And (Vector-Quantity ?V)
         (= (Spatial.Dimension ?V1) (Spatial.Dimension ?V))
         (Forall (?B ?I)
                 (=> (= (Basis.Dimension ?B) (Spatial.Dimension ?V1))
                     (= (Vector-Component ?V ?I ?B)
                        (* ?S (Vector-Component ?V1 ?I ?B)))))))

(Nth-Domain The-Zero-Vector-Of-Type 3 Vector-Quantity)

(=> (= (The-Zero-Vector-Of-Type ?Spatdim ?Physdim) ?V0)
    (Forall (?V)
            (=> (Vector-Quantity ?V)
                (= (Dot ?V ?V0)
                   (The-Zero-Scalar-For-Dimension ?Physdim)))))

(<- (Vector-Quantities-Of-Dimensions ?Physim ?Spatdim)
    (If (And (Physical-Dimension ?Physim)
             (Positive-Integer ?Spatdim))
        (Kappa (?Vq)
               (And (Vector-Quantity ?Vq)
                    (= (Spatial.Dimension ?Vq) ?Spatdim)
                    (= (Quantity.Dimension ?Vq) ?Physim)))))