#18133: Implement Orlik-Solomon algebra of an arrangement
-------------------------------------+-------------------------------------
Reporter: kcrisman | Owner:
Type: enhancement | Status: needs_review
Priority: major | Milestone: sage-6.10
Component: geometry | Resolution:
Keywords: hyperplane | Merged in:
arrangements | Reviewers:
Authors: Travis Scrimshaw, | Work issues:
William Slofstra | Commit:
Report Upstream: N/A | a7bcbadf2efdd95ef76dd7d8b2744ae76b5d9f1a
Branch: | Stopgaps:
public/algebras/orlik_solomon-18133|
Dependencies: |
-------------------------------------+-------------------------------------
Comment (by tscrim):
Replying to [comment:10 darij]:
> On the other hand, I'm afraid the code doesn't properly iterate the
reduction.
> {{{
> sage: M4 = matroids.CompleteGraphic(4)
> sage: OS = M4.orlik_solomon_algebra(QQ)
> sage: OS._reduce_broken_circuit(frozenset({2,3,4}))
> OS{1, 3, 4} + OS{1, 2, 3} - OS{1, 2, 4}
> }}}
> The result is malformed: {1, 3, 4} itself contains a broken circuit, so
one of the monomials isn't actually a monomial. Now you could argue that
this is an underscored method and might do with malformed results if the
method calling it knows what it's doing,
That was going to be my argument.
> but first of all I'm not sure whether the !CombinatorialFreeModule
framework will keep accepting such monomials in the future,
It should because those checks are expensive and there has to be a way to
tell this proposed CFM that you know what you're doing (especially in
internal methods like `_from_dict`).
> and second I cannot guarantee that the multiplication as you implemented
it still works with this implementation of `_reduce_broken_circuit`.
>
> The point is, reducing an element modulo the ideal J(M) is a multistep
process, as clearing out one broken circuit might create another. If you
do it until no more broken circuits remain, then I think your product is
correct (though I'll have to take another look).
That is how the product was designed and why it worked. Although now
you've basically pushed that into the recursive step. This also has an
effect of making it recursive. Have you done some timing benchmarks
between the two implementations?
Also this is bad:
{{{
if not type(S) == frozenset:
}}}
You should use the pythonic (and more robust if we replace it by some
subclass of `frozenset`):
{{{
if not isinstance(S, frozenset):
}}}
I can change this though.
> Another issue is the `algebra_generators`: You're setting the `i`-th
generator to be `self.monomial(frozenset([i]))`, but this too might be
malformed. (For example, if `M` is a uniform matroid `U_{n,1} =
matroids.Uniform(1,n)`, then all basis elements are equal, which means
that they cannot be distinct basis elements.)
This is a good point. Good catch.
--
Ticket URL: <http://trac.sagemath.org/ticket/18133#comment:15>
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 unsubscribe from this group and stop receiving emails from it, send an email
to [email protected].
To post to this group, send email to [email protected].
Visit this group at https://groups.google.com/group/sage-trac.
For more options, visit https://groups.google.com/d/optout.
