help links subscribe changes refresh edit

	Tuples Products And Records
#187 trouble with tuples ←	↑

Cartesian Product

Edit detail for Cartesian Product revision 3 of 4

	1 2 3 4
Editor: Bill Page Time: 2008/05/20 18:53:17 GMT-7
Note: two minute time limit test

changed:
-From BillPage Tue May 20 18:49:34 -0700 2008
-From: Bill Page
-Date: Tue, 20 May 2008 18:49:34 -0700
-Subject: break
-Message-ID: <20080520184934-0700@axiom-wiki.newsynthesis.org>
-
-\begin{axiom}
-for i in 1.. repeat 0
-\end{axiom}

++ This domain implements cartesian product

fricas

)show Product

 Product(A: SetCategory,B: SetCategory)  is a domain constructor
 Abbreviation for Product is PRODUCT 
 This constructor is not exposed in this frame.
------------------------------- Operations --------------------------------
 ?=? : (%,%) -> Boolean                coerce : % -> OutputForm
 construct : (A,B) -> %                first : % -> A
 hash : % -> SingleInteger             latex : % -> String
 second : % -> B                       ?~=? : (%,%) -> Boolean
 ?*? : (Integer,%) -> % if A has ABELGRP and B has ABELGRP
 ?*? : (NonNegativeInteger,%) -> % if A has ABELGRP and B has ABELGRP or A has ABELMON and B has ABELMON or A has CABMON and B has CABMON or A has OAMONS and B has OAMONS
 ?*? : (PositiveInteger,%) -> % if A has ABELGRP and B has ABELGRP or A has ABELMON and B has ABELMON or A has CABMON and B has CABMON or A has OAMONS and B has OAMONS
 ?*? : (%,%) -> % if A has GROUP and B has GROUP or A has MONOID and B has MONOID
 ?+? : (%,%) -> % if A has ABELGRP and B has ABELGRP or A has ABELMON and B has ABELMON or A has CABMON and B has CABMON or A has OAMONS and B has OAMONS
 ?-? : (%,%) -> % if A has ABELGRP and B has ABELGRP
 -? : % -> % if A has ABELGRP and B has ABELGRP
 ?/? : (%,%) -> % if A has GROUP and B has GROUP
 ?<? : (%,%) -> Boolean if A has OAMONS and B has OAMONS or A has ORDSET and B has ORDSET
 ?<=? : (%,%) -> Boolean if A has OAMONS and B has OAMONS or A has ORDSET and B has ORDSET
 ?>? : (%,%) -> Boolean if A has OAMONS and B has OAMONS or A has ORDSET and B has ORDSET
 ?>=? : (%,%) -> Boolean if A has OAMONS and B has OAMONS or A has ORDSET and B has ORDSET
 1 : () -> % if A has GROUP and B has GROUP or A has MONOID and B has MONOID
 0 : () -> % if A has ABELGRP and B has ABELGRP or A has ABELMON and B has ABELMON or A has CABMON and B has CABMON or A has OAMONS and B has OAMONS
 ?^? : (%,Integer) -> % if A has GROUP and B has GROUP
 ?^? : (%,NonNegativeInteger) -> % if A has GROUP and B has GROUP or A has MONOID and B has MONOID
 ?^? : (%,PositiveInteger) -> % if A has GROUP and B has GROUP or A has MONOID and B has MONOID
 commutator : (%,%) -> % if A has GROUP and B has GROUP
 conjugate : (%,%) -> % if A has GROUP and B has GROUP
 convert : % -> InputForm if A has FINITE and B has FINITE
 enumerate : () -> List(%) if A has FINITE and B has FINITE
 hashUpdate! : (HashState,%) -> HashState
 index : PositiveInteger -> % if A has FINITE and B has FINITE
 inv : % -> % if A has GROUP and B has GROUP
 lookup : % -> PositiveInteger if A has FINITE and B has FINITE
 max : (%,%) -> % if A has OAMONS and B has OAMONS or A has ORDSET and B has ORDSET
 min : (%,%) -> % if A has OAMONS and B has OAMONS or A has ORDSET and B has ORDSET
 one? : % -> Boolean if A has GROUP and B has GROUP or A has MONOID and B has MONOID
 opposite? : (%,%) -> Boolean if A has ABELGRP and B has ABELGRP or A has ABELMON and B has ABELMON or A has CABMON and B has CABMON or A has OAMONS and B has OAMONS
 random : () -> % if A has FINITE and B has FINITE
 recip : % -> Union(%,"failed") if A has GROUP and B has GROUP or A has MONOID and B has MONOID
 sample : () -> % if A has ABELGRP and B has ABELGRP or A has ABELMON and B has ABELMON or A has CABMON and B has CABMON or A has GROUP and B has GROUP or A has MONOID and B has MONOID or A has OAMONS and B has OAMONS
 size : () -> NonNegativeInteger if A has FINITE and B has FINITE
 smaller? : (%,%) -> Boolean if A has OAMONS and B has OAMONS or A has ORDSET and B has ORDSET
 subtractIfCan : (%,%) -> Union(%,"failed") if A has ABELGRP and B has ABELGRP or A has CABMON and B has CABMON or A has OAMONS and B has OAMONS
 sup : (%,%) -> % if A has OAMONS and B has OAMONS
 zero? : % -> Boolean if A has ABELGRP and B has ABELGRP or A has ABELMON and B has ABELMON or A has CABMON and B has CABMON or A has OAMONS and B has OAMONS

