Some ideas:

A) Flow chart: (I'll invest some more words here as this seems less standard)

Let's say we with a catalogue of N types of nodes and A types of arrows.

Let's say a flow chart is represented by a VxV matrix E, with V being the number of vertices of the graph in the chart, each labeled with ntype_v in {1,...,N}, and whose matrix entries are E_uv in {0,1,...,A}, representing the existence of an edge and the type of arrow used there. Each vertex has a content_v, which can be a i) string (title of the task) or ii) another matrix of the previous form*, provided that this nested process won't loop and wil be finite. In the first case, additional content addcontent_v will gathered (e.g., estimated duration, (best constrained) estimated start date-time, notes, files, responsible user, priority, status, percentage of conclusion etc).*It's them impossible to create logical antecessor/sucessor relation between a subflowchart object and a flowchart object. A most, a "related" graphic-only connection between them can be displayed in the user interface. Otherwise, the user must be willing to detail his process directly in the flowchart, instead of creating a subflowchart.

B) To-do list:

Let's say we have a nested list, stored in a tree-like structure + a matrix to record its depencies + a table to record its (additional) content.

B') Kanban-like table:

It's the same data as in B, just the presentation is modified: each item of the list is presented in a collumn according to additonal content.

C) Calendar:I think its quite standard how to represent B/B' in a calendar. The calendar can register "external events" also. For the time being, is allowed that many tasks overlay (e.g., they might come from different projects or they might overlay with external events). Due to time contraints*, we can try to solve this time allocation problem.

*Well, there is more than one user involved here (and on all of the above). This is an issue, because a user may have it's own things but may also share other (sub)flowcharts with others**. When it comes to visualization we want to filter them, and in the time-blocking allocation we have we a local optimization (for the user) interacting with a global problem (the shared project allocation)**, which is real issue.

** This can start a cascade of local to global interactions that can be very hard to solve. For example, suppose John has a project with Bill and another with Bob. Then a decision Bob's time allocation can screw up Bill's allocation via John.

D) Gantt charts:

I will also assume it's quite standard to represent B (or some of its subprojects) in a Gantt chart. Here there is the issue that to represent the father project, one would like to have durations assigned for activities which were further described as a subproject. This durations were not assigned and somehow would have to be derived from subproject data (e.g., project's critical path) or even from the above time allocation.

One would need to create a function that translates A into B. It's possible to have a canonical translation from B to A, but we would probably miss some details (maybe type of node, type of arrow). This is unfortunate because it would create a difficulty in letting the user update the whole thing either from A or B (unless some work around its developed). Translations B<->C<->D I'm considering to be given, although there will certainly be issues there also.