This page is to streamline the scheme to find the ZD subspace which holds the seed t+1. We consolidate some of the code and make the seed ZD a parameter.

Start with these definitions and definitions for rref, minspan and rank then: 

(define (P a) (if (null? a) '(()) (let ((c (car a))) (let L ((x (P (cdr a))))
    (if (null? x) '() (cons (car x) (cons (cons c (car x)) (L (cdr x)))))))))
(define (lm x)(if (null? x) C1 (C* (car x) (lm (cdr x)))))
; (define CB (map lm (map reverse (P (reverse basis)))))
(define Pb (map reverse (P basis)))
(define (BB T) (map numlist
  (map (lambda (p) (C* p T)) (map lm (map reverse Pb)))))
(define (trn x) (if (null? (car x)) '()
   (cons (map car x) (trn (map cdr x)))))
(define (numlist a) (let nl ((a a)(b '())) (if (number? a) (cons a b)
    (nl (car a) (nl (cdr a) b)))))
(define (treestr x) (let ld ((x x)) (if (and (pair? x)(null? (cdr x))) (car x)
  (ld (let z ((x x)) (if (and (pair? x)(pair? (cdr x)))
    (cons (cons (car x)(cadr x)) (z (cddr x))) '()))))))
(define (trl x)(numlist (tr (treestr x))))
P above returns the set of subsets of its argument. All sets represented as lists.
lm returns the product of the Clifford numbers in its input list.
Pb is the set of subsets of the basis of V.
BB multiplies its cn argument by each base vector of C and returns the list.
numlist and treestr interconvert between the vector formats used in Clifford arithmetic and the general vector packages.

If b is a right ZD (ab=0) then b† is a left ZD (b†a† = (ab)† = 0† = 0). 

(let ((a (Cr))(b (Cr))) (C= (C* (tr a)(tr b))(tr (C* b a)))) ;=> #t
We will seek left ZDs and then the right ZDs are found thru the † (tr) operator.

I recapitulate the discovered ZD thus: 

(define g12 (C* g1 g2))
(define g012 (C* g0 g12))
(define g023 (C* g0 (C* g2 g3)))
(define g0123 (C* g012 g3))
; the next 3 lines each demonstrate a zero factoring.
(C* (C+ g12 g3) (-- g12 g3))
(C* (C+ g3 g012) (C+ g1 g023))
(C* (C+ C1 g0123) (-- C1 g0123))
Then each of these belong to an 8D sub space as discovered by the BB procedure: 
(define ls (list (C+ g12 g3) (tr (-- g12 g3)) (C+ g3 g012) (tr (C+ g1 g023)) (C+ C1 g0123) (tr (-- C1 g0123))))
(define als (map minspan (map BB ls)))
(map rank als) ;=> (8 8 8 8 8 8)
(map (lambda (x) (map (lambda (y) (rank (append x y))) als)) als) ; => 
; ((8 8 16 16 16 16) (8 8 16 16 16 16) (16 16 8 16 8 16)
; (16 16 16 8 16 8) (16 16 8 16 8 16) (16 16 16 8 16 8))
When (rank (append x y)) = (+ (rank x)(rank y)) then the spaces spanned by x and y are disjoint (except for 0 of course). Numbering the elements of als from 0 thru 5 we see that 0 and 1 span the same space as do 2 and 4 and also 3 and 5. We now list our 3 distinct spaces as als2: 
(define als2 (apply (lambda (s0 s1 s2 s3 s4 s5)(list s0 s2 s3)) als))
(map (lambda (x) (map (lambda (y) (rank (append x y))) als2))
  (map (lambda (x) (map trl x)) als2)) ;=>  ((12 12 12) (12 12 12) (12 12 12))
Thus we have 4 4D ambidextrous ZD subspaces. Spanning sets for the 4 distinct spaces of ZDs are:
Consider this useful detour.
Here is code to find the intersection of two subspaces.