Implementation of blossoming trees for their bijection with Tamari intervals by fwjmath · Pull Request #41416 · sagemath/sage

fwjmath · 2026-01-08T13:07:54Z

This is an implementation of the bijection between blossoming trees and Tamari intervals in the following paper:

Wenjie Fang, Éric Fusy, Philippe Nadeau, "Tamari intervals and blossoming trees". Combinatorial Theory, Volume 5, Issue 1. doi 10.5070/C65165015.

It is the implementation mentioned in the paper, but with additional "Sage-compliant" comments and tests, along with some small restructuring.

More precisely, we provide four new classes.

TamariBlossomingTree: main class that implements blossoming trees and their bijection with Tamari intervals, along with plots and conversion to other Sage objects.
TamariBlossomingTreeFactory: a linear-time random generator of Tamari blossoming tree.
SynchronizedBlossomingTreeFactory: a linear-time random generator of synchronized blossoming trees, which are in bijection with synchronized Tamari intervals.
ModernBlossomingTreeFactory: a linear-time random generator of modern blossoming trees, which are in bijection with modern Tamari intervals.

This implementation will allow users to explore Tamari intervals more easily with our bijection. Most notably, these classes now enables an efficient random generation of large (general, synchronized or modern) Tamari intervals, linear in the size of generated objects. Such generator exists for general Tamari intervals in TamariIntervalPosets, but it goes through triangulations, thus is much slower and more complicated. Here is a comparison of timing:

sage: TIP = TamariIntervalPosets(1000)
sage: %time tip = TIP.random_element()
CPU times: user 5.13 s, sys: 15 ms, total: 5.14 s
Wall time: 5.14 s
sage: TBTF = TamariBlossomingTreeFactory(1000)
sage: %time B = TBTF.random_element()
CPU times: user 118 ms, sys: 2.99 ms, total: 121 ms
Wall time: 120 ms

The random generation of synchronized and modern Tamari intervals is new.

As I am not familiar with the internal structure of Sagemath, these classes were written more like an external module. Advises and help for a restructuring are welcomed. Notably, I did not implement a class for the set of blossoming trees like those for other combinatorial objects. The reason is two-fold:

I am not familiar with the internal working of Sagemath, notably metaclasses, Parent and Element, and the documentation seems to be quite complicated.
I do not intend to provide exhaustive generation, which is less efficient (not linear but quadratic in object size per object).
I may have changed a bit the idea for the second point, as when I look at the exhaustive generation code in the iterator of TamariIntervalPosets_size, its complexity is not clear. It is not linear, but not clear whether quadratic per object. There is a possibility that the class IntegerListsLex may provide an efficient exhaustive generation of related lattice paths to make our bijection more efficient for exhaustive generation.

Thanks @fchapoton for suggesting adapting my original implementation to Sagemath.

By the way, I have not checked whether the documentation shows up correctly in the references, because sage --docbuild reference html fails with the error

Traceback (most recent call last):
  File "<frozen runpy>", line 198, in _run_module_as_main
  File "<frozen runpy>", line 88, in _run_code
  File "/home/fwjmath/svn/sage/src/sage_docbuild/__main__.py", line 545, in <module>
    sys.exit(main())
             ^^^^^^
  File "/home/fwjmath/svn/sage/src/sage_docbuild/__main__.py", line 540, in main
    build = getattr(builder, typ)
            ^^^^^^^^^^^^^^^^^^^^^
AttributeError: 'ReferenceBuilder' object has no attribute 'html'

📝 Checklist

The title is concise and informative.
The description explains in detail what this PR is about.
I have linked a relevant issue or discussion.
I have created tests covering the changes.
I have updated the documentation and checked the documentation preview.

fchapoton · 2026-01-08T14:29:49Z

Salut. Tu m'autorises à faire un commit pour reparer le linter ?

fwjmath · 2026-01-08T14:38:43Z

Salut. Tu m'autorises à faire un commit pour reparer le linter ?

Bien sûr ! Je n'arrive pas à régler le problème en tout cas...

Est-ce qu'il y a une manip que je dois faire ? J'ai déjà croché "Allowing edits by maintainers".

