This stuff was used to track down a bug in tip. That bug has been fixed and now tip sees the right irreducible odd monics in GF(34). I leave this file for now for its useful hacks.
Swallow sets whole, and these definitions. (About using the set code) Swallow everything before “------” from poly stuff. Get Cart from here.

We deal here with GF(34) and set up tools for modulo 3 arithmetic:

```(define p 3)
(define T (gpa p))
(define i->p (T 'i->p))```
(prods q r) below produces the set of products of odd monic polynomials, the first of degree q and the 2nd of degree r.
```(define (prods q r) ; form set of all products of odd q by r monics.
(let* ((p+ (T 'p+))(p* (T 'p*))(tip (T 'tip))
(i->p (T 'i->p))(p->i (T 'p->i))(gap (T 'gap))
(f (Cart (gap q) (gap r)))(F (f))
(monq (i->p (expt p q)))(monr (i->p (expt p r))))
(let r ((R empty)) (let ((g (F))) (if g (let (
(x (p+ monq (car g)))
(y (p+ monr (cdr g))))
(if (or (zero? (vector-ref x 0)) (zero? (vector-ref y 0))) (r R)
(r (add (p->i (p* x y)) R)) )) R)))))```
then perhaps compute set of all reducible 4th degree odd monics:
`(define P34 (union (prods 2 2) (prods 1 3)))`
and all 4th degree odd monics:
```(define all4 (let ((c (expt 3 4))) (let r ((s empty)(C c))
(if (zero? C) s (let ((d (- C 1)))
(r (if (zero? (modulo d 3)) s (add (+ c d) s)) d))))))```
Note:
```(cardinal all4) ; => 54
(i->p (min_elt all4)) ; => #5(1 0 0 0 1)
(i->p (max_elt all4)) ; => #(2 2 2 2 1)```

Tip below recognizes irreducible odd monics in their integer guise:

`(define Tip (let ((tip (T 'tip))) (lambda (p) (tip (i->p p)))))`
and thence the set of 4th degree monics noticed by tip:
`(define testedp (filter Tip all4))`
It finds 18. ((cardinal testedp) ; => 18))
`(inter P34 testedp) ; => ()`
is empty; no reducible odd monics were recognized by tip. (that’s good)
`(equal (diff all4 P34) testedp) ; => #t`
The 4th degree odd monics that were not constructed as products, are exactly the same as those recognized as irreducible. (that’s good)

Here are the irreducible odd monics in GF(34):

```(map i->p (elements (diff all4 P34))) ; =>
(#5(2 1 0 0 1) #5(2 2 0 0 1) #5(2 0 1 0 1) #5(1 1 1 0 1)
#5(1 2 1 0 1) #5(2 0 2 0 1) #5(2 0 0 1 1) #5(1 2 0 1 1)
#5(1 0 1 1 1) #5(1 1 1 1 1) #5(2 2 1 1 1) #5(2 2 2 1 1) #5(2 0 0 2 1)
#5(1 1 0 2 1) #5(1 0 1 2 1) #5(2 1 1 2 1) #5(1 2 1 2 1) #5(2 1 2 2 1))```