Function THE-DYAD

• Defined in theory: Tensor-quantities
• Source code: tensor-quantities.lisp

Slots on this function:

Documentation:

Constructor function for second order tensors. Requires a matrix and an orthnormal-basis as arguments. The constructed dyad is equal to the sum of products of matrix elements with the corresponding basis vectors.

Instance-Of: Function

Arity: 3

Equivalence Axioms:

(<=> (The-Dyad ?M ?B)
     (And (Matrix-Quantity ?M)
          (Square-Matrix ?M)
          (Orthonormal-Basis ?B)
          (= (Quantity.Dimension ?T) (Quantity.Dimension ?M))
          (= (Size ?M) (Basis.Dimension ?B))
          (= (Spatial.Dimension ?T) (Size ?M))
          (Dyad ?T)
          (= ?T
             (Summation (Lambda (?I)
                                (Summation (Lambda (?J)
                                                   (* (Basis.Vec ?B
                                                                 ?I)
                                                      (* (Value ?M
                                                                ?I
                                                                ?J)
                                                         (Basis.Vec ?B
                                                                    ?J))))
                                           1
                                           (Spatial.Dimension ?T)))
                        1
                        (Spatial.Dimension ?T)))))

Axioms:

(Nth-Domain The-Dyad 3 Dyad)

(Nth-Domain The-Dyad 2 Orthonormal-Basis)

(Nth-Domain The-Dyad 1 Square-Matrix)

(Nth-Domain The-Dyad 1 Matrix-Quantity)

Other Related Axioms:

(=> (= (The-Dyad ?M ?B) ?T)
    (= ?T
       (Summation (Lambda (?I)
                          (Summation (Lambda (?J)
                                             (* (Basis.Vec ?B ?I)
                                                (* (Value ?M ?I ?J)
                                                   (Basis.Vec ?B ?J))))
                                     1
                                     (Spatial.Dimension ?T)))
                  1
                  (Spatial.Dimension ?T))))

(=> (= (The-Dyad ?M ?B) ?T) (Dyad ?T))

(=> (= (The-Dyad ?M ?B) ?T) (= (Spatial.Dimension ?T) (Size ?M)))

(=> (= (The-Dyad ?M ?B) ?T) (= (Size ?M) (Basis.Dimension ?B)))

(=> (= (The-Dyad ?M ?B) ?T)
    (= (Quantity.Dimension ?T) (Quantity.Dimension ?M)))

(=> (= (The-Dyad ?M ?B) ?T) (Orthonormal-Basis ?B))

(=> (= (The-Dyad ?M ?B) ?T) (Square-Matrix ?M))

(=> (= (The-Dyad ?M ?B) ?T) (Matrix-Quantity ?M))

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

Notes:

• Example: (= (the-dyad (matrix-of-columns (matrix-of-rows (* 3 feet) (* 1 yard)) (matrix-of-rows (* 24 inches) (72 inches))) 2d-frame-n) (* (the-dyad (matrix-of-rows (matrix-of-columns 3 2) (matrix-of-columns 3 6)) 2d-frame-n) feet))