fchapoton · 2026-01-08T14:46:25Z

ok, je m'en occupe

github-actions · 2026-01-08T15:02:14Z

Documentation preview for this PR (built with commit 1d6435b; changes) is ready! 🎉
This preview will update shortly after each push to this PR.

I changed a few small things, in the doc.

oups

forgot one fix

fchapoton · 2026-01-08T16:09:30Z

voila, le linter est réparé, je te repasse la main

fchapoton · 2026-01-08T16:11:07Z

il faudrait ajouter ton nouveau fichier quelque part dans la liste dans src/doc/en/reference/combinat/module_list.rst

fwjmath · 2026-01-22T14:19:18Z

Il y a maintenant la structure Parent et Element. Pour les métaclasses, en fait c'est imposé par les classes de base, donc il n'est pas utile de trop y réfléchir. J'ai aussi refait un peu de refactoring pour pouvoir utiliser les générateurs aléatoires directement dans la class TamariBlossomingTrees sans chercher les classes d'usine.

fchapoton · 2026-01-23T14:39:40Z

pas une bonne idee du tout de tripatouiller le fichier all.py ; ca rend les changements penibles à lire ....

OK, pardon, tu as fais un roll-back, c'est correct

…Poset

fchapoton

looks good enough. Let's move this in

@fchapoton

sagemathgh-41416: Implementation of blossoming trees for their bijection with Tamari intervals    This is an implementation of the bijection between blossoming trees and Tamari intervals in the following paper: Wenjie Fang, Éric Fusy, Philippe Nadeau, "Tamari intervals and blossoming trees". Combinatorial Theory, Volume 5, Issue 1. doi `10.5070/C65165015`. It is the implementation mentioned in the paper, but with additional "Sage-compliant" comments and tests, along with some small restructuring. More precisely, we provide four new classes. - `TamariBlossomingTree`: main class that implements blossoming trees and their bijection with Tamari intervals, along with plots and conversion to other Sage objects. - `TamariBlossomingTreeFactory`: a linear-time random generator of Tamari blossoming tree. - `SynchronizedBlossomingTreeFactory`: a linear-time random generator of synchronized blossoming trees, which are in bijection with synchronized Tamari intervals. - `ModernBlossomingTreeFactory`: a linear-time random generator of modern blossoming trees, which are in bijection with modern Tamari intervals. This implementation will allow users to explore Tamari intervals more easily with our bijection. Most notably, these classes now enables an efficient random generation of large (general, synchronized or modern) Tamari intervals, linear in the size of generated objects. Such generator exists for general Tamari intervals in TamariIntervalPosets, but it goes through triangulations, thus is much slower and more complicated. Here is a comparison of timing: ``` sage: TIP = TamariIntervalPosets(1000) sage: %time tip = TIP.random_element() CPU times: user 5.13 s, sys: 15 ms, total: 5.14 s Wall time: 5.14 s sage: TBTF = TamariBlossomingTreeFactory(1000) sage: %time B = TBTF.random_element() CPU times: user 118 ms, sys: 2.99 ms, total: 121 ms Wall time: 120 ms ``` The random generation of synchronized and modern Tamari intervals is new. As I am not familiar with the internal structure of Sagemath, these classes were written more like an external module. Advises and help for a restructuring are welcomed. Notably, I did not implement a class for the set of blossoming trees like those for other combinatorial objects. The reason is two-fold: 1. I am not familiar with the internal working of Sagemath, notably metaclasses, Parent and Element, and the documentation seems to be quite complicated. 2. I do not intend to provide exhaustive generation, which is less efficient (not linear but quadratic in object size per object). I may have changed a bit the idea for the second point, as when I look at the exhaustive generation code in the iterator of ``TamariIntervalPosets_size``, its complexity is not clear. It is not linear, but not clear whether quadratic per object. There is a possibility that the class ``IntegerListsLex`` may provide an efficient exhaustive generation of related lattice paths to make our bijection more efficient for exhaustive generation. Thanks @fchapoton for suggesting adapting my original implementation to Sagemath. By the way, I have not checked whether the documentation shows up correctly in the references, because ``sage --docbuild reference html`` fails with the error ``` Traceback (most recent call last): File "<frozen runpy>", line 198, in _run_module_as_main File "<frozen runpy>", line 88, in _run_code File "/home/fwjmath/svn/sage/src/sage_docbuild/__main__.py", line 545, in <module> sys.exit(main()) ^^^^^^ File "/home/fwjmath/svn/sage/src/sage_docbuild/__main__.py", line 540, in main build = getattr(builder, typ) ^^^^^^^^^^^^^^^^^^^^^ AttributeError: 'ReferenceBuilder' object has no attribute 'html' ``` ### 📝 Checklist  - [X] The title is concise and informative. - [X] The description explains in detail what this PR is about. - [ ] I have linked a relevant issue or discussion. - [X] I have created tests covering the changes. - [ ] I have updated the documentation and checked the documentation preview. URL: sagemath#41416 Reported by: fwjmath Reviewer(s): Frédéric Chapoton, fwjmath