spad

)abbrev domain PRODUCT Product
Product (A:SetCategory,B:SetCategory) : C == T
 where
  C == SetCategory  with
       if A has Finite and B has Finite then Finite
       if A has Monoid and B has Monoid then Monoid
       if A has AbelianMonoid and B has AbelianMonoid then AbelianMonoid
       if A has CancellationAbelianMonoid and
          B has CancellationAbelianMonoid then CancellationAbelianMonoid
       if A has Group  and B has Group  then  Group
       if A has AbelianGroup and B has AbelianGroup then  AbelianGroup
       if A has OrderedAbelianMonoidSup and B has OrderedAbelianMonoidSup
                                             then OrderedAbelianMonoidSup
       if A has OrderedSet and B has OrderedSet then  OrderedSet

       makeprod     : (A,B) -> %
        ++ makeprod(a,b) \undocumented
       selectfirst  :   %   -> A
        ++ selectfirst(x) \undocumented
       selectsecond :   %   -> B
        ++ selectsecond(x) \undocumented

  T == add

    --representations
       Rep := Record(acomp:A,bcomp:B)

    --declarations
       x,y: %
       i: NonNegativeInteger
       p: NonNegativeInteger
       a: A
       b: B
       d: Integer

    --define
       coerce(x):OutputForm == paren [(x.acomp)::OutputForm,
                                      (x.bcomp)::OutputForm]
       x=y ==
           x.acomp = y.acomp => x.bcomp = y.bcomp
           false
       makeprod(a:A,b:B) :%   == [a,b]

       selectfirst(x:%) : A   == x.acomp

       selectsecond (x:%) : B == x.bcomp

       if A has Monoid and B has Monoid then
          1 == [1$A,1$B]
          x * y == [x.acomp * y.acomp,x.bcomp * y.bcomp]
          x ** p == [x.acomp ** p ,x.bcomp ** p]

       if A has Finite and B has Finite then
          size == size$A * size$B
          index(n) == [index((((n::Integer-1) quo size$B )+1)::PositiveInteger)$A,
                       index((((n::Integer-1) rem size$B )+1)::PositiveInteger)$B]
          random() == [random()$A,random()$B]
          lookup(x) == ((lookup(x.acomp)$A::Integer-1) * size$B::Integer +
                        lookup(x.bcomp)$B::Integer)::PositiveInteger
          hash(x) == hash(x.acomp)$A * size$B::SingleInteger + hash(x.bcomp)$B

       if A has Group and B has Group then
          inv(x) == [inv(x.acomp),inv(x.bcomp)]

       if A has AbelianMonoid and B has AbelianMonoid then
          0 == [0$A,0$B]

          x + y == [x.acomp + y.acomp,x.bcomp + y.bcomp]

          c:NonNegativeInteger * x == [c * x.acomp,c*x.bcomp]

       if A has CancellationAbelianMonoid and
          B has CancellationAbelianMonoid then
            subtractIfCan(x, y) : Union(%,"failed") ==
              (na:= subtractIfCan(x.acomp, y.acomp)) case "failed" => "failed"
              (nb:= subtractIfCan(x.bcomp, y.bcomp)) case "failed" => "failed"
              [na::A,nb::B]

       if A has AbelianGroup and B has AbelianGroup then
          - x == [- x.acomp,-x.bcomp]
          (x - y):% == [x.acomp - y.acomp,x.bcomp - y.bcomp]
          d * x == [d * x.acomp,d * x.bcomp]

       if A has OrderedAbelianMonoidSup and B has OrderedAbelianMonoidSup then
          sup(x,y) == [sup(x.acomp,y.acomp),sup(x.bcomp,y.bcomp)]

       if A has OrderedSet and B has OrderedSet then
          x < y ==
               xa:= x.acomp ; ya:= y.acomp
               xa < ya => true
               xb:= x.bcomp ; yb:= y.bcomp
               xa = ya => (xb < yb)
               false

--     coerce(x:%):Symbol ==
--      PrintableForm()
--      formList([x.acomp::Expression,x.bcomp::Expression])$PrintableForm

