Ensure append_move and other functions to apply labels to nodes by default

[edwardchalstrey1]

This feature request is for...

PyGambit

Requested enahancement or feature

I find it much clearer to specify nodes using labels wherever possible.

So after doing the following:

g.append_move(
    g.root,
    player="Buyer",
    actions=["Trust", "Not trust"]
)

I want to be able to do:

g.append_move(
    g.root.children["Trust"],  # Using the action label here
    player="Seller",
    actions=["Honor", "Abuse"]
)

However, currently the action labels are not applied by default, meaning the first step becomes:

g.append_move(
    g.root,
    player="Buyer",
    actions=["Trust", "Not trust"]
)
g.root.children[0].label = "Trust"
g.root.children[1].label = "Not trust"

Intuitively I expect to not have to apply the labels separately

Changes to make

• Update append_move to apply labels
• Also would be great if labels were inherited when doing append_infoset

[edwardchalstrey1]

This links in with an idea discussed on the internal project roadmap doc for Gambit 17 features

Requiring everything to have a text label would be a big departure from Gambit history - all of our (now very old!) sample games in general do not have text labels for most game elements. And, we would need to design the interface to take some of the burden from users on generating labels for larger games.

[tturocy]

To clarify, actually the request here is for Node.children to support indexing by action label, not by node label. Currently Node.children indexes by node label, which actually is not very useful.

An alternate idea which has been under consideration is instead to define the addition operator (or a similar operator) such that node + action -> child node. So g.root + "Trust" would yield the desired node.

This makes sense in principle because a node actually is just a unique sequence of actions (at least if the game representation is a tree and not a directed graph).

[edwardchalstrey1]

An alternate idea which has been under consideration is instead to define the addition operator (or a similar operator) such that node + action -> child node. So g.root + "Trust" would yield the desired node.

This makes a lot of sense to me, in the tutorial version of the one-card poker example I've been working on I've been referring to nodes in the markdown text like King -> Raise -> Meet, then in the Python code because I've been manually labelling each node in the same way as the action that resulted in its creation, I can therefore do: g.root.children["King"].children["Raise"].children["Meet"], which I suppose is still a little clunky.

Interesting problem!

So the way described in your alternate idea you'd be able to refer to a node like: g.root + "KingRaiseMeet". For large games that could become convoluted, but I don't see a clear better solution here; I think abstracting further through abbreviation to get the sequence (for this example to RKRM) might not be much better than just using indices for a long sequence, but I'm not sure

[tturocy]

It would be more like g.root + "King" + "Raise" + "Meet". Although even more likely we have been thinking about notations based on XPath/JMESpath and/or Python's pathlib.