{ "cells": [ { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "(ql:quickload :kenzo)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "(in-package \"CAT\")" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "(cat-init)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Objects with effective homology\n", "\n", "## Introduction\n", "\n", "The present chapter describes the set of programming tools for handling *objects with effective homology*. The theoretical material may be found in the paper *Constructive Algebraic Topology* by Julio Rubio Garcia and Francis Sergeraert (Available at the web site\n", "[**https://www-fourier.ujf.grenoble.fr/~sergerar/**](https://www-fourier.ujf.grenoble.fr/~sergerar/)). The terminology used in this chapter is compatible with this reference.). The terminology used in this chapter is compatible with this reference.\n", "\n", "## Reduction\n", "\n", "A *reduction* in ``Kenzo`` is a 5-tuple $(\\hat C, C, f, g, h)$:\n", "\n", "$$\n", "\\begin{align}\n", "\\hat{C}\\quad & \\qquad\\stackrel{h}{\\longrightarrow} & \\mbox{$^s\\hat{C}$} \\\\\n", "{\\scriptstyle f} \\downarrow \\uparrow {\\scriptstyle g} & & \\\\\n", "C\\quad & &\n", "\\end{align}\n", "$$\n", "\n", "where $\\hat C$ and $C$ are chain complexes, $f$ and $g$ chain complex morphisms and\n", "$h$ a homotopy operator. Hereafter, $\\hat C$ is called the *top chain complex* and $C$ the *bottom chain complex*. ${}^s\\hat C$ is $\\hat C$ shifted, i.e. $h$ has degree $1$. The mappings $f$, $g$, $h$, together with the differential operator $d$ on $\\hat C$, must verify the following relations:\n", "\n", "$$\n", "\\begin{eqnarray*}\n", "f \\circ g & = & 1_C \\\\\n", "h \\circ d + d \\circ h & = & 1_{\\hat C} - g \\circ f \\\\\n", "f \\circ h & = & 0 \\\\\n", "h \\circ g & = & 0 \\\\\n", "h \\circ h & = & 0\n", "\\end{eqnarray*}\n", "$$\n", "\n", "The morphisms $f$ and $g$ and the homotopy operator $h$ describe the (big) chain complex $\\hat C$ as the direct sum\n", "\n", "$$ \\hat C= \\hat C_1 \\oplus \\hat C_2$$\n", "\n", "where $\\hat C_1 = Im(g) \\simeq C$ and $\\hat C_2= Ker(f)$ ($\\hat C_2$ is acyclic).\n", "\n", "### Representation of a reduction\n", "\n", "A reduction\\index{reduction!representation} is implemented as an instance of the ``CLOS`` class ``REDUCTION``, whose definition is:\n", "\n", "```lisp\n", "(DEFCLASS REDUCTION ()\n", " ;; Top Chain Complex\n", " ((tcc :type chain-complex :initarg :tcc :reader tcc1)\n", " ;; Bottom Chain Complex\n", " (bcc :type chain-complex :initarg :bcc :reader bcc1)\n", " (f :type morphism :initarg :f :reader f1)\n", " (g :type morphism :initarg :g :reader g1)\n", " (h :type morphism :initarg :h :reader h1)\n", " ;; IDentification NuMber\n", " (idnm :type fixnum :initform (incf *idnm-counter*) :reader idnm)\n", " ;; ORiGiN\n", " (orgn :type list :initarg :orgn :reader orgn)))\n", "```\n", "\n", "This class has 7 slots:\n", "\n", "1. ``tcc``, the object of type ``chain-complex`` representing the chain complex $\\hat C$ (top chain complex).\n", "2. ``bcc``, the object of type ``chain-complex`` representing the chain complex $C$ (bottom chain complex).\n", "3. ``f``, the object of type ``morphism``representing the morphism $f$.\n", "4. ``g``, the object of type ``morphism`` representing the morphism $g$.\n", "5. ``h``, the object of type ``morphism`` representing the morphism $h$.\n", "6. ``idmn``, an integer, number plate for the object.\n", "7. ``orgn``, a comment list carefully chosen.\n", "\n", "The accessors of the slots are the functions whose name appears after the specifier ``:reader`` in the class definition. A printing method has been associated to the class ``REDUCTION`` and the external representation of an instance is a string like ``[Kn Reduction]``, where ``n`` is the number plate of the ``Kenzo`` object.\n", "\n", "### The function ``build-rdct``\n", "\n", "To facilitate the construction of instances of the ``REDUCTION`` class, the\n", "software provides the function ``build-rdct``.\n", "\n", "```lisp\n", "build-rdct :f f :g g :h h :orgn orgn\n", "```\n", "\n", "defined with keyword parameters. The returned value is an instance of the class ``REDUCTION``. \n", "The keyword arguments are:\n", "\n", "- *f*, the object of type ``morphism`` representing the morphism $f$.\n", "- *g*, the object of type ``morphism`` representing the morphism $g$.\n", "- *h*, the object of type ``morphism`` representing the morphism $h$.\n", "- *orgn*, the comment list carefully chosen since the system does not build a new instance of the class if it finds in the list of already built reductions, ``*rdct-list*``, a reduction with the same comment list.\n", "\n", "The ``tcc`` slot and the ``bcc`` slot of the instance are taken respectively from the ``sorc`` slot (source slot) and the ``trgt`` slot (target slot) of the morphism $f$. The function ``build-rdc`` controls the validity of the degrees of the morphisms and pushes the new created instance on the list ``*rdct-list*``.\n", "\n", "### Useful macros and functions\n", "\n", "``(cat-init)`` *[Function]*\n", "> Clear among others, the list ``*rdct-list*``, list of user created reductions and reset the global counter to 1. See also the description of this function in chapter 1.\n", "\n", "``(rdct n)`` *[Function]*\n", "> Retrieve in the list ``*rdct-list*`` the reduction instance whose identification (as ``Kenzo`` object) is ``n``. If it does not exist, return ``NIL``.\n", "\n", "``(bcc rdct &rest args)`` *[Macro]*\n", "> With only one argument (a reduction *rdct*) this macro selects the bottom chain complex of the reduction. Otherwise, it applies the differential of the bottom chain complex of the reduction *rdc* on the arguments *args*, (either *degree generator* or *cmb*).\n", "\n", "``(tcc rdct &rest args)`` *[Macro]*\n", "> With only one argument (a reduction *rdct*) this macro selects the top chain complex of the reduction. Otherwise, it applies the differential of the top chain complex of the reduction *rdc* on the arguments *args*, (either *degree generator* or *cmb*).\n", "\n", "``(f rdct &rest args)`` *[Macro]*\n", "> With only one argument (a reduction *rdct*) this macro selects the morphism $f$ of the reduction. Otherwise, it applies the morphism $f$ of the reduction *rdc* on the arguments *args*, (either *degree generator* or *cmb*).\n", "\n", "``(g rdct &rest args)`` *[Macro]*\n", "> With only one argument (a reduction *rdct* this macro selects the morphism $g$ of the reduction. Otherwise, it applies the morphism $g$ of the reduction *rdc* on the arguments *args*, (either *degree generator* or *cmb*).\n", "\n", "``(h rdct &rest args)`` *[Macro]*\n", "> With only one argument (a reduction *rdct*) this macro selects the morphism $h$ of the reduction. Otherwise, it applies the morphism $h$ of the reduction *rdc* on the arguments *args*, (either *degree generator* or *cmb*).\n", "\n", "``(trivial-rdct chcm)`` *[Function]*\n", "> Build the trivial reduction involving only the chain complex chcm, as shown in the following diagram,\n", "$$\n", "\\begin{align}\n", " C \\quad & \\quad\\stackrel{Zero} {\\longrightarrow} & {}^s C \\\\\n", " {\\scriptstyle {Id}} \\downarrow \\uparrow {\\scriptstyle {Id}} & & \\\\\n", " C \\quad & &\n", "\\end{align}\n", "$$\n", "where the morphism *Zero* is the zero morphism of degree 1 in the chain complex $C$ and *Id* is the identity morphism in that chain complex (see the functions ``zero-mrph`` and ``idnt-mrph`` in the chain complex chapter).\n", "\n", "``(cmps brdct trdct)`` *[Method]*\n", "> Build a new reduction from the two reductions $r1$ and $r2$ (here, respectively *brdct* and *trdct*). This is done by a call to ``build-rdct`` with the following parameters:\n", "$$\n", "\\begin{eqnarray*}\n", "f & = & f_{r1}\\circ f_{r2}, \\\\\n", "g & = & g_{r2}\\circ g_{r1}, \\\\\n", "h & = & h_{r2} + g_{r2} \\circ h_{r1} \\circ f_{r2}.\n", "\\end{eqnarray*}\n", "$$\n", "The compositions and additions of morphisms are realized respectively by the methods ``cmps``, ``i-cmps`` and ``add`` (see chapter 1). We recall that the ``tcc`` and the ``bcc`` slots of this new created reduction are respectively the source and target slots of the new morphim $f$.\n", "\n", "### Verification functions\n", "\n", "The two following functions are very helpful to verify the coherence of the the various mappings involved in a reduction. Let us recall the diagram of a reduction:\n", "$$\n", "\\begin{align}\n", "\\hat{C} \\quad & \\quad\\stackrel{h}{\\longrightarrow} & \\mbox{$^s\\hat{C}$} \\\\\n", "{\\scriptstyle f} \\downarrow \\uparrow {\\scriptstyle g} & & \\\\\n", "C \\quad & &\n", "\\end{align}\n", "$$\n", "\n", "``(pre-check-rdct rdct)`` *[Function]*\n", "> Assign to the following lisp global variables, the morphism instances computed from the morphisms of the reduction *rdct*, according to the formulas:\n", "$$\n", "\\begin{align}\n", " \\mathtt{*tdd*} & = & d_{\\hat C} \\circ d_{\\hat C},\\\\\n", " \\mathtt{*bdd*} & = & d_C \\circ d_C , \\\\\n", " \\mathtt{*id-fg*} & = & f \\circ g - Id_C,\n", " \\mathtt{*id-gf-dh-hd*} & = & Id_{\\hat C} - g \\circ f - (d_{\\hat C} \\circ h + h \\circ d_{\\hat C}),\\\\\n", " \\mathtt{*hh*} & = & h \\circ h, \\\\\n", " \\mathtt{*fh*} & = & f \\circ h, \\\\\n", " \\mathtt{*hg*} & = & h \\circ g, \\\\\n", " \\mathtt{*df-fd*} & = & d_C \\circ f - f \\circ d_{\\hat C}, \\\\\n", " \\mathtt{*dg-gd*} & = & d_{\\hat C} \\circ g - g \\circ d_C.\n", "\\end{align}\n", "$$\n", "In these formulas $d_C$ and $d_{\\hat C}$ are the respective boundary operators of the\n", "chain complexes $C$ and $\\hat C$. $Id_C$ and $Id_{\\hat C}$ are the identity morphisms\n", "on the chain complexes $C$ and $\\hat C$ built by the function ``idnt-mrph``\n", "\n", "``(check-rdct)`` *[Function]*\n", "> Map all the morphisms prepared by the function *pre-check-rdct* on chosen combinations.\n", "This function having no parameters, the user must assign to the two lisp global variables:\n", "``*tc*`` and ``*bc*``, valid combinations belonging respectively to $\\hat C$ and $C$. The call to this function is simply ``(check-rdct)``. This function knows what morphism to apply\n", "to the combinations and pauses after each evaluation to allow the user to inspect each result.\n", "To resume the execution, the user must enter a blank character. If the morphisms are coherent, the result of each mapping is a null combination.\n", "\n", "#### Example" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "(defun cdelta (dmns)\n", " (build-chcm\n", " :cmpr #'l-cmpr\n", " :basis :locally-effective\n", " :bsgn '(0)\n", " :intr-dffr\n", " #'(lambda (degr gmsm)\n", " (make-cmbn\n", " :degr (1- degr)\n", " :list (do ((rslt +empty-list+\n", " (cons (cons sign\n", " (append\n", " (subseq gmsm 0 nark)\n", " (subseq gmsm (1+ nark))))\n", " rslt))\n", " (sign 1 (- sign))\n", " (nark 0 (1+ nark)))\n", " ((> nark degr) rslt))))\n", " :strt :gnrt\n", " :orgn `(locally effective version of C_* delta ,dmns)))" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "(defun make-f (tdmns bdmns)\n", " (build-mrph\n", " :sorc (cdelta tdmns) :trgt (cdelta bdmns) :degr 0\n", " :intr #'(lambda (degr gmsm)\n", " (let ((pos (position-if #'(lambda (vertex) (>= vertex bdmns))\n", " gmsm)))\n", " (if pos\n", " (if (< pos degr)\n", " (zero-cmbn degr)\n", " (cmbn degr 1 (nconc (butlast gmsm) (list bdmns))))\n", " (cmbn degr 1 gmsm))))\n", " :strt :gnrt\n", " :orgn `(projection delta ,tdmns => delta ,bdmns)))" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "(defun make-g (tdmns bdmns)\n", " (build-mrph\n", " :sorc (cdelta bdmns) :trgt (cdelta tdmns) :degr 0\n", " :intr #'identity\n", " :strt :cmbn\n", " :orgn `(injection delta ,bdmns => delta ,tdmns)))" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "(defun make-h (tdmns bdmns)\n", " (build-mrph\n", " :sorc (cdelta tdmns) :trgt (cdelta tdmns) :degr +1\n", " :intr #'(lambda (degr gmsm)\n", " (let ((pos (position-if #'(lambda (vertex) (>= vertex bdmns))\n", " gmsm)))\n", " (if pos\n", " (if (member bdmns gmsm)\n", " (zero-cmbn (1+ degr))\n", " (cmbn (1+ degr) (-1-expt-n pos)\n", " (append (subseq gmsm 0 pos) (list bdmns)\n", " (subseq gmsm pos))))\n", " (zero-cmbn (1+ degr)))))\n", " :strt :gnrt\n", " :orgn `(homotopy for delta ,tdmns => ,bdmns)))" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "(defun make-rdct (tdmns bdmns)\n", " (let ((rdct (build-rdct\n", " :f (make-f tdmns bdmns)\n", " :g (make-g tdmns bdmns)\n", " :h (make-h tdmns bdmns)\n", " :orgn `(reduction delta ,tdmns ,bdmns))))\n", " rdct))" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "(def rdct (make-rdct 6 3))" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "(orgn rdct)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "(pre-check-rdct rdct)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "(setf *tc* (cmbn 2 1 '(0 1 2) 10 '(1 2 3) 100 '(1 2 4) 1000 '(2 3 4)))" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "(setf *bc* (cmbn 3 4 '(0 1 2 3)))" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "(check-rdct-no-wait)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "(def trdct (make-rdct 6 4))" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "(def brdct (make-rdct 4 3))" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "(setf rdct (cmps brdct trdct))" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "(pre-check-rdct rdct)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "(check-rdct-no-wait)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 2.4.1 Useful functions related to the perturbation lemma\n", "#### Example" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "(def hmeq (trivial-hmeq (cdelta 4)))" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "(setf hmeq (add hmeq (opps (dffr (cdelta 4)))))" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "(gnrt-? (dffr (rbcc hmeq)) 3 '(0 1 2 3))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 2.5.1 Representation of a combination in a bicone" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "(def comb-bic (cmbn 3 2 (bcnb 'b1) 4 (bcnb 'b1) 6 (bcnb 'b3)\n", " 3 (bcnb 'c1) 5 (bcnb 'c1) 7 (bcnb 'd1)))" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "(cmbn-list comb-bic)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 2.5.2 Useful functions and macros for bicones\n", "#### Examples" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "(def comb-b (cmbn 3 2 'b1 4 'b2 6 'b3))" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "(def comb-c (cmbn 4 3 'c1 5 'c2))" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "(def comb-d (cmbn 3 7 'd1))" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "(def comb-bic (make-bicn-cmbn comb-b comb-c comb-d))" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "(bicn-cmbn-cmbnb comb-bic)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "(bicn-cmbn-cmbnc comb-bic)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "(bicn-cmbn-cmbnd comb-bic)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "(multiple-value-bind (b c d)\n", " (dispatch-bicn-cmbn comb-bic)\n", " (list b c d))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 2.6 Construction of a bicone from 2 reductions\n", "#### Example" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "(cat-init)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "(defun cdelta (dmns)\n", " (build-chcm\n", " :cmpr #'l-cmpr\n", " :basis #'(lambda (n)\n", " (mapcar #'dlop-int-ext (funcall (delta-n-basis dmns) n)))\n", " :bsgn '(0)\n", " :intr-dffr\n", " #'(lambda (degr gmsm)\n", " (make-cmbn\n", " :degr (1- degr)\n", " :list (do ((rslt +empty-list+\n", " (cons (cons sign\n", " (append\n", " (subseq gmsm 0 nark)\n", " (subseq gmsm (1+ nark))))\n", " rslt))\n", " (sign 1 (- sign))\n", " (nark 0 (1+ nark)))\n", " ((> nark degr) rslt))))\n", " :strt :gnrt\n", " :orgn `(Effective version of C_* delta ,dmns)))" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "(def delta3 (cdelta 3))" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "(basis delta3 0)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "(basis delta3 1)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "(basis delta3 2)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "(basis delta3 3)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "(basis delta3 4)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "(def bic (bicone (make-rdct 3 2) (make-rdct 4 2)))" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "(basis bic 0)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "(basis bic 1)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "(basis bic 4)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "(? bic (cmbn 2 3 (bcnb '(0 1 3)) 4 (bcnc '(0 1 2 3)) 5 (bcnd '(0 1 4))))" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "(? bic (? bic (cmbn 2 3 (bcnb '(0 1 3)) 4 (bcnc '(0 1 2 3)) 5 (bcnd '(0 1 4)))))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 2.7 Composition of homotopy equivalences\n", "#### Example" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "(cat-init)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "(def c (build-chcm\n", " :cmpr #'s-cmpr\n", " :basis #'(lambda (dmns) (declare (ignore dmns)) '(a))\n", " :bsgn 'a\n", " :intr-dffr #'zero-intr-dffr\n", " :strt :cmbn\n", " :orgn '(c)))" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "(def h1 (trivial-hmeq c))" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "(def h2 (cmps h1 h1))" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "(pre-check-rdct (lrdct h2))" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "(setf *tc* (cmbn 3 1 (bcnb 'a) 10 (bcnc 'a) 100 (bcnd 'a)))" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "(setf *bc* (cmbn 3 1 'a))" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "(check-rdct-no-wait)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "(pre-check-rdct (rrdct h2))" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "(check-rdct-no-wait)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "(def h3 (cmps h2 h2))" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "(setf *tc* (cmbn 3 1 (bcnb (bcnb 'a)) 10 (bcnb (bcnc 'a)) 100 (bcnb (bcnd 'a))\n", " 1000 (bcnc 'a) 10000 (bcnd (bcnb 'a)) 5234 (bcnd (bcnc 'a))\n", " 223 (bcnd (bcnd 'a))))" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "(pre-check-rdct (lrdct h3))" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "(check-rdct-no-wait)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "(pre-check-rdct (rrdct h3))" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "(check-rdct-no-wait)" ] } ], "metadata": { "kernelspec": { "display_name": "SBCL Lisp", "language": "lisp", "name": "lisp" }, "language_info": { "codemirror_mode": "text/x-common-lisp", "mimetype": "text/x-common-lisp", "name": "common-lisp", "pygments_lexer": "common-lisp", "version": "X3J13" } }, "nbformat": 4, "nbformat_minor": 0 }