#19123: LatticePoset: add is_vertically_decomposable
-------------------------------------+-------------------------------------
       Reporter:  jmantysalo         |        Owner:
           Type:  enhancement        |       Status:  needs_work
       Priority:  major              |    Milestone:  sage-6.9
      Component:  combinatorics      |   Resolution:
       Keywords:                     |    Merged in:
        Authors:  Jori Mäntysalo     |    Reviewers:
Report Upstream:  N/A                |  Work issues:
         Branch:                     |       Commit:
  u/jmantysalo/vertically_decomposable|  
0d472a68c9edf4ddea1404ff0cb6d2f508de55d0
   Dependencies:                     |     Stopgaps:
-------------------------------------+-------------------------------------

Comment (by jmantysalo):

 Replying to [comment:5 ncohen]:
 > > There are of course other options, like having a function (this one,
 with an argument?) returning list of "decomposition elements".
 >
 > +1 to that.

 OK. What should be the name of the argument? `certificate`?
 `give_me_the_list=True`?

 > > How should it be defined on non-connected posets? And I am not sure if
 this works with non-bounded posets; I thinked about bounded ones when
 writing this.
 >
 > Hmmm, okay okay... I attempted to write a definition, but indeed for
 non-lattices you have 1000 different corner-cases, and th definition would
 be a mess.

 Except for the 2-element lattice there is one simple definition that
 generalizes this:

 {{{
 any(P.cover_relations_graph().is_cut_vertex(e) for e in P)
 }}}

 But in any case, it is easy to move this to posets later if we want so.

 > > (Btw, this would be nice exercise of (totally unneeded) optimization.
 One should not need to look for all edged of Hasse diagram to see that a
 poset is indecomposable.)
 >
 > What do you mean? Your algorithm looks very reliable. I do not see it
 waste much.

 If the poset has coverings `2 -> 6` and `4 -> 9`, then no element `3..8`
 can be a decomposition element. After founding, say, `2 -> 6` we could
 check `5 ->`, `4 ->` and so on. But after founding `4 -> 9` we should have
 a somewhat complicated stack to skip re-checking biggest covers of `4` and
 `5`. I guess that the algorithm would be slower in reality, but I am quite
 sure that it would be better in some theoretical meaning.

--
Ticket URL: <http://trac.sagemath.org/ticket/19123#comment:6>
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 http://groups.google.com/group/sage-trac.
For more options, visit https://groups.google.com/d/optout.

Reply via email to