@fchapoton

sagemathgh-41416: Implementation of blossoming trees for their bijection with Tamari intervals    This is an implementation of the bijection between blossoming trees and Tamari intervals in the following paper: Wenjie Fang, Éric Fusy, Philippe Nadeau, "Tamari intervals and blossoming trees". Combinatorial Theory, Volume 5, Issue 1. doi `10.5070/C65165015`. It is the implementation mentioned in the paper, but with additional "Sage-compliant" comments and tests, along with some small restructuring. More precisely, we provide four new classes. - `TamariBlossomingTree`: main class that implements blossoming trees and their bijection with Tamari intervals, along with plots and conversion to other Sage objects. - `TamariBlossomingTreeFactory`: a linear-time random generator of Tamari blossoming tree. - `SynchronizedBlossomingTreeFactory`: a linear-time random generator of synchronized blossoming trees, which are in bijection with synchronized Tamari intervals. - `ModernBlossomingTreeFactory`: a linear-time random generator of modern blossoming trees, which are in bijection with modern Tamari intervals. This implementation will allow users to explore Tamari intervals more easily with our bijection. Most notably, these classes now enables an efficient random generation of large (general, synchronized or modern) Tamari intervals, linear in the size of generated objects. Such generator exists for general Tamari intervals in TamariIntervalPosets, but it goes through triangulations, thus is much slower and more complicated. Here is a comparison of timing: ``` sage: TIP = TamariIntervalPosets(1000) sage: %time tip = TIP.random_element() CPU times: user 5.13 s, sys: 15 ms, total: 5.14 s Wall time: 5.14 s sage: TBTF = TamariBlossomingTreeFactory(1000) sage: %time B = TBTF.random_element() CPU times: user 118 ms, sys: 2.99 ms, total: 121 ms Wall time: 120 ms ``` The random generation of synchronized and modern Tamari intervals is new. As I am not familiar with the internal structure of Sagemath, these classes were written more like an external module. Advises and help for a restructuring are welcomed. Notably, I did not implement a class for the set of blossoming trees like those for other combinatorial objects. The reason is two-fold: 1. I am not familiar with the internal working of Sagemath, notably metaclasses, Parent and Element, and the documentation seems to be quite complicated. 2. I do not intend to provide exhaustive generation, which is less efficient (not linear but quadratic in object size per object). I may have changed a bit the idea for the second point, as when I look at the exhaustive generation code in the iterator of ``TamariIntervalPosets_size``, its complexity is not clear. It is not linear, but not clear whether quadratic per object. There is a possibility that the class ``IntegerListsLex`` may provide an efficient exhaustive generation of related lattice paths to make our bijection more efficient for exhaustive generation. Thanks @fchapoton for suggesting adapting my original implementation to Sagemath. By the way, I have not checked whether the documentation shows up correctly in the references, because ``sage --docbuild reference html`` fails with the error ``` Traceback (most recent call last): File "<frozen runpy>", line 198, in _run_module_as_main File "<frozen runpy>", line 88, in _run_code File "/home/fwjmath/svn/sage/src/sage_docbuild/__main__.py", line 545, in <module> sys.exit(main()) ^^^^^^ File "/home/fwjmath/svn/sage/src/sage_docbuild/__main__.py", line 540, in main build = getattr(builder, typ) ^^^^^^^^^^^^^^^^^^^^^ AttributeError: 'ReferenceBuilder' object has no attribute 'html' ``` ### 📝 Checklist  - [X] The title is concise and informative. - [X] The description explains in detail what this PR is about. - [ ] I have linked a relevant issue or discussion. - [X] I have created tests covering the changes. - [ ] I have updated the documentation and checked the documentation preview. URL: sagemath#41416 Reported by: fwjmath Reviewer(s): Frédéric Chapoton, fwjmath

