++ 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)

**Type: **Type

fricas

size()$X

**Type: **NonNegativeInteger

?
fricas

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

fricas

Compiling function G694 with type NonNegativeInteger -> Boolean

**Type: **List(Product(IntegerMod

?(3),

Set(PrimeField?(3))))
fricas

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

**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]

**Type: **List(Product(IntegerMod

?(3),

Set(PrimeField?(3))))