#9559: *generalized* canonical generation in Cython
---------------------------------+------------------------------------------
Reporter: rlm | Owner: rlm
Type: enhancement | Status: needs_work
Priority: major | Milestone: sage-5.6
Component: group theory | Resolution:
Keywords: | Work issues: formatting
Report Upstream: N/A | Reviewers: Tom Boothby
Authors: Robert Miller | Merged in:
Dependencies: | Stopgaps:
---------------------------------+------------------------------------------
Changes (by rlm):
* dependencies: #10549, #10804 =>
Old description:
> Depends on #10804
>
> The basic idea is that one has objects which satisfy the criteria set out
> in `sage/groups/perm_gps/partn_ref`. In particular, one has implemented a
> refinement function, a comparison function, and an equivalent-children
> function. Then one defines the following four functions, and the code
> which will appear here will do the rest.
>
> 1. Given an input object `X`, this function will return a number `k`.
> This is the number of augmentations from `X` to perform, thought of
> abstractly as the list `[0, 1, ..., k-1]`. The user will keep the data of
> what augmentations these actually are.
>
> 2. Given a permutation of `X` (acting on `[0, 1, ..., n-1]`), and a
> number `a` in `[0, 1, ..., k-1]`, outputs a number `b` in the same range,
> such that the augmentation represented by `a` maps to the one represented
> by `b` under the permutation.
>
> 3. Given a number in `[0, 1, ..., k-1]`, outputs an object `C` which
> realizes the augmentation.
>
> 4. Given a permutation `g`, and an object `C`, applies `g` to `C`,
> constructs an arbitrary parent object `P` of `C`, and returns
> `g^(-1)(P)`.
>
> Function (2) will be optional. If not provided, then the list of
> augmentations given in (1) will have to be a set of orbit
> representatives.
>
> NOTE: ticket #11369 should be set to needs_review once this one is ready
New description:
The basic idea is that one has objects which satisfy the criteria set out
in `sage/groups/perm_gps/partn_ref`. In particular, one has implemented a
refinement function, a comparison function, and an equivalent-children
function. Then one defines the following four functions, and the code
which will appear here will do the rest.
1. Given an input object `X`, this function will return a number `k`. This
is the number of augmentations from `X` to perform, thought of abstractly
as the list `[0, 1, ..., k-1]`. The user will keep the data of what
augmentations these actually are.
2. Given a permutation of `X` (acting on `[0, 1, ..., n-1]`), and a number
`a` in `[0, 1, ..., k-1]`, outputs a number `b` in the same range, such
that the augmentation represented by `a` maps to the one represented by
`b` under the permutation.
3. Given a number in `[0, 1, ..., k-1]`, outputs an object `C` which
realizes the augmentation.
4. Given a permutation `g`, and an object `C`, applies `g` to `C`,
constructs an arbitrary parent object `P` of `C`, and returns `g^(-1)(P)`.
Function (2) will be optional. If not provided, then the list of
augmentations given in (1) will have to be a set of orbit representatives.
NOTE: ticket #11369 should be set to needs_review once this one is ready
--
--
Ticket URL: <http://trac.sagemath.org/sage_trac/ticket/9559#comment:13>
Sage <http://www.sagemath.org>
Sage: Creating a Viable Open Source Alternative to Magma, Maple, Mathematica,
and MATLAB
--
You received this message because you are subscribed to the Google Groups
"sage-trac" group.
To post to this group, send email to [email protected].
To unsubscribe from this group, send email to
[email protected].
For more options, visit this group at
http://groups.google.com/group/sage-trac?hl=en.