@fchapoton

sagemathgh-41416: Implementation of blossoming trees for their bijection with Tamari intervals    This is an implementation of the bijection between blossoming trees and Tamari intervals in the following paper: Wenjie Fang, Éric Fusy, Philippe Nadeau, "Tamari intervals and blossoming trees". Combinatorial Theory, Volume 5, Issue 1. doi `10.5070/C65165015`. It is the implementation mentioned in the paper, but with additional "Sage-compliant" comments and tests, along with some small restructuring. More precisely, we provide four new classes. - `TamariBlossomingTree`: main class that implements blossoming trees and their bijection with Tamari intervals, along with plots and conversion to other Sage objects. - `TamariBlossomingTreeFactory`: a linear-time random generator of Tamari blossoming tree. - `SynchronizedBlossomingTreeFactory`: a linear-time random generator of synchronized blossoming trees, which are in bijection with synchronized Tamari intervals. - `ModernBlossomingTreeFactory`: a linear-time random generator of modern blossoming trees, which are in bijection with modern Tamari intervals. This implementation will allow users to explore Tamari intervals more easily with our bijection. Most notably, these classes now enables an efficient random generation of large (general, synchronized or modern) Tamari intervals, linear in the size of generated objects. Such generator exists for general Tamari intervals in TamariIntervalPosets, but it goes through triangulations, thus is much slower and more complicated. Here is a comparison of timing: ``` sage: TIP = TamariIntervalPosets(1000) sage: %time tip = TIP.random_element() CPU times: user 5.13 s, sys: 15 ms, total: 5.14 s Wall time: 5.14 s sage: TBTF = TamariBlossomingTreeFactory(1000) sage: %time B = TBTF.random_element() CPU times: user 118 ms, sys: 2.99 ms, total: 121 ms Wall time: 120 ms ``` The random generation of synchronized and modern Tamari intervals is new. As I am not familiar with the internal structure of Sagemath, these classes were written more like an external module. Advises and help for a restructuring are welcomed. Notably, I did not implement a class for the set of blossoming trees like those for other combinatorial objects. The reason is two-fold: 1. I am not familiar with the internal working of Sagemath, notably metaclasses, Parent and Element, and the documentation seems to be quite complicated. 2. I do not intend to provide exhaustive generation, which is less efficient (not linear but quadratic in object size per object). I may have changed a bit the idea for the second point, as when I look at the exhaustive generation code in the iterator of ``TamariIntervalPosets_size``, its complexity is not clear. It is not linear, but not clear whether quadratic per object. There is a possibility that the class ``IntegerListsLex`` may provide an efficient exhaustive generation of related lattice paths to make our bijection more efficient for exhaustive generation. Thanks @fchapoton for suggesting adapting my original implementation to Sagemath. By the way, I have not checked whether the documentation shows up correctly in the references, because ``sage --docbuild reference html`` fails with the error ``` Traceback (most recent call last): File "<frozen runpy>", line 198, in _run_module_as_main File "<frozen runpy>", line 88, in _run_code File "/home/fwjmath/svn/sage/src/sage_docbuild/__main__.py", line 545, in <module> sys.exit(main()) ^^^^^^ File "/home/fwjmath/svn/sage/src/sage_docbuild/__main__.py", line 540, in main build = getattr(builder, typ) ^^^^^^^^^^^^^^^^^^^^^ AttributeError: 'ReferenceBuilder' object has no attribute 'html' ``` ### 📝 Checklist  - [X] The title is concise and informative. - [X] The description explains in detail what this PR is about. - [ ] I have linked a relevant issue or discussion. - [X] I have created tests covering the changes. - [ ] I have updated the documentation and checked the documentation preview. URL: sagemath#41416 Reported by: fwjmath Reviewer(s): Frédéric Chapoton, fwjmath

