QSAlgorithmFF release 3.6.0
========================================

Purpose
-------
This Maple package completes unimodular rows over

    K[x_1,...,x_n],  K = Frac(Q[t_1,...,t_m]/P),

where P is a prime ideal.  The principal output is a matrix U such that

    row . U = [1,0,...,0].

The distribution contains only the mathematical implementation, stable public
facade, loaders, and help manual.  Tests, random generators, and diagnostic
scripts are not bundled.

Installation
------------
1. Extract the directory to an ordinary path, for example

       C:/QSAlgorithmFF_release_v3_6_0

2. In Maple run

       restart:
       currentdir("C:/QSAlgorithmFF_release_v3_6_0"):
       read "load_all.mpl":
       QSFullFF:-Version();

Refactored algorithm structure
------------------------------
The public data root QSFullFF:-CompleteRowData now follows one explicit tree:

    1. ValidateFunctionField
    2. UnimodularRowData
    3. recursive CompleteRow core
       (0) exact base cases: length 1, length 2, field, K[x]
       (1) HeuristicCompletionData
       (2) OneStepReductionCoreData
           - NormalisationStep
           - ReduceDegreeData
           - LocalLoopData
             * maximal-ideal selection
             * OneLocalSolData (horrocks/residue/search/auto)
           - PatchData
       (3) recursive CompleteRow on one fewer variable
    4. final independent verification

The prime-ideal check and initial unimodularity certificate are computed once
before the recursive core.  Right inverses are then propagated through every
matrix transformation and specialization.

Main commands
-------------
Return only the completion matrix:

    U := QSFullFF:-CompleteRow(
        row,xvars,tvars,Pgens,
        'timeLimit'=600,
        'printLog'=true,
        'useHeuristics'=true,
        'localMethod'="horrocks"
    ):

Return the complete data tree:

    Data := QSFullFF:-CompleteRowData(
        row,xvars,tvars,Pgens,
        'timeLimit'=600,
        'printLog'=true,
        'useHeuristics'=false,
        'localMethod'="horrocks"
    ):

Run only the explicit heuristic phase:

    H := QSFullFF:-HeuristicCompletionData(
        row,xvars,tvars,Pgens,
        'useHeuristics'=true
    ):

The returned table contains H["success"] and, on success, H["U"].

Perform one exact specialization step row*U=row(xvars[-1]=0):

    Step := QSFullFF:-OneStepReductionData(
        row,xvars,tvars,Pgens,
        'timeLimit'=600,
        'printLog'=true,
        'useHeuristics'=false,
        'localMethod'="horrocks",
        'printBranches'=false
    ):

Public run controls
-------------------
The main API remains the same as release 3.5.3:

    timeLimit       positive seconds or infinity;
    printLog        print the current phase and elapsed time;
    useHeuristics   enable/disable the explicit heuristic phase, integer
                    norm-search, and small-integer-point fast paths;
    localMethod     "horrocks", "residue", "search", or "auto".

Exact base cases, good-candidate selection, normalization, degree reduction,
right-inverse transport, Horrocks/residue, patching, recursion, and final
verification are always enabled.

Local-loop branch data
----------------------
The local loop always records each maximal ideal M_i, denominator d_i, and
local matrix U_i:

    L["M_list"];
    L["d_list"];
    L["U_list"];

Use printBranches=true in QSFullFF:-LocalLoopData or OneStepReductionData to
print d_i and U_i as each branch is completed.

Documentation
-------------
See:

    docs/QSAlgorithmFF_help_manual.pdf
    docs/QSAlgorithmFF_help_manual.tex

Compatibility
-------------
The documented target environment is Maple 2025.  This build environment did
not contain a Maple kernel, so final dynamic certification must be performed in
the user's Maple installation with the independent verifier.
