Computer Chess Club Archives


Search

Terms

Messages

Subject: Symbolic: Status report 2004.05.19

Author: Steven Edwards

Date: 11:17:16 05/21/04


Symbolic: Status report 2004.05.19

I've spent most of the limited development time available on Symbolic's KSes
(Knowledge Sources).  In particular, the Selector KS family now all return an
analysis structure instead of a node or a move.  This makes the selection
process a bit simpler and relieves the need for the search tree nodes to retain
various selection results.  The analysis structure is a list containing the PV,
the expectation, and a certainty metric for the expectation.  Future additions
to the analysis structure are planned and include causal information.

The top level KsCandidateSelector is finished.  Here it is:

(defun KsCandidateSelector (MyNode MyEffort MyReason MySP)
    "CandidateSelector Knowledge Source"
    ;; This KS is called only once per move to pick the candidate to be played.
    ;;
    ;; MyNode: The root node of the search tree.
    ;; MyEffort: Ignored.
    ;; MyReason: Standard interpretation.
    ;; MySP: Ignored.
    ;;
    ;; Returns: The analysis of the candidate search.

    (let
        (
            (ResultAnalysis nil)
            (SelectorAnalysis nil)
            (PV (getprop MyNode 'PV))
            (Effort 0)
        )

        ;; QuickSelector tried first

        (setf ResultAnalysis
            (KSM
                KiQuickSelector
                MyNode
                Effort
                "Get a quick and obvious move."
                nil))

        ;; Mark search concluded if the QuickSelector was successful

        (when ResultAnalysis
            (setf TheGoingFlag nil))

        ;; Otherwise, the search is still active

        (when TheGoingFlag

            ;; Set an initial result analysis in case of timeout

            (setf ResultAnalysis
                (KSM
                    KiContingencySelector
                    MyNode
                    Effort
                    "Get a contingency move."
                    nil))

            ;; Repeat the selector loop with increasing effort until timeout

            (TimeCheckNorm)
            (dowhile
                (and
                    TheGoingFlag
                    (TimeCheckFast)
                    (not (IsCertainAnalysis? ResultAnalysis))
                    (< Effort 10)) ;; TBD

                    ;; Increment the effort parameter

                    (incf Effort)

                    ;; Get an analysis

                    (setf SelectorAnalysis
                        (KSM
                            KiSelector
                            MyNode
                            Effort
                            "Perform a ply zero selection."
                            ResultAnalysis))

                    ;; Is the contingent analysis valid?

                    (unless TheAbortFlag
                        (setf ResultAnalysis SelectorAnalysis)))

            ;; Done with top level selector loop

            (setf TheGoingFlag nil))

        ResultAnalysis))



This page took 0 seconds to execute

Last modified: Thu, 15 Apr 21 08:11:13 -0700

Current Computer Chess Club Forums at Talkchess. This site by Sean Mintz.