@fchapoton

sagemathgh-41416: Implementation of blossoming trees for their bijection with Tamari intervals    This is an implementation of the bijection between blossoming trees and Tamari intervals in the following paper: Wenjie Fang, Éric Fusy, Philippe Nadeau, "Tamari intervals and blossoming trees". Combinatorial Theory, Volume 5, Issue 1. doi `10.5070/C65165015`. It is the implementation mentioned in the paper, but with additional "Sage-compliant" comments and tests, along with some small restructuring. More precisely, we provide four new classes. - `TamariBlossomingTree`: main class that implements blossoming trees and their bijection with Tamari intervals, along with plots and conversion to other Sage objects. - `TamariBlossomingTreeFactory`: a linear-time random generator of Tamari blossoming tree. - `SynchronizedBlossomingTreeFactory`: a linear-time random generator of synchronized blossoming trees, which are in bijection with synchronized Tamari intervals. - `ModernBlossomingTreeFactory`: a linear-time random generator of modern blossoming trees, which are in bijection with modern Tamari intervals. This implementation will allow users to explore Tamari intervals more easily with our bijection. Most notably, these classes now enables an efficient random generation of large (general, synchronized or modern) Tamari intervals, linear in the size of generated objects. Such generator exists for general Tamari intervals in TamariIntervalPosets, but it goes through triangulations, thus is much slower and more complicated. Here is a comparison of timing: ``` sage: TIP = TamariIntervalPosets(1000) sage: %time tip = TIP.random_element() CPU times: user 5.13 s, sys: 15 ms, total: 5.14 s Wall time: 5.14 s sage: TBTF = TamariBlossomingTreeFactory(1000) sage: %time B = TBTF.random_element() CPU times: user 118 ms, sys: 2.99 ms, total: 121 ms Wall time: 120 ms ``` The random generation of synchronized and modern Tamari intervals is new. As I am not familiar with the internal structure of Sagemath, these classes were written more like an external module. Advises and help for a restructuring are welcomed. Notably, I did not implement a class for the set of blossoming trees like those for other combinatorial objects. The reason is two-fold: 1. I am not familiar with the internal working of Sagemath, notably metaclasses, Parent and Element, and the documentation seems to be quite complicated. 2. I do not intend to provide exhaustive generation, which is less efficient (not linear but quadratic in object size per object). I may have changed a bit the idea for the second point, as when I look at the exhaustive generation code in the iterator of ``TamariIntervalPosets_size``, its complexity is not clear. It is not linear, but not clear whether quadratic per object. There is a possibility that the class ``IntegerListsLex`` may provide an efficient exhaustive generation of related lattice paths to make our bijection more efficient for exhaustive generation. Thanks @fchapoton for suggesting adapting my original implementation to Sagemath. By the way, I have not checked whether the documentation shows up correctly in the references, because ``sage --docbuild reference html`` fails with the error ``` Traceback (most recent call last): File "<frozen runpy>", line 198, in _run_module_as_main File "<frozen runpy>", line 88, in _run_code File "/home/fwjmath/svn/sage/src/sage_docbuild/__main__.py", line 545, in <module> sys.exit(main()) ^^^^^^ File "/home/fwjmath/svn/sage/src/sage_docbuild/__main__.py", line 540, in main build = getattr(builder, typ) ^^^^^^^^^^^^^^^^^^^^^ AttributeError: 'ReferenceBuilder' object has no attribute 'html' ``` ### 📝 Checklist  - [X] The title is concise and informative. - [X] The description explains in detail what this PR is about. - [ ] I have linked a relevant issue or discussion. - [X] I have created tests covering the changes. - [ ] I have updated the documentation and checked the documentation preview. URL: sagemath#41416 Reported by: fwjmath Reviewer(s): Frédéric Chapoton, fwjmath

@fchapoton