spad

   Compiling FriCAS source code from file 
      /var/lib/zope2.10/instance/axiom-wiki/var/LatexWiki/8594176356433254296-25px002.spad
      using old system compiler.
   PRODUCT abbreviates domain Product 
******** Spad syntax error detected ********
Expected: BACKTAB
The prior line was:

   50>           x * y == [x.acomp * y.acomp,x.bcomp * y.bcomp]

The current line is:

   51>           x ** p == [x.acomp ** p ,x.bcomp ** p]

The number of valid tokens is 1.
The prior token was #S(TOKEN :SYMBOL |x| :TYPE IDENTIFIER :NONBLANK 51)
The current token is #S(TOKEN :SYMBOL POWER :TYPE KEYWORD :NONBLANK 51)

fricas

X:=Product(IntegerMod 3,Set PF 3)

$\label{eq1}\hbox{\axiomType{Product}\ } (\hbox{\axiomType{IntegerMod}\ } (3) , \hbox{\axiomType{Set}\ } (\hbox{\axiomType{PrimeField}\ } (3)))$

(1)

Type: Type

fricas

size()$X

$\label{eq2}24$

(2)

Type: NonNegativeInteger?

fricas

[index(i)$X for i in 1..size()$X::PositiveInteger]

fricas

Compiling function G694 with type NonNegativeInteger -> Boolean

$\label{eq3}\begin{array}{@{}l} \displaystyle \left[{\left[ 1, \:{\left\{ \right\}}\right]}, \:{\left[ 1, \:{\left\{ 1 \right\}}\right]}, \:{\left[ 1, \:{\left\{ 2 \right\}}\right]}, \:{\left[ 1, \:{\left\{ 1, \: 2 \right\}}\right]}, \:{\left[ 1, \:{\left\{ 0 \right\}}\right]}, \:{\left[ 1, \:{\left\{ 1, \: 0 \right\}}\right]}, \: \right. \ \ \displaystyle \left.{\left[ 1, \:{\left\{ 2, \: 0 \right\}}\right]}, \:{\left[ 1, \:{\left\{ 1, \: 2, \: 0 \right\}}\right]}, \:{\left[ 2, \:{\left\{ \right\}}\right]}, \:{\left[ 2, \:{\left\{ 1 \right\}}\right]}, \:{\left[ 2, \:{\left\{ 2 \right\}}\right]}, \:{\left[ 2, \:{\left\{ 1, \: 2 \right\}}\right]}, \right. \ \ \displaystyle \left.\:{\left[ 2, \:{\left\{ 0 \right\}}\right]}, \:{\left[ 2, \:{\left\{ 1, \: 0 \right\}}\right]}, \:{\left[ 2, \:{\left\{ 2, \: 0 \right\}}\right]}, \:{\left[ 2, \:{\left\{ 1, \: 2, \: 0 \right\}}\right]}, \:{\left[ 0, \:{\left\{ \right\}}\right]}, \: \right. \ \ \displaystyle \left.{\left[ 0, \:{\left\{ 1 \right\}}\right]}, \:{\left[ 0, \:{\left\{ 2 \right\}}\right]}, \:{\left[ 0, \:{\left\{ 1, \: 2 \right\}}\right]}, \:{\left[ 0, \:{\left\{ 0 \right\}}\right]}, \:{\left[ 0, \:{\left\{ 1, \: 0 \right\}}\right]}, \:{\left[ 0, \:{\left\{ 2, \: 0 \right\}}\right]}, \: \right. \ \ \displaystyle \left.{\left[ 0, \:{\left\{ 1, \: 2, \: 0 \right\}}\right]}\right]$

(3)

Type: List(Product(IntegerMod?(3),Set(PrimeField?(3))))

fricas

reduce(_and,[(lookup(index(i)$X)=i)::Boolean for i in 1..size()$X::PositiveInteger])

$\label{eq4} \mbox{\rm true}$

(4)

Type: Boolean

fricas

lookup(makeprod(2,[2])$X)

   The function makeprod is not implemented in Product(IntegerMod(3),
      Set(PrimeField(3))) .
[random()$X for i in 1..5]

$\label{eq5}\left[{\left[ 0, \:{\left\{ 2, \: 0 \right\}}\right]}, \:{\left[ 2, \:{\left\{ 1 \right\}}\right]}, \:{\left[ 0, \:{\left\{ 1, \: 2, \: 0 \right\}}\right]}, \:{\left[ 1, \:{\left\{ 1 \right\}}\right]}, \:{\left[ 2, \:{\left\{ 1, \: 2 \right\}}\right]}\right]$

(5)

Type: List(Product(IntegerMod?(3),Set(PrimeField?(3))))