sagemathgh-41416: Implementation of blossoming trees for their bijection with Tamari intervals    This is an implementation of the bijection between blossoming trees and Tamari intervals in the following paper: Wenjie Fang, Éric Fusy, Philippe Nadeau, "Tamari intervals and blossoming trees". Combinatorial Theory, Volume 5, Issue 1. doi `10.5070/C65165015`. It is the implementation mentioned in the paper, but with additional "Sage-compliant" comments and tests, along with some small restructuring. More precisely, we provide four new classes. - `TamariBlossomingTree`: main class that implements blossoming trees and their bijection with Tamari intervals, along with plots and conversion to other Sage objects. - `TamariBlossomingTreeFactory`: a linear-time random generator of Tamari blossoming tree. - `SynchronizedBlossomingTreeFactory`: a linear-time random generator of synchronized blossoming trees, which are in bijection with synchronized Tamari intervals. - `ModernBlossomingTreeFactory`: a linear-time random generator of modern blossoming trees, which are in bijection with modern Tamari intervals. This implementation will allow users to explore Tamari intervals more easily with our bijection. Most notably, these classes now enables an efficient random generation of large (general, synchronized or modern) Tamari intervals, linear in the size of generated objects. Such generator exists for general Tamari intervals in TamariIntervalPosets, but it goes through triangulations, thus is much slower and more complicated. Here is a comparison of timing: ``` sage: TIP = TamariIntervalPosets(1000) sage: %time tip = TIP.random_element() CPU times: user 5.13 s, sys: 15 ms, total: 5.14 s Wall time: 5.14 s sage: TBTF = TamariBlossomingTreeFactory(1000) sage: %time B = TBTF.random_element() CPU times: user 118 ms, sys: 2.99 ms, total: 121 ms Wall time: 120 ms ``` The random generation of synchronized and modern Tamari intervals is new. As I am not familiar with the internal structure of Sagemath, these classes were written more like an external module. Advises and help for a restructuring are welcomed. Notably, I did not implement a class for the set of blossoming trees like those for other combinatorial objects. The reason is two-fold: 1. I am not familiar with the internal working of Sagemath, notably metaclasses, Parent and Element, and the documentation seems to be quite complicated. 2. I do not intend to provide exhaustive generation, which is less efficient (not linear but quadratic in object size per object). I may have changed a bit the idea for the second point, as when I look at the exhaustive generation code in the iterator of ``TamariIntervalPosets_size``, its complexity is not clear. It is not linear, but not clear whether quadratic per object. There is a possibility that the class ``IntegerListsLex`` may provide an efficient exhaustive generation of related lattice paths to make our bijection more efficient for exhaustive generation. Thanks @fchapoton for suggesting adapting my original implementation to Sagemath. By the way, I have not checked whether the documentation shows up correctly in the references, because ``sage --docbuild reference html`` fails with the error ``` Traceback (most recent call last): File "<frozen runpy>", line 198, in _run_module_as_main File "<frozen runpy>", line 88, in _run_code File "/home/fwjmath/svn/sage/src/sage_docbuild/__main__.py", line 545, in <module> sys.exit(main()) ^^^^^^ File "/home/fwjmath/svn/sage/src/sage_docbuild/__main__.py", line 540, in main build = getattr(builder, typ) ^^^^^^^^^^^^^^^^^^^^^ AttributeError: 'ReferenceBuilder' object has no attribute 'html' ``` ### 📝 Checklist  - [X] The title is concise and informative. - [X] The description explains in detail what this PR is about. - [ ] I have linked a relevant issue or discussion. - [X] I have created tests covering the changes. - [ ] I have updated the documentation and checked the documentation preview. URL: sagemath#41416 Reported by: fwjmath Reviewer(s): Frédéric Chapoton, fwjmath

fwjmath and others added 14 commits July 7, 2025 14:09

Adding new module, quality of code to improve

76ba602

Merge branch 'sagemath:develop' into blossoming

af17038

Merge branch 'sagemath:develop' into blossoming

9b71539

20251202

62d3213

Merge branch 'blossoming' of github.com:fwjmath/sage into blossoming

9bdbdf5

Merge branch 'sagemath:develop' into blossoming

4254bed

some more docs

e0bae9b

fixed module not found error

fbbbe7e

more comments and tests

5a2ad9f

more tests and comments, inheritance from SageObject etc.

5122cbc

Merge branch 'sagemath:develop' into blossoming

ce02faa

Final result of adding comments and some restructuring

d0d1736

Merge branch 'sagemath:develop' into blossoming

3c67412

update all.py to the most current version

350bd87

github-actions bot added the s: needs review label Jan 8, 2026

fwjmath added 3 commits January 8, 2026 14:20

fix lint problem

8e3521f

more fixes for lint due to py-autopep8 in emacs

7ed29f6

some more minor fixes for lint

1125dfd

fchapoton self-assigned this Jan 8, 2026

fchapoton added 4 commits January 8, 2026 16:37

fix details for linter in tamari_blossoming_tree.py

c556f71

I changed a few small things, in the doc.

Update tamari_blossoming_tree.py

c6671df

oups

fix rst syntax in tamari_blossoming_tree.py

a1fb75a

Update tamari_blossoming_tree.py

96fbf9a

forgot one fix

fchapoton added the c: combinatorics label Jan 8, 2026

fwjmath added 2 commits January 19, 2026 21:07

first working class with parent and element

c9b0d6a

finalize parent/element restructuring

fdc9572

fwjmath and others added 7 commits January 22, 2026 15:20

fix lint

2666304

Merge branch 'sagemath:develop' into blossoming

6ec9d3b

more lint fix

a4abf7e

Merge branch 'blossoming' of github.com:fwjmath/sage into blossoming

e825b23

fix related code in interval poset

d319516

revert rollback of all.py

7163039

fix lint for all.py

3c53e1f

fchapoton reviewed Jan 26, 2026

View reviewed changes

Comment thread src/sage/combinat/interval_posets.py Outdated

fwjmath and others added 7 commits January 27, 2026 18:40

fix documentation references

84e63a5

Merge branch 'develop' into blossoming

239cd29

fix new lint

a5d3b4a

added back the zero size case for random generation in TamariInterval…

7174f88

…Poset

fix broken link in doc

b269e45

Merge branch 'develop' into blossoming

a45ddf1

Update all.py

1d6435b

fchapoton added s: positive review and removed s: needs review labels Feb 27, 2026

fchapoton approved these changes Feb 27, 2026

View reviewed changes

vbraun merged commit 6ed85aa into sagemath:develop Mar 22, 2026
37 of 41 checks passed

github-actions bot removed the s: positive review label Mar 22, 2026

fwjmath deleted the blossoming branch March 24, 2026 14:30

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

Implementation of blossoming trees for their bijection with Tamari intervals#41416

Implementation of blossoming trees for their bijection with Tamari intervals#41416
vbraun merged 51 commits intosagemath:developfrom
fwjmath:blossoming

fwjmath commented Jan 8, 2026

Uh oh!

fchapoton commented Jan 8, 2026

Uh oh!

fwjmath commented Jan 8, 2026

Uh oh!

fchapoton commented Jan 8, 2026

Uh oh!

github-actions bot commented Jan 8, 2026 •

edited

Loading

Uh oh!

fchapoton commented Jan 8, 2026

Uh oh!

fchapoton commented Jan 8, 2026

Uh oh!

fwjmath commented Jan 22, 2026

Uh oh!

fchapoton commented Jan 23, 2026 •

edited

Loading

Uh oh!

Uh oh!

fchapoton left a comment

Uh oh!

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

3 participants

Uh oh!

Conversation

fwjmath commented Jan 8, 2026

📝 Checklist

Uh oh!

fchapoton commented Jan 8, 2026

Uh oh!

fwjmath commented Jan 8, 2026

Uh oh!

fchapoton commented Jan 8, 2026

Uh oh!

github-actions bot commented Jan 8, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

fchapoton commented Jan 8, 2026

Uh oh!

fchapoton commented Jan 8, 2026

Uh oh!

fwjmath commented Jan 22, 2026

Uh oh!

fchapoton commented Jan 23, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

Uh oh!

fchapoton left a comment

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

3 participants

github-actions bot commented Jan 8, 2026 •

edited

Loading

fchapoton commented Jan 23, 2026 •

edited

Loading