11institutetext: Tampere University, Finland 11email:
<EMAIL_ADDRESS>
22institutetext: University of Oulu,Finland 22email:
<EMAIL_ADDRESS>
33institutetext: University of Arizona, USA 33email<EMAIL_ADDRESS>
44institutetext: Vorarlberg University of Applied Sciences, Austria 44email:
<EMAIL_ADDRESS>

# One Microservice per Developer: Is This the Trend in OSS?

Dario Amoroso d’Aragona* 11 Xiaozhou Li 22 Tomas Cerny 33 Andrea Janes 44
Valentina Lenarduzzi 22 Davide Taibi 1122

###### Abstract

When developing and managing microservice systems, practitioners suggest that
each microservice should be owned by a particular team. In effect, there is
only one team with the responsibility to manage a given service. Consequently,
one developer should belong to only one team. This practice of "one-
microservice-per-developer" is especially prevalent in large projects with an
extensive development team.

Based on the bazaar-style software development model of Open Source Projects,
in which different programmers, like vendors at a bazaar, offer to help out
developing different parts of the system, this article investigates whether we
can observe the "one-microservice-per-developer" behavior, a strategy we
assume anticipated within microservice based Open Source Projects.

We conducted an empirical study among 38 microservice-based OS projects. Our
findings indicate that the strategy is rarely respected by open-source
developers except for projects that have dedicated DevOps teams.

##  1 Introduction

Microservices are increasing their diffusion both in industry and in Open
Source Software (OSS) projects [4].

Microservices are small and autonomous services deployed independently, with a
single and clearly defined purpose [11, 24]. Because of their independent
deployment, each microservice can scale independently from others. Some
authors see microservices not primarily as a technological benefit but also as
a way to scale up the number of development teams: "microservices are not
necessarily required to manage huge software, but rather to manage a huge
number of people working on them [29]." The rationale is that since
microservices decouple software components, less communication is necessary to
develop them, and larger teams become possible.

Practitioners suggest that a microservice should be owned and managed by a
single team [4, 3, 1, 30, 27, 29, 36]. The supportive argument sources from
“Conway’s law” [9] states that “organizations which design systems (in the
broad sense) are constrained to produce designs which are copies of the
communication structures of these organizations.” Following this law, it would
be ineffective or detrimental to have two separate teams working on one
microservice. Working on one microservice requires communication within the
team, and if these communication structures are not present, the work on a
joint microservice becomes hard. Therefore, it is suggested that each team is
responsible for one or more business functions [1, 30]. While some authors
(and Conway himself [9]) clearly foresee that each team can own more than one
microservice/subsystem [8, 30, 36], others suggest that "a team should have
exactly one service unless there is a proven need to have multiple services",
to not exceed the cognitive capacity of a team [30]. Particularly if business
functions are large (e.g., "customer management" or "order management"),
practitioners suggest that one team is fully dedicated to one microservice
[27].

Therefore, following the practitioners’ recommendations [9, 30, 27, 36, 8], a
developer must belong only to one team, and each team must contribute only to
one microservice. Consequently, we can deduct that each team member, and
therefore each developer, must contribute to only one microservice. Based on
these assumptions, it would be interesting to investigate the ”one-
microservice-per-developer” strategy to verify to which extent it is
considered in practice.

The goal of this paper is to investigate to which degree it is correct to
assume that in microservice OSS projects, the one-microservice-per-developer
strategy is respected.

Particularly, teams developing OSS projects using a bazaar-style software
development model (as described in Eric Raymond’s seminal essay "The Cathedral
and the Bazaar," in which different programmers, like vendors at a bazaar,
offer to help out developing different parts of the system [28]), require a
decoupled software architecture, which—what we assume—would manifest in a
decoupled collaboration structure. Within OSS projects adopting a microservice
architecture, we hypothesize, we observe that developers, during a given time
window, commit only to one microservice at a time.

For these aims, we designed and conducted an empirical study among 38
microservice-based OSS projects selected from the dataset created by Baresi et
al. [4]. Using code repositories of these projects and analyzing the history
of commits, we calculated the average number of microservices developed by
each developer determining how well is the one-microservice-per-developer
strategy employed. In addition, we further investigated the potential
developer profiles using Exploratory Factor Analysis (EFA) to detect the
patterns of developer behaviors in the core contributor groups of these
projects.

Paper structure: Section 3 describes the empirical study design, while Section
4 reports the obtained results. Section 5 discusses the results, and Section 6
highlights the limitation of this work. Section 2 presents the related work,
and Section 7 concludes.

##  2 Related Work

Developer interaction analysis has been approached from different perspectives
in OSS communities. Given the large quantities of produced communication
artifacts throughout the developer interaction in the development process,
various automated approaches have been proposed. Common sources of input for
such analysis include version control systems (performing mining source code
repositories) [16, 15], mailing lists, and issue trackers [26, 5], or
developer online surveys [22]. Prior to the era of microservices, Bird et al.
[5] considered social network communities and system modularity. They
researched code artifact changes across modules and analyzed email archives to
derive social networks and assess community alignment with modularity. The
conclusions and research questions of Bird et al. [5] in the scope of
microservices drive new perspectives. Microservices are self-contained, and
with regard to Conway’s law, we can consider well-defined teams assigned to
particular microservice development. In addition, the remaining challenge
related to crosscutting concerns cannot be simply negated in microservices.

With regards to microservices and well-defined separation boundaries by code
repositories (or at least repository modules). It can thus be assumed that
code artifacts modified by developers within the same community are placed in
a related repository location.

Throughout OSS software development, it can be expected that developer
assignments to subsystems remain stable (i.e., given expertise alignments,
subsystem assignment, etc.). Ashraf and Panichella [2] analyzed a set of OSS
projects to examine developer communities from the perspective of their
subsystem assignment and interaction highlighting that emerging communities
change considerably across a project’s lifetime and do align with each other.

The microservices perspective, as suggested by Lenarduzzi et al. [21], enables
teams to work independently, reducing cross-team communication. At the same
time, upon microservice integration, issues are reported across teams, as
suggested by Bogner et al. [7] who report on ripple effects. There are other
underlying issues behind this relevant to system evolution, such as missing
system-centered perspective and lack of tools to analyze coherence across
microservices, perform modification trade-off analysis, or evaluate the
conformance of the as-built and as-documented architectures.

Besides interaction analysis to understand communities, other interesting
research directions took place. For instance, Marco et al. [25] analyzed
GitHub commit comments regarding emotions and feelings expression showing that
“one-commit” developers are more active and polite when posting comments as
opposed to “multi-commit” developers, that are less active in posting
comments, and when commenting, they are less polite.

In a timely thesis, Shi [31] looked into establishing contributor roles within
software repositories by mining architectural information. In a case study on
Apache Tomcat, they used the metric to deduce these roles and validate them
with particular roles listed on the project website. Such a research direction
aligns with the perspective of microservices with established separation of
duty. Furthermore, the classification of experts responsible for re-
engineering or management can lead to better insights into the applicability
of Conway’s law across microservice developers.

It is also important to take into account that enterprise companies like Red
Hat manage OSS projects [33] rather than projects based on volunteer
contribution. This can influence role identification, contributor duty spread
across modules, and also the community network. Spinellis et al. [33]
considered the detection of OSS projects that are supported by enterprises.
Such projects can serve as better benchmarks for practical case studies.

With respect to inter-project dependency identification, Blincoe et al. [6]
considered reference coupling. The reference coupling method often identifies
technical dependencies between projects that are untracked by developers.
Understanding inter-project dependency is important for change impact analysis
and coordination. In their study, they manually analyzed identified
dependencies and categorized and compared them to dependencies specified by
the development team. They also assessed how the ecosystem structure compares
with the social behavior of project contributors and owners. As a result, of
socio-technical alignment analysis within the GitHub ecosystems, they found
that the project owners’ social behavior aligns well with the technical
dependencies within the ecosystem. Still, the project contributors’ social
behavior does not align with these dependencies. In microservices, this could
possibly translate into system architects aware of consequences and
microservice developers who operate in isolation as suggested by Lenarduzzi et
al. [21] and unaware of such as inter-project dependency.

In a similar perspective, Scaliante Wiese et al. [34] researched co-change
prediction. They use issues, developers’ communication, and commit metadata to
analyze change patterns for prediction models. They demonstrate that such
models based on contextual information from software changes are accurate and
can support software maintenance and evolution, warning developers when they
miss relevant artifacts while performing a software change.

##  3 The Empirical Study

In this section, we describe our empirical study reporting the goal and
research questions, context, data collection, and data analysis following the
guideline defined by Wohlin et al. [35].

Our goal is to evaluate to what extent the one-microservice-per-developer
strategy, recommended by practitioners [4, 3, 1, 30, 27] is respected in OSS
projects. To allow verifiability and replicability, we published the raw data
in the replication package111 https://figshare.com/s/6ba4e0063ab04d03d6d6.

Then, we formulated two Research Questions (RQs).

RQ1. How well is the one-microservice-per-developer strategy respected in OSS
projects following a microservice architecture?

RQ2. Which developer roles better respect the one-microservice-per-developer
strategy?

With RQ1, we investigated if developers are actually responsible, and
therefore committing, only to a single microservice. In RQ2, we aimed to
understand if specific roles are respecting the aforementioned strategy
differently. We expect that some roles (e.g. DevOps) can be involved in
multiple microservices, while other roles (e.g. coders) are involved only in a
single microservice.

###  3.1 The Selected Projects

We considered the manually validated dataset including 145 microservice-based
projects, proposed by Baresi et al. [4]. The authors developed, validated, and
released a tool to recognize the architecture (e.g., the microservices, the
external services, and the databases used) in a given microservices-based
project. In addition, the authors provided a list of 145 projects that have
been manually validated as non-toy projects regularly using microservices, for
which they also reported the list of built-in microservices in the form of
relative paths and some other set-up information not used in our case. In
particular, for our analysis, we leveraged the list of projects and the
related list of microservices identified by a list of sub-project folders. The
dataset consists of projects whose source code is accessible on
GitHub222https://github.com and is complemented with further data, including
the microservice list.

In order to select a set of relevant projects for our study, we defined the
following inclusion criteria:

  * •

Project with at least 2 microservices. With this threshold, we aim to exclude
non-microservices projects.

  * •

Projects with at least 2 microservices committed in the last 12 months. To
analyze projects that are still maintained.

By requiring a minimum number of microservices and activities in the last non-
representative outliers for our study can be excluded. It is important to note
that we did not exclude projects based on their programming languages.

As a result, we included 38 microservice-based projects with a total of 379
microservices (10 microservices per project on average).

###  3.2 Data Collection

To collect statistics about the development process, we browsed every project
commit. We gathered the timestamp, the author’s name, and the precise change
locations for each commit. With the latter, a modification is connected to a
microservice. We specifically created a heuristic that matches if the path of
the modified file is contained in the project’s list of microservices. If so,
we updated the list of microservice changes in the aforementioned author’s
commit.

###  3.3 Data Analysis

To answer RQ1, the goal is to investigate the microservice coverage by the
developers on average by examining their commits on the microservices. Here,
we considered only the commits involving source code files and excluded all
the commits regarding documentation and setup files. We analyzed the
distribution of commits over developers and microservices to understand 1) how
many microservices have developers in common, and 2) how many developers work
on more than one single microservice.

However, the threat, in this case, is the situation where a developer finishes
work on a microservice and gets started to work on another microservice, or
for some reason, he/she is just moved to another team of developers. From our
point of view, this situation does not lead to a real violation of the one-
microservice-per-developer strategy. For this reason, we have defined a metric
for counting how many times a developer recommits to a microservice after
starting work on another microservice; in other words, if a developer $D_{1}$
commits to microservice $m_{1}$, switches the team, and starts committing to a
$m_{2}$ microservice, then the result of our metric will be $0$ because the
developer never goes back to the previous microservice; otherwise, if after a
while the developer commits back to $m_{1}$, our metric results will give $1$,
because the developer goes back to the previous microservice ($m_{1}$).

To answer RQ2, we need to understand how to identify the role of each
contributor in OSS microservice projects. Different from industrial projects,
within OSS projects on GitHub, contributors, are neither assigned roles by
"project managers" or "product owners" nor obliged to focus on the tasks
assigned to them in the corresponding areas. Therefore, we shall only be able
to understand the roles based on the domains each contributor has been
contributing to.

To identify the roles of the project contributors, we adopted the approach
proposed by Montandon et al. [23] combined with the Exploratory Factor
Analysis (EFA).

Montandon et al. [23] proposed a machine-learning-based approach based on the
extensions of the committed files. They used more than 100k developers’ data
from GitHub together with Stack Overflow data and studied five critical roles:
Backend, Frontend, Data scientist, DevOps, and Mobile. Herein, we initially
adopt the same settings.

The Exploratory Factor Analysis (EFA) [13] aims to discover not only the
number of factors but also what measurable variables together influence which
individual factors [10]. With EFA, we can reduce the complexity of the data,
and also are able to explain the observations with a smaller set of latent
factors. Importantly, by doing so we can also discover the relations among the
variables.

Herein, we follow these steps to conduct EFA on our commit dataset and
determine the profile of each developer:

  1. 1.

Preprocessing. Firstly, we group the obtained developer behavior data.

  2. 2.

Data Verification. Secondly, we verify its sampling adequacy and statistical
significance. For example, we can use Bartlett’s Test of Sphericity [32] and
Kaiser-Meyer-Olkin (KMO) Test [18] for such a purpose.

  3. 3.

Determining Factor Number. Thirdly, we find the number of factors using
parallel analysis (PA) [14]. Herein, we employ the Monte Carlo simulation
technique to simulate random samples consisting of uncorrelated variables.
Then, We extract the eigenvalues of the correlation matrix of the simulated
data and compare the extracted eigenvalues that are ordered by magnitude to
the average simulated eigenvalues. Significant factors are the ones with
ob.served eigenvalues higher than the corresponding simulated eigenvalues

  4. 4.

Factor Extraction and Interpretation. With the number of factors determined,
we conduct the EFA on the dataset. To simplify the interpretation of the
factor analysis result, we employ the varimax rotation technique [17] to
maximize the variance of each factor loading.

  5. 5.

Determining Individual Developer Role Allocation. To apply the factor-variable
relation to individual contributors, we shall calculate the similarity between
the developers’ contributions in terms of the languages and each detected
factor. By comparing the contributor’s similarity to each role factor, we
shall understand more intuitively which role(s) he/she leans to. Such results
can be visualized in a radar chart.

For this study, as a result of the EFA, we shall have a set of factors, each
of which is closely related to a set of latent variables, i.e., programming
languages. To be noted, due to the fact that the original data are collected
from projects of different programming languages, it is likely that
contributors working on different languages lean toward similar roles. For
example, contributors working on CSS and VUE can both be Frontend
contributors. Therefore, we shall observe the loadings of the EFA and manually
merge factors related to only closely-connected languages into the unified
roles.

Particularly, the contributor’s similarity to each role-factor can be
calculated using the Kumar-Hassebrook (KH) similarity, which incorporates also
the inner product of the assigned values of the variables [20]. Moreover,
using the KH similarity, we can evaluate each contributor’s effort level in
each pre-detected role-factor, respectively.

##  4 Results

In this Section, we report the obtained results to answer our Research
Questions (RQs).

###  $RQ_{1}$ How well is the one-microservice-per-developer strategy
respected in OSS projects following a microservice architecture?

To answer $RQ_{1}$, we investigated the single developer, assuming that a
single developer does not belong to more than one team at the same time.
Figure 2 compares the number of microservices with shared developers (MSs with
Shared Dev) with the number of microservices where all developers committed
only to the same microservice (MSs without Shared Dev).

Unexpectedly, only 2 projects always respected the one-microservice-per-
developer strategy, while the remaining projects shared among services.

Since the vast majority of the projects (Figure 4) a developer works on more
than one microservice, we continue our analysis to understand if developers
are simply switching teams, or are working on more microservices at the same
time.

Figure 2 shows the result of the number of times developers commit back on a
microservice after moving to another one among the projects. In two projects
out of 38, developers never commit back to the previous microservice. In most
of the projects ($53$%), the median is $0$, in $34$% of the projects the
median is between $1$ and $10$, and finally in the $13$% of the projects is
more than $10$. However, analyzing the figure, we can see that the boxplots
are very stretched, thus in the same project there are some developers that do
not return back after changing microservice (or never change microservice) and
some developers that instead, commit to the previous microservice.

Figure 1: # microservices with shared and not shared developers (RQ1)

Figure 2: Frequency that developers have committed back (RQ1)

As a result, we conclude that in an OSS context, the one-microservice-per-
developer strategy is not respected as in most cases, developers work on more
than one microservice in parallel.

###  $RQ_{2}$ Which developer roles better respect the one-microservice-per-
developer strategy?

To tackle $RQ_{2}$, we first investigated the strategies of different
contributor-microservice effort allocations. Figure 4 shows the distribution
of the “microservices per developer" of each of the selected projects. To be
noted, the light-example-4j, which contains 155 different microservices, is
not shown in Figure 4. Because one outlier in this project reaches 154
microservices, showing this project in the chart will make the details of all
other projects invisible. Nonetheless, this project was certainly included in
the analysis process.

Figure 3: MS Per Developer sorted by #Developer (RQ1)

Figure 4: MS Per developer sorted by #Microservice (RQ2)

From Figure 4, we can easily find that for all the projects, the one-
microservice-per-developer strategy has not been respected. For the selected
projects, the majority of the medians range from one to seven. For all
projects, there are always some developers committing across multiple
microservices.

On the contrary, many projects that contain various numbers of microservices
have one individual contributor who contributes to all the microservices. We
name such a strategy One-Dev-ALL-MS. For example, in project geoserver-cloud,
contributor gabriel.roldan committed in all the 11 microservices, and in
project eShopOnContainers, contributor mvelosop covers all the 17
microservices. Furthermore, many projects even have multiple contributors that
cover all the microservices. We name such a strategy Multi-Dev-All-MS. For
example, in project loopback4-microservice-catalog, there are eight
contributors covering all 18 microservices; and in project DeathStarBench six
contributors cover all three microservices. It is likely that such a
phenomenon is irrelevant to either the microservice number or a number of
contributors.

Based on this phenomenon, we can intuitively categorize the projects as
follows.

  * •

One-Dev-ALL-MS projects: Projects where only one individual contributor covers
all microservices while all the others cover part of them (16 out of 38)

  * •

Multi-Dev-ALL-MS projects: Projects with multiple contributors covering all
microservices (10 out of 38)

  * •

Multi-Dev-SOME-MS projects: Any projects with no contributors covering all
microservices; nor do they adopt “One-microservice-per-developer” strategy (12
out of 38)

  * •

One-MS-per-developer projects: Any projects with each contributor/team working
only on one microservice

To further investigate the potential roles of the contributors that cover all
microservices and the other common contributors, we used EFA to detect the
latent factors.

1\. Preprocessing. Firstly, for the preprocessing, we grouped the original
dataset by the contributors. For each contributor, we synthesized his/her
contribution in every language by checking the extensions of the committed
files. We crawl each project’s languages using GitHub API. By grouping the
data, we obtained the 1 536 contributors’ dataset with their contribution to
the 33 languages. And we further normalized the dataset into values between
zero and one.

2\. Data Verification. Herein, the KMO score for this dataset is 0.585. It
shows that the sampling is adequate and applying factor analysis is useful for
this dataset. When applying PA to the dataset, we detected 13 factors as there
are 13 out of 33 observed eigenvalues greater than 1.0. The corresponding
factor loadings are shown in the replication packagePackage.

3\. Determining Factor Number. Based on the result of the parallel analysis
(PA), the turning point can be found easily by examining the differences
between observed eigenvalues and simulated eigenvalues. Since the simulated
eigenvalue becomes greater than the observed eigenvalue in the 14th factor
(1.00049 and 0.90517, respectively), the first 13 factors are retained. The
number of factors is therefore 13. According to Guadagnoli and Velicer [12],
scores greater than 0.4 are considered stable, especially when all variables
are not cross-loaded heavily.

4\. Factor Extraction and Interpretation. The initially detected factors and
the correlated variables are reported in the replication packagePackage.
Herein, we adapted Montandon et al.’s role-language relevance results [23] as
the reference to analyze the interpretation of each factor. To be noted, we
added several languages that are not listed in Montandon et al’s study based
on common knowledge and experts’ opinions.

Meanwhile, we also considered the other contributors that are not related to
any specific roles above as Others. By calculating the KH similarity between
the role factors in the factor table obtained previously and the reference
table [23]. Here we assigned the role with the highest similarity score to
each factor.

Furthermore, we combined the factors with the same roles and obtained the
final role-factor reference model.

5\. Determining Individual Developer Role Allocation. By using this role-
factor relevance model, we simply calculated the factor similarities of any
contributor, given his/her contribution allocation in terms of the 33
languages. Furthermore, we investigated the difference in terms of the
contributor roles of the project strategies mentioned above.

Figure 5: Average Role-Factor Distribution of Each Strategy (RQ2)

Figure 5 shows the average behavior patterns of the different types of
contributors in terms of the technical roles. From Figure 5, we can easily
observe that the individual contributors who cover all microservices (i.e.,
One-Dev-ALL-MS) of the projects contribute largely as Documentation+. And they
are also heavily involved in Frontend, when slightly less in Backend and
DevOps roles. To be noted, they also contribute as Fullstack but are nearly
non-existent in the other aspects. In addition, the One-Dev-ALL-MS also
contributes as the Data Scientist role more than the others. On the other
hand, for the multiple contributors that cover all the microservices (i.e.,
Multi-Dev-ALL-Ms), these contributors, on average, contribute less than the
One-Dev-ALL-MS mentioned above. However, they contribute slightly more as
Frontend than the other roles. They cover the Fullstack role a little less but
surprisingly at a similar level compared to One-Dev-ALL-MS. Furthermore, they
contribute more in other languages that are not role-related than that from
the One-Dev-ALL-MS. The Multi-Dev-ALL-MS also contributes to Backend,
Documentation, and Data Scientist, but much less than the other aspects.
Regarding all the Multi-Dev-SOME-MS contributors, they contribute much less in
terms of all working roles than the One-Dev-ALL-Ms and Multi-Dev-ALL-Ms.

The majority of the microservice projects have one or multiple contributors
who commit to all microservices. The single contributor who covers all
microservices (One-Dev-ALL-MS) contributes much more than the multiple
contributors covering all microservices (Multi-Dev-ALL-MS) in all roles,
except that Multi-Dev-ALL-MS contribute more in non-role-related languages.
Multi-Dev-SOME-MS contribute much less in all roles.

##  5 Discussion

Using a large established 145-microservice project dataset [4] we selected 38
projects with a sufficient number of contributors and commits as a
representative OSS sample. This project sample did not adopt the same strategy
suggested for proprietary (closed-source) software projects. In the analyzed
sample we identified that developers typically work on multiple microservices,
and focus on various features, often in parallel. These conclusions are also
confirmed by the vast majority of the projects when considering different
developer roles.

One of the explanations might be the dynamics of OSS projects. In OSS
projects, developers commit their time voluntarily at random, non-fixed hours
and schedules, oftentimes driven by feature priority requests or error
reports. In particular, none of the selected projects is directly sponsored by
a company that allocates developers to the project. Therefore, developers
commonly select a set of issues to be implemented (either new features or bug
fixing) and work on them independently rather than adopting the specific
microservice that they maintain. Another explanation might be that, despite
the decentralized nature of OSS and the microservice architecture, OSS
projects might not have yet assimilated this strategy. Another reason might be
the lack of clear teams in OSS projects (i.e. each developer does not belong
to a specific team), and therefore the “one-microservice-per-developer”
strategy might not be perceived as an issue.

It must also be recognized that additional effort and overhead are related to
the “one-microservice-per-developer” strategy. However, this might not be the
proper fit for the OSS environment and context. OSS projects are often driven
by small development teams or individuals who stand behind the entire project,
occasionally OSS projects have professional teams behind them (i.e., Red Hat);
however, we did not include these projects in the study.

Microservice architecture is the mainstream architecture for cloud-native
systems. However, not necessarily all microservice systems are cloud-native.
In a similar parallel, the decentralized development model connected with
cloud-native systems might collide with the OSS development model. Perhaps the
main driver for the microservice architecture in these OSS projects is
scalability and the decentralized development aspect goes away with the OSS
model.

As practitioners often suggest [4, 3, 1, 30, 27], if the development team is
too small to be split into multiple teams, and there are multiple
microservices, to respect the one-microservice-per-developer strategy, the
system should rather remain monolithic. The reasons for OSS might be
prioritized system scalability for the price of this strategy violation.
Perhaps some projects might have decided to split their systems into multiple
microservices for maintainability reasons, to increase the separation of
concerns, or to better identify different business domains, independently from
the team that is working on the same services.

Another explanation might be given by Mariusz, who investigated whether
Conway’s Law applies to OSS projects [19] and concludes that teams "organize
themselves spontaneously around tasks, and since those tasks concern software
modules, teams naturally follow Conway’s law".

The result of this study will serve the practitioners’ community to understand
how OSS microservice projects are being developed. Moreover, it will help
researchers to further investigate the one-microservice-per-developer
strategy.

##  6 Threats to Validity

Construct Validity. Replying to RQ1 we tried to understand if the one-
microservice-per-developer strategy is adopted. But we measure how well this
strategy is adopted in an OSS context by analyzing individual developer
behavior and assuming that a single developer belongs to one team at a time.
We recognized that this assumption could lead to some threats. We planned to
expand our work in the future by adding information (such as developer
communications, and issue/pull request comments) to extract teams to fine-
grain our analysis.

Internal Validity. The dataset used is one of the most recent in the context
of microservices and open-source projects. However, the dataset is very
heterogeneous (for the number of microservices, the age of the projects, and
the number of developers), and we could only analyze a subset of the projects.
We want to extend the dataset to get a better picture of the real state of the
art.

External Validity. The findings of this paper can be simply extended when more
microservice projects are taken into account. It is reasonable that all the
currently included projects shall also inevitably evolve when the proposed
method should be replicated with the results updated. Especially for RQ2, the
findings can also be generalized to projects that are not specifically
microservice-based if we use modules or features to functionally separate the
projects instead of using microservices. In this way, such extended findings
shall provide insights into the collective contributor profiles for any given
OSS project scope. In addition, when the language-role relations can be
further defined (e.g., new roles defined, new languages assigned to different
roles, etc.), the findings can also be updated accordingly with the changes
conducted in the reference table.

Reliability. Using the dataset we provided in the replication packagePackage
with the same approach, the practitioners and scholars can easily obtain the
same results as described above. Only when any changes are introduced in the
data itself or when the interpretation of the obtained factors varies based on
different expertise, the findings shall differ accordingly.

##  7 Conclusion

Based on the suggestion of practitioners that "a developer should have exactly
one service unless there is a proven need to have multiple services" and the
assumption that developers developing open source software using a bazaar-
style software development model would encourage a "one microservice per
developer" strategy, we learned in this study that OSS projects do not comply
with this strategy. Oftentimes, we could identify projects with a greater
number of microservices than project contributors, and the OSS development
model with a few main contributors dominated the proprietary software
strategy. Still, we must assume that the contributor dedication to OSS has a
very different dynamics than fully-funded organization projects that can
afford multiple developers with regular commitments to contribution. One might
question if Conway’s law collides with the OSS development model, and the
results of this study add weight to the doubts. In this work, we showed that
OSS microservice projects rarely follow the “one-microservice-per-developer”
strategy.

We have demonstrated this by analyzing the OSS project source code
repositories of an established microservices project dataset. We further
supported this result by analyzing the different developers’ roles in
contributing to these projects.

As future work, we aim at further study if “one-microservice per developer"
holds in OSS projects trying to observe emerging or stable developer-like
collaborations between developers. To do so, we plan to analyze the commits of
source code repositories of microservice projects, also parsing the actual
code modifications to understand if a collaboration took place. Also,
following the suggestion by Mariusz[19] projects, which states that
“developers organize themselves spontaneously around tasks,” we plan to study
issue-tracking systems in combination with source code repositories to
investigate if we are able to detect such spontaneous developers acting on
single microservices. Moreover, we aim to investigate the developers’ team
composition to classify the developers who contribute to the same code.

## References

  * [1] Amazon: Service per team pattern. https://docs.aws.amazon.com/prescriptive-guidance/latest/modernization-decomposing-monoliths/service-per-team.html (Jan 2023)
  * [2] Ashraf, U., Mayr-Dorn, C., Mashkoor, A., Egyed, A., Panichella, S.: Do Communities in Developer Interaction Networks align with Subsystem Developer Teams? An Empirical Study of Open Source Systems. In: Int. Conf. on Software and System Processes. pp. 61–71 (2021)
  * [3] Balalaie, A., Heydarnoori, A., Jamshidi, P.: Microservices Architecture Enables DevOps: Migration to a Cloud-Native Architecture. IEEE Software 33(3), 42–52 (2016). https://doi.org/10.1109/MS.2016.64
  * [4] Baresi, L., Quattrocchi, G., Tamburri, D.A.: Microservice Architecture Practices and Experience: a Focused Look on Docker Configuration Files (2022). https://doi.org/10.48550/ARXIV.2212.03107, https://arxiv.org/abs/2212.03107
  * [5] Bird, C., Pattison, D., D’Souza, R., Filkov, V., Devanbu, P.: Latent Social Structure in Open Source Projects. In: Int. Symposium on Foundations of Software Engineering. p. 24–35 (2008)
  * [6] Blincoe, K., Harrison, F., Kaur, N., Damian, D.: Reference Coupling: An exploration of inter-project technical dependencies and their characteristics within large software ecosystems. Information and Software Technology 110, 174–189 (2019)
  * [7] Bogner, J., Fritzsch, J., Wagner, S., Zimmermann, A.: Industry Practices and Challenges for the Evolvability Assurance of Microservices: An Interview Study and Systematic Grey Literature Review. Empirical Softw. Engg. 26(5) (2021)
  * [8] Carneiro, C., Schmelmer, T.: Microservices From Day One: Build robust and scalable software from the start. Apress (2016)
  * [9] Conway, M.E.: How Do Committees Invent? Datamation (April 1968)
  * [10] DeCoster, J.: Overview of factor analysis (1998)
  * [11] Fowler, M.: CodeSmell. https://martinfowler.com/bliki/CodeSmell.html (Feb 2006)
  * [12] Guadagnoli, E., Velicer, W.F.: Relation of sample size to the stability of component patterns. Psychological bulletin 103(2), 265 (1988)
  * [13] Hair, J.F., Black, W.C., Babin, B.J., Anderson, R.E., Tatham, R.L., et al.: Multivariate data analysis (Vol. 6) (2006)
  * [14] Horn, J.L.: A rationale and test for the number of factors in factor analysis. Psychometrika 30(2), 179–185 (1965)
  * [15] Jermakovics, A., Sillitti, A., Succi, G.: Mining and Visualizing Developer Networks from Version Control Systems. In: Int. Workshop on Cooperative and Human Aspects of Software Engineering (2011)
  * [16] Joblin, M., Mauerer, W., Apel, S., Siegmund, J., Riehle, D.: From Developer Networks to Verified Communities: A Fine-Grained Approach. In: Int. Conf. on Software Engineering. p. 563–573 (2015)
  * [17] Kaiser, H.F.: The varimax criterion for analytic rotation in factor analysis. Psychometrika 23(3), 187–200 (1958)
  * [18] Kaiser, H.F.: An index of factorial simplicity. Psychometrika 39(1), 31–36 (1974)
  * [19] Kamola, M.: How to Verify Conway’s Law for Open Source Projects. IEEE Access 7, 38469–38480 (2019). https://doi.org/10.1109/ACCESS.2019.2905671
  * [20] Kumar, B.V., Hassebrook, L.: Performance measures for correlation filters. Applied optics 29(20), 2997–3006 (1990)
  * [21] Lenarduzzi, V., Sievi-Korte, O.: On the Negative Impact of Team Independence in Microservices Software Development. In: XP Conference (2018)
  * [22] Meneely, A., Williams, L.: Socio-Technical Developer Networks: Should We Trust Our Measurements? In: Int. Conf. on Software Engineering. p. 281–290 (2011)
  * [23] Montandon, J.E., Valente, M.T., Silva, L.L.: Mining the technical roles of GitHub users. Information and Software Technology 131, 106485 (2021)
  * [24] Newman, S.: Building Microservices. O’Reilly Media, Inc., 1st edn. (2015)
  * [25] Ortu, M., Hall, T., Marchesi, M., Tonelli, R., Bowes, D., Destefanis, G.: Mining Communication Patterns in Software Development: A GitHub Analysis. In: Int. Conf. on Predictive Models and Data Analytics in Software Engineering. p. 70–79. PROMISE’18 (2018)
  * [26] Panichella, S., Bavota, G., Penta, M.D., Canfora, G., Antoniol, G.: How Developers’ Collaborations Identified from Different Sources Tell Us about Code Changes. In: Int. Conf. on Software Maintenance and Evolution. pp. 251–260 (2014)
  * [27] Qcon2022: Dark Energy, Dark Matter and the Microservices Patterns?! https://shorturl.at/etHM5 (November 2022)
  * [28] Raymond, E.S., O’Reilly, T.: The Cathedral and the Bazaar. O’Reilly & Associates, Inc., USA, 1st edn. (1999)
  * [29] Reinfurt, M.: The horror of microservices in small teams — and why you shouldn’t build them. https://shorturl.at/bgHKR (Apr 2021)
  * [30] Richardson, C.: A pattern language for microservices. https://shorturl.at/bGS34 (Jan 2021)
  * [31] Shi, K.: Establishing contributor roles within software repositories by mining architectural information. https://fse.studenttheses.ub.rug.nl/25608/1/bCS_2021_ShiK.pdf (2021)
  * [32] Snedecor, G.W., Cochran, W.G.: Statistical methods, 8thEdn. Ames: Iowa State Univ. Press Iowa 54, 71–82 (1989)
  * [33] Spinellis, D., Kotti, Z., Kravvaritis, K., Theodorou, G., Louridas, P.: A Dataset of Enterprise-Driven Open Source Software. In: Int. Conf. on Mining Software Repositories. p. 533–537 (2020)
  * [34] Wiese, I.S., Ré, R., Steinmacher, I., Kuroda, R.T., Oliva, G.A., Treude, C., Gerosa, M.A.: Using contextual information to predict co-changes. Journal of Systems and Software 128, 220–235 (2017)
  * [35] Wohlin, C., Runeson, P., Höst, M., Ohlsson, M.C., Regnell, B., Wesslén, A.: Experimentation in software engineering. Springer Science & Business Media (2012)
  * [36] Wolff, E.: Microservices Primer: A Short Overview. Leanpub (2021)


#  Quantum $3j$-symbols for $U_{q}(\mathfrak{sl}_{3})$

Ayaz Ahmed  Department of Physics, Indian Institute of Technology Bombay,
Mumbai, India, 400076  P. Ramadevi  Department of Physics, Indian Institute of
Technology Bombay, Mumbai, India, 400076  Shoaib Akhtar  Physics Department,
Stanford University, Stanford, CA 94305, USA

###### Abstract

We propose an algebraic expression for $U_{q}(\mathfrak{sl}_{3})$ quantum $3j$
symbols (quantum Clebsch-Gordan coefficients) appearing in the decomposition
of tensor product of symmetric representations. Our compact form will be
useful to write the spectral parameter dependent $R$-matrix elements for any
bi-partite vertex model whose edges carry states of the symmetric
representations.

5pt

##  1 Introduction

In the context of quantum theory of addition of two angular momentum, we have
seen the natural appearance of Clebsch-Gordan coefficients (Wigner
$3j$-symbol). Particularly, these Clebsch-Gordan (CG) coefficients, which
determine the states of the irreducible representations obtained from the
tensor product of any two $SU(2)$ representations, has wide applications in
nuclear and atomic physics [1, 2].

In the development of quantum inverse scattering method, it is seen that
quantising a classical system leads to quantum deformation in some structures
of the system. In the work of Kulish and Reshetikhin [3], solution of the
Yang-Baxter equation needed a deformation of the universal enveloping algebra
of $\mathfrak{sl_{2}}$ (over $\mathbb{C}$). These deformed algebraic
structures were successfully captured in the work of Drinfel’d [4], by
quantising the universal enveloping algebra of the Lie algebra. The universal
$\mathcal{R}$ matrix of $U_{q}(\mathfrak{sl}_{2})$, which obey Yang-Baxter
equations, connect intra-disciplinary areas like integrable lattice models &
Wess-Zumino-Novikov-Witten (WZNW) model[5]. In fact, the spectral parameter
dependent $R$-matrix governing the exactly solvable models like vertex models
[6] can be determined if we know $U_{q}(\mathfrak{sl}_{N})$ quantum CG (q-CG)
coefficients[7, 8]. These q-CG coefficients also find applications in nuclear
physics[9, 10].

The closed form expression for q-CG coefficients of $U_{q}(\mathfrak{sl}_{2})$
is known[11]. Hence, determining the $R$-matrix elements of vertex models with
edges carrying states of arbitrary spin $n/2$ is straightforward. However, to
generalise these results for vertex models with edges carrying states
belonging to symmetric representation

$\underbrace{(n,0,0,\ldots
0)}_{N-1}\equiv{\underbrace{\yng(4)}_{n}}\in\mathfrak{sl}_{N},$

requires q-CG coefficients of $U_{q}(\mathfrak{sl}_{N})$. Determining an
algebraic expression for $U_{q}(\mathfrak{sl}_{N})$ q-CG has to include a new
feature which emerges when we go to $\mathfrak{sl}_{N\geq 3}$. That is, the
multiple occurrence of linear independent states belonging to an irreducible
representations $(n_{1}+n_{2}-2s,s)$ in the tensor product of symmetric
representations

$\underbrace{(n_{1},0,0,0,\ldots)}_{N-1}\otimes\underbrace{(n_{2},0,0,0,\ldots)}_{N-1}={\oplus}_{s=0}^{Min[n_{1},n_{2}]}\underbrace{(n_{1}+n_{2}-2s,s,0,0,\ldots)}_{N-1}~{},$
(1)

where $(n_{1}+n_{2}-2s=2,s=4,0,0,\ldots)\equiv\yng(6,4)$ denotes the
irreducible representation as a two row Young diagram with $n_{1}+n_{2}-2s$
single boxes and $s$ vertical two boxes. Note that the number of irreducible
representations in the tensor product decomposition are same for any
$\mathfrak{sl}_{N}$. As a first step, we focus on obtaining
$U_{q}(\mathfrak{sl}_{3})$ q-CG coefficients for the above tensor product
decomposition in this paper.

The paper is organized as follows: In section 2, we present a brief
introduction of $U_{q}(\mathfrak{sl}_{2})$ algebra to construct q-CG
coefficients. Section 3 describes the idea to handle the multiplicity for
$U_{q}(\mathfrak{sl}_{3})$ and classification of states. In section 3.1, we
propose an algebraic expression for q-CG coefficients. In section 4, we
summarize our work and indicate possible direction to pursue in future. Then
appendix A discusses methods to obtain linearly independent states and in
appendix B, we present some q-CG coefficients data calculated from our
expression using Wolfram Mathematica 12.1.

##  2 $U_{q}(\mathfrak{sl}_{2})$ Quantum $3j$-symbols

$U_{q}(\mathfrak{sl}_{2})$ denotes the quantum deformation of the
$U(\mathfrak{sl}_{2})$ algebra whose three generators
$E_{\pm\alpha_{1}},H_{\alpha_{1}}$ obey[12]

$[H_{\alpha_{1}},E^{\pm}_{\alpha_{1}}]=\pm
E^{\pm}_{\alpha_{1}},~{}~{}[E^{+}_{\alpha_{1}},E^{-}_{\alpha_{1}}]=[2H_{\alpha_{1}}],$
(2)

where $\alpha_{1}$ indicates that there is only one positive root for
$\mathfrak{sl}_{2}$ and the square bracket is the quantum deformation of
ordinary operator $H_{\alpha_{1}}$. $[n]$ is defined as

$[n]=\frac{q^{n/2}-q^{-n/2}}{q^{1/2}-q^{-1/2}}~{},$ (3)

which is referred to as q-number, as it reduces to the classical number $n$ in
the following way:

${\rm taking}~{}q=e^{\hbar},~{}{\rm limit}~{}{\hbar\rightarrow 0}~{}[n]=n.$
(4)

Let us denote the highest weight state of the
spin-$j\equiv\overbrace{\yng(4)}^{2j}$ representation of
$U_{q}(\mathfrak{sl}_{2})$, whose highest weight $\lambda=2j$
($j\in\frac{1}{2}\mathbb{Z}$), as $|j,j\rangle\equiv|\lambda,\lambda\rangle$.
Then the ladder operators action on the state $|j,j\rangle$ will generate all
the states of the spin $j$ representation:

$(E^{-}_{\alpha_{1}})^{\ell}|j,j\rangle=\prod_{r=0}^{\ell-1}\sqrt{[j+j-r][j-j+1+r]}|j,j-\ell\rangle~{},$
(5)

where $\ell\leq 2j$ and the square bracket is given by expression(3). For a
general state,

$|\lambda=2j,\lambda-(j-m)\rangle\equiv|j,m\rangle,$

the ladder operator consistent with the above algebra is[12]

$E^{\pm}_{\alpha_{1}}|j,m\rangle=\sqrt{[j\mp m][j\pm m+1]}|j,m\pm
1\rangle~{}.$ (6)

The three generators on the tensor product of two different spin states :

$|j_{1},m_{1}\rangle\otimes|j_{2},m_{2}\rangle$

obey the following co-product rule[12]:

$\displaystyle\Delta H_{\alpha_{1}}$ $\displaystyle=$
$\displaystyle\mathbb{I}\otimes
H_{\alpha_{1}}+H_{\alpha_{1}}\otimes\mathbb{I}$ (7) $\displaystyle\Delta
E_{\alpha_{1}}^{\pm}$ $\displaystyle=$ $\displaystyle
E_{\alpha_{1}}^{\pm}\otimes q^{H_{\alpha_{1}}/2}+q^{-H_{\alpha_{1}}/2}\otimes
E_{\alpha_{1}}^{\pm}~{}.$ (8)

Assuming that the deformation parameter $q$ is $k$-th root of unity with $k\gg
j_{1},j_{2}$, the spin $J$ of the irreducible representations (from the
decomposition of the tensor product $j_{1}\otimes j_{2}$) takes values
$|j_{1}-j_{2}|,|j_{1}-j_{2}|+1,\ldots j_{1}+j_{2}$. Further, the state
$|J,M\rangle$ can be obtained by the action of the lowering ladder operator on
the highest weight state :

$(E^{-}_{\alpha_{1}})^{\ell}|J=j_{1}+j_{2},M=j_{1}+j_{2}\rangle=(\Delta
E_{\alpha_{1}})^{\ell}|j_{1},j_{1}\rangle|j_{2},j_{2}\rangle~{},$ (9)

leading to

$|J=j_{1}+j_{2},M=j_{1}+j_{2}-\ell\rangle={\sum_{m_{1},m_{2}}}C^{j_{1},j_{2}}_{m_{1},m_{2}}(J,M)~{}|j_{1},m_{1}\rangle\otimes|j_{2},m_{2}\rangle~{},$

where $m_{1}+m_{2}=M$ gives non-zero q-CG coefficients

$C^{j_{1},j_{2}}_{m_{1},m_{2}}(J,M)=\\{\langle j_{1}m_{2}|\otimes\langle
j_{2},m_{2}|\\}|J,M\rangle.$ (10)

It is also possible to determine other states

$|J=j_{1}+j_{2}-1,M\rangle,|J=j_{1}+j_{2}-2,M\rangle\ldots$

by imposing orthogonality

$\langle J,M|J^{\prime},M\rangle=\delta_{J,J^{\prime}}~{},$

and hence deduce the q-CG coefficients for $J<j_{1}+j_{2}$. It is not at all
obvious that one can directly put forth a closed form expression for q-CG
coefficients without going through the above sequence of steps. Interestingly,
a closed form expression proposed in [11] gives the $U_{q}(\mathfrak{sl}_{2})$
q-CG coefficients:

$\displaystyle C^{j_{1}.j_{2}}_{m_{1},m_{2}}(j,m)$ $\displaystyle=$
$\displaystyle\begin{bmatrix}j_{1}&j_{2}&j\\\ m_{1}&m_{2}&m\end{bmatrix}$ (11)
$\displaystyle=$
$\displaystyle(-1)^{j_{1}-m_{1}}\delta_{m,m_{1}+m_{2}}q^{\frac{1}{4}\left[j_{2}(j_{2}+1)-j_{1}(j_{1}+1)-j(j+1)\right]+\frac{m+1}{2}m_{1}}$
$\displaystyle\times\left\\{\frac{[2j+1][j_{1}+j_{2}-j]![j_{1}-m_{1}]![j_{2}-m_{2}]![j+m]![j-m]!}{[j+j_{1}+j_{2}+1]![j+j_{1}-j_{2}]![j+j_{2}-j_{1}]![j_{1}+m_{1}]![j_{2}+m_{2}]!}\right\\}^{\frac{1}{2}}$
$\displaystyle\times\sum_{k=0}^{j-m}\frac{(-1)^{k}q^{\frac{k}{2}(j+m+1)}[j_{2}+j-m_{1}-k]![j_{1}+m_{1}+k]!}{[k]![j-m-k]![j_{2}-j+m_{1}+k]![j_{1}-m_{1}-k]!}~{},$

where factorial of q-numbers (3) is $[n]!=\prod_{m=1}^{n}[m]$. These q-CG
coefficients obey the orthogonality relations [13]:

$\displaystyle\sum_{m_{1},m_{2}}\begin{bmatrix}j_{1}&j_{2}&j\\\
m_{1}&m_{2}&m\end{bmatrix}\begin{bmatrix}j_{1}&j_{2}&j^{\prime}\\\
m_{1}&m_{2}&m^{\prime}\end{bmatrix}$ $\displaystyle=$
$\displaystyle\delta_{j,j^{\prime}}\delta_{m,m^{\prime}}\delta(j_{1}j_{2}j)$
$\displaystyle\sum_{j,m}\begin{bmatrix}j_{1}&j_{2}&j\\\
m_{1}&m_{2}&m\end{bmatrix}\begin{bmatrix}j_{1}&j_{2}&j\\\
m_{1}^{\prime}&m_{2}^{\prime}&m\end{bmatrix}$ $\displaystyle=$
$\displaystyle\delta_{m_{1},m_{1}^{\prime}}\delta_{m_{2},m_{2}^{\prime}}~{},$
(12)

where

$\delta(j_{1}j_{2}j)=\begin{cases}1,&\text{if }|j_{1}-j_{2}|\leq j\leq
j_{1}+j_{2}\\\ 0,&\text{otherwise}~{}.\end{cases}$

The $k$ summation appearing in expression(11) can be compactly written in
terms of hypergeometric series ${}_{3}\varphi_{2}$. We first recall the
generalised hypergeometric series can be written in terms of q-Pochhammer
symbols,

$(x;q)_{n}=\prod_{k=0}^{n-1}(1-xq^{k}),~{}~{}n\geq 0,$ (13)

as follows:

${}_{r}\varphi_{s}\left(\begin{matrix}a_{1},a_{2},\cdots,a_{r}\\\
b_{1},\cdots,b_{s}&\end{matrix};q,z\right)=\sum_{n=0}^{\infty}\frac{(a_{1};q)_{n}(a_{2};q)_{n}\cdots(a_{r};q)_{n}}{(b_{1};q)_{n}(b_{2};q)_{n}\cdots(b_{s};q)_{n}}\left[(-1)^{n}q^{n(n-1)/2}\right]^{1+s-r}z^{n}~{}.$
(14)

The q-CG coefficient in terms of the hypergeometric series is[14]

$\displaystyle C^{j_{1}.j_{2}}_{m_{1},m_{2}}(j,m)$ $\displaystyle=$
$\displaystyle(-1)^{j_{1}-m_{1}}\delta_{m,m_{1}+m_{2}}q^{\frac{1}{4}\left[j_{2}(j_{2}+1)-j_{1}(j_{1}+1)-j(j+1)\right]+\frac{m+1}{2}m_{1}}$
(15)
$\displaystyle\times\left\\{\frac{[2j+1][j_{1}+j_{2}-j]![j+m]![j_{1}+m_{1}]![j_{2}-m_{2}]!}{[j+j_{1}+j_{2}+1]![j+j_{1}-j_{2}]![j-j_{1}+j_{2}]![j-m]![j_{1}-m_{1}]![j_{2}+m_{2}]!}\right\\}^{\frac{1}{2}}$
$\displaystyle\times\frac{[j_{2}+j-m_{1}]!}{[j_{2}-j+m_{1}]!}{}_{3}\varphi_{2}\left(\begin{matrix}q^{m-j},q^{m_{1}-j_{1}},q^{j_{1}+m_{1}+1}\\\
q^{m_{1}-j_{2}-j},q^{j_{2}-j+m_{1}+1}&\end{matrix};q,q\right)~{}.$

With this review for the simplest $U_{q}(\mathfrak{sl}_{2})$, we will now
generalise the methodology for $U_{q}(\mathfrak{sl}_{3})$ q-CG coefficients in
the following section.

##  3 $U_{q}(\mathfrak{sl}_{3})$ q-CG coefficients

We know that the rank of the $\mathfrak{sl}_{3}$ group is two, i.e. there are
two Cartan generators $\mathbf{H}=(H_{1},H_{2})$ and two simple root vectors:
$\boldsymbol{\alpha}_{1}=(\alpha_{1}^{(1)},\alpha_{1}^{(2)})$,
$\boldsymbol{\alpha}_{2}=(\alpha_{2}^{(1)},\alpha_{2}^{(2)}).$ Further, there
is an additional positive root,
$\boldsymbol{\alpha}_{3}=\boldsymbol{\alpha}_{1}+\boldsymbol{\alpha}_{2}.$
Associated with these three positive roots, we have three
$U_{q}(\mathfrak{sl}_{2})$ subalgebras, whose generators are

$\\{E^{\pm}_{\boldsymbol{\alpha}_{i}},H_{\boldsymbol{\alpha}_{i}}\\}~{}{\rm
where}~{}H_{\boldsymbol{\alpha}_{i}}={\boldsymbol{\alpha}_{i}}.\mathbf{H}.$

We follow the standard normalisation of the simple roots
$\boldsymbol{\alpha}_{1},\boldsymbol{\alpha}_{2}$:

$\boldsymbol{\alpha}_{i}.\boldsymbol{\alpha}_{j}=\delta_{ij}-\frac{1}{2}\delta_{i,j=i\pm
1}~{}.$ (16)

Note that, the roots of $U_{q}(\mathfrak{sl}_{3})$ are two-component vectors,
whereas the root $\alpha_{1}=1$ of $U_{q}(\mathfrak{sl}_{2})$ is a one-
component number. We will now discuss the states of a representation belonging
to $U_{q}(\mathfrak{sl}_{3})$:

$(5,2)\equiv\yng(7,2)~{},$ (17)

as depicted in Figure 1, which is known as weight diagram. The highest weight,
which is also a two-component vector, for the representation is

$\boldsymbol{\lambda}=5\boldsymbol{\mu}_{1}+2\boldsymbol{\mu}_{2}~{},$

where $\boldsymbol{\mu}_{1},\boldsymbol{\mu}_{2}$ are the fundamental weight
vectors obeying

$\boldsymbol{\mu}_{i}.\boldsymbol{\alpha}_{j}=\frac{1}{2}\delta_{ij}~{},$ (18)

with the simple roots $\boldsymbol{\alpha}_{1},\boldsymbol{\alpha}_{2}$. The
states belonging to $(5,2)$ weight diagram are shown as black dots for outer
shell, black dots with red concentric circles in inner shell, and an
additional green circle in the second inner shell and so on. This illustrates
the emergence of multiplicity states for inner shells[15]. For the $(5,2)$
weight diagram the triangular structure appears from the second inner shell
onward. Hence, the states remain with multiplicity 3 from second shell onward.
For symmetric representation $(3,0)=\yng(3)$, the weight diagram is triangular
and hence, the states have no multiplicity. For any arbitrary representation
$(n,m)$, ${\boldsymbol{\lambda}}=n\boldsymbol{\mu}_{1}+m\boldsymbol{\mu}_{2}$,
the triangular shell emerges from the $min(m,n)$-the inner shell.

(5,2)$\boldsymbol{\alpha}_{1}$$\boldsymbol{\alpha}_{2}$$\boldsymbol{\alpha}_{3}$$\tiny
F$$\tiny E$$\tiny G$$\tiny H$ Figure 1: Weight diagram for $\mathfrak{sl}_{3}$
representation (5,2)

For the marked point ‘F’ in Figure 1, the three linearly independent states
can be obtained by the action of lowering operator on the highest weight state
$|\boldsymbol{\lambda},\boldsymbol{\lambda}\rangle,~{}$ where
$\boldsymbol{\lambda}=5\boldsymbol{\mu}_{1}+2\boldsymbol{\mu}_{2}$ :

$|\boldsymbol{\lambda},\boldsymbol{\omega}=\boldsymbol{\lambda}-4\boldsymbol{\alpha}_{1}-3\boldsymbol{\alpha}_{2};\text{black}\rangle=\left(E^{-}_{\boldsymbol{\alpha}_{3}}\right)^{3}\left(E^{-}_{\boldsymbol{\alpha}_{1}}\right)^{1}|\boldsymbol{\lambda},\boldsymbol{\lambda}\rangle~{},$
(19)
$|\boldsymbol{\lambda},\boldsymbol{\omega}=\boldsymbol{\lambda}-4\boldsymbol{\alpha}_{1}-3\boldsymbol{\alpha}_{2};\text{red}\rangle=\left(E^{-}_{\boldsymbol{\alpha}_{3}}\right)^{2}\left(E^{-}_{\boldsymbol{\alpha}_{1}}\right)^{1}\left(E^{-}_{\boldsymbol{\alpha}_{2}}\right)^{1}\left(E^{-}_{\boldsymbol{\alpha}_{1}}\right)^{1}|\boldsymbol{\lambda},\boldsymbol{\lambda}\rangle~{},$
$|\boldsymbol{\lambda},\boldsymbol{\omega}=\boldsymbol{\lambda}-4\boldsymbol{\alpha}_{1}-3\boldsymbol{\alpha}_{2};\text{green}\rangle=\left(E^{-}_{\boldsymbol{\alpha}_{3}}\right)^{1}\left(E^{-}_{\boldsymbol{\alpha}_{1}}\right)^{1}\left(E^{-}_{\boldsymbol{\alpha}_{2}}\right)^{2}\left(E^{-}_{\boldsymbol{\alpha}_{1}}\right)^{2}|\boldsymbol{\lambda},\boldsymbol{\lambda}\rangle~{}.$

In fact, all the linearly independent states corresponding to the black dots,
red circles, green circles…can be obtained by systematic sequence of lowering
operators, as discussed in appendix A, acting on the highest weight state
$|\boldsymbol{\lambda}=n\boldsymbol{\mu}_{1}+m\boldsymbol{\mu}_{2},\boldsymbol{\lambda}\rangle$.
The action of every $U_{q}(\mathfrak{sl}_{2})$ subalgebra ladder operator (6)
requires defining

$|\boldsymbol{\lambda},\boldsymbol{\omega}=\boldsymbol{\lambda}-A\boldsymbol{\alpha}_{1}-B\boldsymbol{\alpha}_{2}\rangle\equiv|\vec{j}(\boldsymbol{\omega}),\vec{m}(\boldsymbol{\omega})\rangle~{},$
(20)

where the explicit forms of
$\vec{j}(\boldsymbol{\omega})=\\{j^{(1)}(\boldsymbol{\omega}),j^{(2)}(\boldsymbol{\omega})\rangle,j^{(3)}(\boldsymbol{\omega})\\}$
are

$\displaystyle j^{(1)}(\boldsymbol{\omega})$ $\displaystyle=$
$\displaystyle(\boldsymbol{\lambda}-\max(B-m,0)\boldsymbol{\alpha}_{1}-B\boldsymbol{\alpha}_{2})\cdot\boldsymbol{\alpha}_{1}$
$\displaystyle j^{(2)}(\boldsymbol{\omega})$ $\displaystyle=$
$\displaystyle(\boldsymbol{\lambda}-A\boldsymbol{\alpha}_{1}-\max(A-n,0)\boldsymbol{\alpha}_{2})\cdot\boldsymbol{\alpha}_{2}$
$\displaystyle j^{(3)}(\boldsymbol{\omega})$ $\displaystyle=$
$\displaystyle(\boldsymbol{\lambda}-(A-B)\boldsymbol{\alpha}_{1})\cdot\boldsymbol{\alpha_{3}}\
\text{ when}~{}A\geq B$ (21) $\displaystyle=$
$\displaystyle(\boldsymbol{\lambda}-(B-A)\boldsymbol{\alpha}_{2})\cdot\boldsymbol{\alpha}_{3}\
\text{ when}~{}B\geq A$

and the corresponding
$\vec{m}(\boldsymbol{\omega})=\\{m^{(1)}(\boldsymbol{\omega}),m^{(2)}(\boldsymbol{\omega}),m^{(3)}(\boldsymbol{\omega})\\}$
will be

$m^{(i)}(\boldsymbol{\omega})=\left(\boldsymbol{\lambda}-A\boldsymbol{\alpha}_{1}-B\boldsymbol{\alpha}_{2}\right)\cdot\boldsymbol{\alpha}_{i}.$
(22)

These $j^{(i)}$’s can be seen from the point of view of the
$U_{q}(\mathfrak{sl}_{2})$ subalgebra generated by
$\\{E^{\pm}_{\boldsymbol{\alpha}_{i}},H_{\boldsymbol{\alpha}_{i}}\\}$. For
instance, for the marked point ‘F’ in Figure 1, given by the state (19),
$j^{(1)}$ corresponds to projection of weight state at point ‘E’ with
$\boldsymbol{\alpha}_{1}$. So,

$j^{(1)}(\boldsymbol{\omega}=\boldsymbol{\lambda}-4\boldsymbol{\alpha}_{1}-3\boldsymbol{\alpha}_{2})=\left(5\boldsymbol{\mu}_{1}+2\boldsymbol{\mu}_{2}-\boldsymbol{\alpha}_{1}-3\boldsymbol{\alpha}_{2}\right)\cdot\boldsymbol{\alpha}_{1}~{}.$
(23)

Similarly, it is easy to see that the projection of weight state marked ‘G’
with $\boldsymbol{\alpha}_{2}$ will give
$j^{(2)}(\boldsymbol{\omega}=\boldsymbol{\lambda}-4\boldsymbol{\alpha}_{1}-3\boldsymbol{\alpha}_{2})$
and ‘H’ with $\boldsymbol{\alpha}_{3}$ will give
$j^{(3)}(\boldsymbol{\omega}=\boldsymbol{\lambda}-4\boldsymbol{\alpha}_{1}-3\boldsymbol{\alpha}_{2})$
.

###  3.1 Algebraic expression of $U_{q}{(\mathfrak{sl}_{3})}$ q-CG
coefficients

As the tensor product decomposition of two symmetric representation(1) for
$U_{q}(\mathfrak{sl}_{3})$ is same as $U_{q}(\mathfrak{sl}_{2})$, the highest
weight states of the irreducible representations can be obtained as follows:

$|\boldsymbol{\Lambda}^{(s)},\boldsymbol{\Omega}=\boldsymbol{\Lambda}^{(s)}\rangle=\sum_{k_{1}+k_{2}=s}C^{\boldsymbol{\lambda}_{1},\boldsymbol{\lambda}_{2}}_{\boldsymbol{\omega}_{1},\boldsymbol{\omega}_{2}}(\boldsymbol{\Lambda}^{(s)},\boldsymbol{\Omega})|\boldsymbol{\lambda}_{1},\boldsymbol{\omega}_{1}=\boldsymbol{\lambda}_{1}-k_{1}\boldsymbol{\alpha}_{1}\rangle|\boldsymbol{\lambda}_{2},\boldsymbol{\omega}_{2}=\boldsymbol{\lambda}_{2}-k_{2}\boldsymbol{\alpha}_{1}\rangle~{},$
(24)

where
$\boldsymbol{\Lambda}^{(s)}=(n_{1}+n_{2}-2s)\boldsymbol{\mu}_{1}+s\boldsymbol{\mu}_{2}$,
$\boldsymbol{\lambda}_{1}=n_{1}\boldsymbol{\mu}_{1}$ and
$\boldsymbol{\lambda}_{2}=n_{2}\boldsymbol{\mu}_{1}$. Note that, the summation
$k_{1},k_{2}$ variables obeying the condition, $k_{1}+k_{2}=s$, is same as the
weight vector

$\boldsymbol{\Lambda}^{(s)}=\boldsymbol{\Omega}=\boldsymbol{\omega}_{1}+\boldsymbol{\omega}_{2}.$

Comparing with the $U_{q}(\mathfrak{sl}_{2})$ q-CG coefficients, these
$U_{q}(\mathfrak{sl}_{3})$ q-CG coefficients must obey:

$C^{\boldsymbol{\lambda}_{1},\boldsymbol{\lambda}_{2}}_{\boldsymbol{\omega}_{1},\boldsymbol{\omega}_{2}}(\boldsymbol{\Lambda}^{(s)},\boldsymbol{\Omega}=\boldsymbol{\Lambda}^{(s)})=\begin{bmatrix}\boldsymbol{\lambda}_{1}&\boldsymbol{\lambda}_{2}&\boldsymbol{\Lambda}^{(s)}\\\
\boldsymbol{\omega}_{1}&\boldsymbol{\omega}_{2}&\boldsymbol{\Omega}\end{bmatrix}_{U_{q}(\mathfrak{sl}_{3})}={\begin{bmatrix}\frac{n_{1}}{2}&\frac{n_{2}}{2}&\frac{n_{1}+n_{2}}{2}\\\
\frac{n_{1}}{2}-k_{1}&\frac{n_{2}}{2}-k_{2}&\frac{n_{1}+n_{2}}{2}-s\end{bmatrix}}_{U_{q}({\mathfrak{sl}_{2}})}~{}.$
(25)

In fact, the above q-CG expression should be the same for
$U_{q}(\mathfrak{sl}_{N})$ as well. We can now apply the sequence of ladder
operators (following appendix A) on the highest weight state(24) to obtain all
the states within each irreducible representations $(n_{1}+n_{2}-2s,s)$.

Applying
$(E_{\boldsymbol{\alpha}_{2}}^{-})^{l_{2}}(E_{\boldsymbol{\alpha}_{1}}^{-})^{l_{1}}$
ladder operators on the highest weight state (24):

$\left(E_{\boldsymbol{\alpha}_{2}}^{-}\right)^{l_{2}}\left(E_{\boldsymbol{\alpha}_{1}}^{-}\right)^{l_{1}}|\boldsymbol{\Lambda}^{(s)},\boldsymbol{\Omega}=\boldsymbol{\Lambda}^{(s)}\rangle=H_{\boldsymbol{\alpha}_{1},l_{1}}(\boldsymbol{\Omega})H_{\boldsymbol{\alpha}_{2},l_{2}}(\boldsymbol{\Omega-
l_{1}\boldsymbol{\alpha}_{1}})|\boldsymbol{\Lambda}^{(s)},\boldsymbol{\Omega}-\sum_{i=1}^{2}l_{i}\boldsymbol{\alpha}_{i}\rangle~{},$
(26)

where $H_{\boldsymbol{\alpha}_{i},l}(\boldsymbol{\Omega})$ in terms of
$\vec{j}$(21) is

$H_{\boldsymbol{\alpha}_{i},l}(\boldsymbol{\Omega})=\left(\frac{[j^{(i)}(\boldsymbol{\Omega})+m^{(i)}(\boldsymbol{\Omega})]![j^{(i)}(\boldsymbol{\Omega})-m^{(i)}(\boldsymbol{\Omega})+l]!}{[j^{(i)}(\boldsymbol{\Omega})+m^{(i)}(\boldsymbol{\Omega})-l]![j^{(i)}(\boldsymbol{\Omega})-m^{(i)}(\boldsymbol{\Omega})]!}\right)^{1/2}~{}.$
(27)

Similarly, the co-product action on the tensor product states in the RHS of
equation(24):

$\displaystyle\left(\Delta
E_{\boldsymbol{\alpha}_{1}}^{-}\right)^{l_{2}}\left(\Delta
E_{\boldsymbol{\alpha}_{1}}^{-}\right)^{l_{1}}|\boldsymbol{\lambda}_{1},\boldsymbol{\omega}_{1}=\boldsymbol{\lambda}_{1}-k_{1}\boldsymbol{\alpha}_{1}\rangle|\boldsymbol{\lambda}_{2},\boldsymbol{\omega}_{2}=\boldsymbol{\lambda}_{1}-k_{2}\boldsymbol{\alpha}_{1}\rangle=~{}~{}~{}~{}~{}~{}~{}~{}~{}$
$\displaystyle~{}~{}~{}~{}~{}\sum_{x_{i}+y_{i}=l_{i}}F_{\boldsymbol{\alpha}_{1},l_{1}}^{x_{1},y_{1}}(\boldsymbol{\omega}_{1},\boldsymbol{\omega}_{2})F_{\boldsymbol{\alpha}_{2},l_{2}}^{x_{2},y_{2}}(\boldsymbol{\omega}_{1}-x_{1}\boldsymbol{\alpha}_{1},\boldsymbol{\omega}_{2}-y_{1}\boldsymbol{\alpha}_{1})$
$\displaystyle|\boldsymbol{\lambda}_{1},\boldsymbol{\omega}_{1}-\sum_{i=1}^{2}x_{i}\boldsymbol{\alpha}_{i}\rangle|\boldsymbol{\lambda}_{2},\boldsymbol{\omega}_{2}-\sum_{i=1}^{2}y_{i}\boldsymbol{\alpha}_{i}\rangle~{},$
(28)

where
$F^{(x,y)}_{\boldsymbol{\alpha}_{i},l}(\boldsymbol{\omega}_{1},\boldsymbol{\omega}_{2})$
in terms of the $U_{q}(\mathfrak{sl}_{2})$ variables (21) turns out to be

$\displaystyle
F^{(x,y)}_{\boldsymbol{\alpha}_{i},l}(\boldsymbol{\omega}_{1},\boldsymbol{\omega}_{2})$
$\displaystyle=$ $\displaystyle
q^{\frac{1}{2}(xm^{(i)}(\boldsymbol{\omega}_{2})-ym^{(i)}(\boldsymbol{\omega}_{1}))}\frac{[x+y]!}{[x]![y]!}\times$
(29)
$\displaystyle\times\left(\frac{[j^{(i)}(\boldsymbol{\omega}_{2})+m^{(i)}(\boldsymbol{\omega}_{2})]![j^{(i)}(\boldsymbol{\omega}_{1})+m^{(i)}((\boldsymbol{\omega}_{1})]!}{[j^{(i)}(\boldsymbol{\omega}_{2})-m^{(i)}(\boldsymbol{\omega}_{2})]![j^{(i)}(\boldsymbol{\omega}_{1})-m^{(i)}(\boldsymbol{\omega}_{1})]!}\right)^{1/2}$
$\displaystyle\times\left(\frac{[j^{(i)}(\boldsymbol{\omega}_{2})-m^{(i)}(\boldsymbol{\omega}_{2})+y]![j^{(i)}(\boldsymbol{\omega}_{1})-m^{(i)}(\boldsymbol{\omega}_{1})+x]!}{[j^{(i)}(\boldsymbol{\omega}_{2})+m^{(i)}(\boldsymbol{\omega}_{2})-y]![j^{(i)}(\boldsymbol{\omega}_{1})+m^{(i)}(\boldsymbol{\omega}_{1})-x]!}\right)^{1/2}~{}.$

Hence incorporating the equations(28,26), the associated state in the weight
diagram of the representation $(n_{1}+n_{2}-2s,s)$ will be

$\displaystyle|\boldsymbol{\Lambda}^{(s)},\boldsymbol{\Omega}-\sum_{i=1}^{2}l_{i}\boldsymbol{\alpha}_{i}\rangle$
$\displaystyle=$
$\displaystyle\sum_{k_{1},k_{2}}\sum_{x_{i}+y_{i}=l_{i}}(-1)^{s}C^{\boldsymbol{\lambda}_{1},\boldsymbol{\lambda}_{2}}_{\boldsymbol{\omega}_{1},\boldsymbol{\omega}_{2}}(\boldsymbol{\Lambda}^{(s)},\boldsymbol{\Omega})\frac{F_{\boldsymbol{\alpha}_{1},l_{1}}^{x_{1},y_{1}}(\boldsymbol{\omega}_{1},\boldsymbol{\omega}_{2})}{H_{\boldsymbol{\alpha}_{1},l_{1}}(\boldsymbol{\Omega})}$
(30)
$\displaystyle\frac{F_{\boldsymbol{\alpha}_{2},l_{2}}^{x_{2},y_{2}}(\boldsymbol{\omega}_{1}-x_{1}\boldsymbol{\alpha}_{1},\boldsymbol{\omega}_{2}-x_{2}{\boldsymbol{\alpha}_{1}})}{H_{\boldsymbol{\alpha}_{2},l_{2}}(\boldsymbol{\Omega}-l_{1}{\boldsymbol{\alpha}_{1}})}|\boldsymbol{\lambda}_{1},\boldsymbol{\omega}_{1}-\sum_{i=1}^{2}x_{i}\boldsymbol{\alpha}_{i}\rangle|\boldsymbol{\lambda}_{2},\boldsymbol{\omega}_{2}-\sum_{i=1}^{2}y_{i}\boldsymbol{\alpha}_{i}\rangle~{},$

where $(-1)^{s}$ is just a choice of the sign.

We can read off $U_{q}(\mathfrak{sl}_{3})$ q-CG coefficients from the above
state decomposition:

$\displaystyle
C^{\boldsymbol{\lambda}_{1},\boldsymbol{\lambda}_{2}}_{\boldsymbol{\omega}_{1}-{\sum}_{i=1}^{2}x_{i}\boldsymbol{\alpha}_{i},\boldsymbol{\omega}_{2}-\sum_{i=1}^{2}y_{i}\boldsymbol{\alpha}_{i}}(\boldsymbol{\Lambda}^{(s)},\boldsymbol{\Omega}-l_{1}\boldsymbol{\alpha}_{1}-l_{2}\boldsymbol{\alpha}_{2})=$
(31)
$\displaystyle(-1)^{s}C^{\boldsymbol{\lambda}_{1},\boldsymbol{\lambda}_{2}}_{\boldsymbol{\omega}_{1},\boldsymbol{\omega}_{2}}(\boldsymbol{\Lambda}^{(s)},\boldsymbol{\Omega})\frac{F_{\boldsymbol{\alpha}_{1},l_{0}}^{x_{1},y_{1}}(\boldsymbol{\omega}_{1},\boldsymbol{\omega}_{2})}{H_{\boldsymbol{\alpha}_{1},l_{1}}(\boldsymbol{\Omega})}~{}~{}\frac{F_{\boldsymbol{\alpha}_{2},l_{2}}^{x_{2},y_{2}}(\boldsymbol{\omega}_{1}-x_{1}\boldsymbol{\alpha}_{1},\boldsymbol{\omega}_{2}-y_{1}\boldsymbol{\alpha}_{1})}{H_{\boldsymbol{\alpha}_{2},l_{2}}(\boldsymbol{\Omega}-l_{1}\boldsymbol{\alpha}_{1})}~{}.$

Applying $(E_{\boldsymbol{\alpha}_{3}}^{-})^{l_{3}}$ ladder operator on the
highest weight state (24), we can obtain

$\displaystyle|\boldsymbol{\Lambda}^{(s)},\boldsymbol{\Omega}-l_{3}\boldsymbol{\alpha}_{3}\rangle$
$\displaystyle=$
$\displaystyle\sum_{k_{1},k_{2}}\sum_{x_{3}+y_{3}=l_{3}}(-1)^{s}C^{\boldsymbol{\lambda}_{1},\boldsymbol{\lambda}_{2}}_{\boldsymbol{\omega}_{1},\boldsymbol{\omega}_{2}}(\boldsymbol{\Lambda}^{(s)},\boldsymbol{\Omega})\frac{F_{\boldsymbol{\alpha}_{3},l_{3}}^{x_{3},y_{3}}(\boldsymbol{\omega}_{1},\boldsymbol{\omega}_{2})}{H_{\boldsymbol{\alpha}_{3},l_{3}}(\boldsymbol{\Omega})}$
$\displaystyle~{}~{}~{}~{}~{}~{}~{}~{}~{}~{}|\boldsymbol{\lambda}_{1},\boldsymbol{\omega}_{1}-x_{3}\boldsymbol{\alpha}_{3}\rangle|\boldsymbol{\lambda}_{2},\boldsymbol{\omega}_{2}-y_{3}\boldsymbol{\alpha}_{3}\rangle~{}.$
(32)

Note that the above state will have the same weight vector of the state(30)
when $l_{3}=l_{1}=l_{2}\neq 0$ but they are linearly independent states and
not orthogonal. Hence, we can perform the conventional Gram-Schmidt
orthogonalisation procedure to obtain state which is orthonormal to
$|\boldsymbol{\Lambda}^{(s)},\boldsymbol{\Omega}-l_{3}\boldsymbol{\alpha}_{3}\rangle\big{|}_{l_{1}=l_{2}=l_{3}}$:

$\mathcal{N}\left(|\boldsymbol{\Lambda}^{(s)},\boldsymbol{\Omega}-\sum_{i=1}^{2}l_{i}\boldsymbol{\alpha}_{i}\rangle\big{|}_{l_{1}=l_{2}=l_{3}}-\langle\boldsymbol{\Lambda}^{(s)},\boldsymbol{\Omega}-\sum_{i=1}^{2}l_{i}\boldsymbol{\alpha}_{i}|\boldsymbol{\Lambda}^{(s)},\boldsymbol{\Omega}-l_{3}\boldsymbol{\alpha}_{3}\rangle|\boldsymbol{\Lambda}^{(s)},\boldsymbol{\Omega}-l_{3}\boldsymbol{\alpha}_{3}\rangle\big{|}_{l_{1}=l_{2}=l_{3}}\right)~{}.$
(33)

The overall factor $\mathcal{N}$ required for obtaining normalised states. We
can now extract q-CG coefficients
$C^{\boldsymbol{\lambda}_{1},\boldsymbol{\lambda}_{2}}_{\boldsymbol{\omega}_{1}-x_{3}\boldsymbol{\alpha}_{3},\boldsymbol{\omega}_{2}-y_{3}\boldsymbol{\alpha}_{3}}(\boldsymbol{\Lambda}^{(s)},\boldsymbol{\Omega}-l_{3}\boldsymbol{\alpha}_{3})$.

The methodology we have presented generalises to any arbitrary state(19) and
we have implemented them in a Mathematica program to determine $U_{q}(sl_{3})$
q-CG coefficients for this class of decomposition of tensor product of
symmetric representations(1).

Under conjugation, $U_{q}(\mathfrak{sl}_{3})$ representation
$(n,m)\rightarrow(m,n)$. That is,
$\boldsymbol{\mu}_{1}\leftrightarrow\boldsymbol{\mu}_{2}$. We propose the q-CG
coefficients for the conjugate of tensor product decomposition (1) to satisfy

$\begin{bmatrix}n_{1}\boldsymbol{\mu}_{2}&n_{2}\boldsymbol{\mu}_{2}&\bar{\boldsymbol{\Lambda}}^{(s)}\\\
\bar{\boldsymbol{\omega}}_{1}&\bar{\boldsymbol{\omega}}_{2}&\bar{\boldsymbol{\Omega}}\end{bmatrix}_{U_{q}(\mathfrak{sl}_{3})}=\begin{bmatrix}n_{1}\boldsymbol{\mu}_{1}&n_{2}\boldsymbol{\mu}_{1}&\boldsymbol{\Lambda}^{(s)}\\\
\boldsymbol{\omega}_{1}&\boldsymbol{\omega}_{2}&\boldsymbol{\Omega}\end{bmatrix}_{U_{q}(\mathfrak{sl}_{3})}~{},$
(34)

for all the points in the weight diagram where the diagram gets mirror
reflected so that the roots
$\boldsymbol{\alpha}_{1}\leftrightarrow\boldsymbol{\alpha}_{2}$. Hence, the
conjugate
$\bar{\boldsymbol{\Lambda}}^{(s)}=s\boldsymbol{\mu}_{1}+(n_{1}+n_{2}-2s)\boldsymbol{\mu}_{2}$
and
$\bar{\boldsymbol{\omega}}=n_{1}\boldsymbol{\mu}_{2}-A\boldsymbol{\alpha}_{2}-B\boldsymbol{\alpha}_{1}$
for
$\boldsymbol{\omega}=n_{1}\boldsymbol{\mu}_{1}-A\boldsymbol{\alpha}_{1}-B\boldsymbol{\alpha}_{2}$.

##  4 Conclusion

In this paper, we focused on the tensor product decomposition of symmetric
representation (1) and defined the linear independent weight states within
every irreducible representation $\boldsymbol{\Lambda}^{(s)}$. Using the
$U_{q}(\mathfrak{sl}_{2})$ q-CG for the highest weight states (24), we could
systematically obtain an algebraic expression for $U_{q}(\mathfrak{sl}_{3})$
q-CG coefficients (3.1) for states (black dotted) in the weight diagram.

Further, the multiple states in the inner shell of the weight diagram can be
shown to be linearly independent but not orthogonal. After performing Gram-
Schmidt orthogonalisations, the q-CG coefficients for those states (indicated
as red, green …concentric circles) can be obtained. These q-CG coefficients
are tabulated in appendix B for symmetric representations whose Young diagram
presentation is up to two and three boxes. Further, the Mathematica program
will enable computing for other symmetric representation. This compiled data
of $U_{q}(\mathfrak{sl}_{3})$ q-CG coefficients is useful to obtain R-matrix
elements of new bi-partite vertex models[7, 8].

It is still a challenging problem to attempt q-CG for a most general tensor
product decomposition

$(n_{1},m_{1})\otimes(n_{2},m_{2})=\oplus_{i}(N_{i},M_{i})~{},$

where some of the irreducible representation may occur more than once. Unlike
$(n,0)$ states where every state occurs only once, the general $(n_{1},m_{1})$
states will have multiplicity. We hope to pursue them in future.

## Acknowledgments

We would like to thank Abhishek, Saswati, Vivek for discussions during the
initial stages of the project. PR would like to thank SERB (MATRICS)
MTR/2019/000956 funding. PR is grateful to ICTP senior associateship funding
for visit where this paper was finalised.

##  Appendix A Systematic sequence of ladder operation to obtain Black,
Red,$\cdots$ states

To get a orthonormal set for black dotted states we have to follow paths
according to Figure 2. First we have to apply different powers
$(E_{\boldsymbol{\alpha}_{3}}^{-})$ on the highest weight state $(5,2)$ to
reach all the points ‘P’,‘Q’,$\cdots$ up to ‘L’. This path divides the weight
diagram in upper and lower halves.

(5,2)$\boldsymbol{\alpha}_{1}$$\boldsymbol{\alpha}_{2}$$\boldsymbol{\alpha}_{3}$$\tiny
P$$\tiny L$$\tiny M$$\tiny N$$\tiny Q$ Figure 2: Sequence of ladder operation
for black dotted states

Now to span all the points of upper half of the weight diagram, we have to
follow sequence of ladder operators like -
$(E_{\boldsymbol{\alpha}_{3}}^{-})^{l_{3}}(E_{\boldsymbol{\alpha}_{2}}^{-})^{l_{2}}$,
acting on the highest weight $(5,2)$. Similarly for lower half states we have
to follow sequence like -
$(E_{\boldsymbol{\alpha}_{3}}^{-})^{l_{3}}(E_{\boldsymbol{\alpha}_{1}}^{-})^{l_{1}}$,
also acts on the highest weight. So in Figure 2, the states associated to
‘L’,‘M’ and ‘N’, are as follows:

$\displaystyle|L;\text{black}\rangle$
$\displaystyle=(E_{\boldsymbol{\alpha}_{3}}^{-})^{7}|\boldsymbol{\lambda},\boldsymbol{\lambda}=5\boldsymbol{\mu}_{1}+2\boldsymbol{\mu}_{2}\rangle$
(35) $\displaystyle|M;\text{black}\rangle$
$\displaystyle=(E_{\boldsymbol{\alpha}_{3}}^{-})^{5}(E_{\boldsymbol{\alpha}_{2}}^{-})^{2}|\boldsymbol{\lambda},\boldsymbol{\lambda}\rangle$
$\displaystyle|N;\text{black}\rangle$
$\displaystyle=(E_{\boldsymbol{\alpha}_{3}}^{-})^{3}(E_{\boldsymbol{\alpha}_{1}}^{-})^{2}|\boldsymbol{\lambda},\boldsymbol{\lambda}\rangle~{}.$

Now for the red circled states, first to reach the weight state indicated as
‘P’ in Figure 3, we have to choose a sequence of ladder operators which is
different from Figure 2 and which should give a linearly independent state for
$|P;\text{red}\rangle$. So the appropriate sequence here is
$(E_{\boldsymbol{\alpha}_{2}}^{-})(E_{\boldsymbol{\alpha}_{1}}^{-})$ on
highest weight $(5,2)$, to reach ‘P’.

(5,2)$\boldsymbol{\alpha}_{1}$$\boldsymbol{\alpha}_{2}$$\boldsymbol{\alpha}_{3}$$\tiny
P$$\tiny N$$\tiny Q$ Figure 3: Sequence of ladder operation for red circled
states

Then we follow the procedure similar to above i.e. applying
$(E_{\boldsymbol{\alpha}_{3}}^{-})^{l_{3}}(E_{\boldsymbol{\alpha}_{1}}^{-})^{l_{1}}$
or
$(E_{\boldsymbol{\alpha}_{3}}^{-})^{l_{3}}(E_{\boldsymbol{\alpha}_{1}}^{-})^{l_{1}}$
on the weight ‘P’. So we can write $|N;\text{red}\rangle$ which is linearly
independent to $|N;\text{black}\rangle$:

$|N;\text{red}\rangle=(E_{\boldsymbol{\alpha}_{3}}^{-})^{3}(E_{\boldsymbol{\alpha}_{1}}^{-})|P;\text{red}\rangle=(E_{\boldsymbol{\alpha}_{3}}^{-})^{3}(E_{\boldsymbol{\alpha}_{1}}^{-})[(E_{\boldsymbol{\alpha}_{2}}^{-})(E_{\boldsymbol{\alpha}_{1}}^{-})]|\boldsymbol{\lambda},\boldsymbol{\lambda}\rangle~{}.$
(36)

Similarly for green circled states, we reach the weight state indicated by ‘Q’
by performing
$(E_{\boldsymbol{\alpha}_{2}}^{-})^{2}(E_{\boldsymbol{\alpha}_{1}}^{-})^{2}$
on $|\boldsymbol{\lambda},\boldsymbol{\lambda}\rangle$ and then other states
can be reached by the same type of operations as above. So we can write
$|N;\text{green}\rangle$, which is linearly independent to
$|N;\text{black}\rangle$ and $|N;\text{red}\rangle$ as

$|N,\text{green}\rangle=(E_{\boldsymbol{\alpha}_{3}}^{-})^{2}(E_{\boldsymbol{\alpha}_{1}}^{-})|Q;\text{green}\rangle=(E_{\boldsymbol{\alpha}_{3}}^{-})^{2}(E_{\boldsymbol{\alpha}_{1}}^{-})[(E_{\boldsymbol{\alpha}_{2}}^{-})^{2}(E_{\boldsymbol{\alpha}_{1}}^{-})^{2}]|\boldsymbol{\lambda},\boldsymbol{\lambda}\rangle~{}.$
(37)

Note that, this method gives three states,
$|N;\text{black}\rangle$,$|N;\text{green}\rangle$ and $|N;\text{red}\rangle$
which are only linearly independent but not orthonormal and to make them
orthonormal we perform Gram-Schmidt orthonormalisation on
$|N;\text{green}\rangle$ and $|N;\text{red}\rangle$.

##  Appendix B Quantum Clebsch-Gordan coefficients for different irreducible
representations

### • q-CG Coefficients for tensor product of ${\tiny\yng(1)}$ and
${\tiny\yng(1)}$ for $U_{q}(\mathfrak{sl}_{3})$ group

${\Yautoscale 1\yng(1)}\otimes{\Yautoscale 1\yng(1)}=\underbrace{\Yautoscale
1\yng(2)}_{[2,0]}\oplus\underbrace{\Yautoscale 1\yng(1,1)}_{[0,1]}$

#### All the weight states belonging to irreducible representation
$\boldsymbol{\Lambda}^{(0)}=2\boldsymbol{\mu}_{1}={\Yautoscale 1\yng(2)}$

(From here, we refer the highest weight
$|\boldsymbol{\lambda},\boldsymbol{\lambda}\rangle$ as
$|\boldsymbol{\lambda}\rangle$ and other weights
$|\boldsymbol{\lambda},\boldsymbol{\omega}\rangle$ as
$|\boldsymbol{\omega}\rangle$. Note that, the first states are always the
highest weight states.)

#### All the weight states belonging to irreducible representation
$\boldsymbol{\Lambda}^{(1)}=\boldsymbol{\mu}_{2}={\Yautoscale 1\yng(1,1)}$

From equation ($38$) it is quite evident that the corresponding q-CG
coefficients are

$\begin{bmatrix}\boldsymbol{\mu}_{1}&\boldsymbol{\mu}_{1}&\boldsymbol{\mu}_{2}\\\
\boldsymbol{\mu}_{1}-\boldsymbol{\alpha}_{1}&\boldsymbol{\mu}_{1}-\boldsymbol{\alpha}_{1}-\boldsymbol{\alpha}_{2}&\boldsymbol{\mu}_{2}-\boldsymbol{\alpha}_{1}-\boldsymbol{\alpha}_{2}\end{bmatrix}_{U_{q}(\mathfrak{sl}_{3})}=\frac{q^{-1/4}}{\sqrt{[2]}}$

and

$\begin{bmatrix}\boldsymbol{\mu}_{1}&\boldsymbol{\mu}_{1}&\boldsymbol{\mu}_{2}\\\
\boldsymbol{\mu}_{1}-\boldsymbol{\alpha}_{1}-\boldsymbol{\alpha}_{2}&\boldsymbol{\mu}_{1}-\boldsymbol{\alpha}_{1}&\boldsymbol{\mu}_{2}-\boldsymbol{\alpha}_{1}-\boldsymbol{\alpha}_{2}\end{bmatrix}_{U_{q}(\mathfrak{sl}_{3})}=-\frac{q^{1/4}}{\sqrt{[2]}}~{}.$

Similarly, all the q-CG coefficients can be extracted from the following set
of states for each irreducible representation.

### • q-CG Coefficients for tensor product of ${\tiny\yng(2)}$ and
${\tiny\yng(1)}$ for $U_{q}(\mathfrak{sl}_{3})$ group

${\Yautoscale 1\yng(2)}\otimes{\Yautoscale 1\yng(1)}=\underbrace{\Yautoscale
1\yng(3)}_{[3,0]}\oplus\underbrace{\Yautoscale 1\yng(2,1)}_{[1,1]}$

#### All the weight states belonging to irreducible representation 1(3)

#### All the black dotted states belonging to irreducible representation
1(2,1)

#### All the red circled states belonging to irreducible representation 1(2,1)
(only linearly independent to the black dotted states with same weights)

#### The red circled states of 1(2,1) representation (after Gram-Schmidt
orthonormalisation) from where q-CG coefficients can be extracted

### • q-CG Coefficients for tensor product of ${\tiny\yng(2)}$ and
${\tiny\yng(2)}$ for $U_{q}(\mathfrak{sl}_{3})$ group

${\Yautoscale 1\yng(2)}\otimes{\Yautoscale 1\yng(2)}=\underbrace{\Yautoscale
1\yng(4)}_{[4]}\oplus\underbrace{\Yautoscale
1\yng(3,1)}_{[2,1]}\oplus\underbrace{\Yautoscale 1\yng(2,2)}_{[0,2]}$

#### All the weight states belonging to irreducible representation 1(4)

#### All the black dotted states belonging to irreducible representation
1(3,1)

#### All the red circled states belonging to irreducible representation 1(3,1)
(only linearly independent to the black dotted states with same weights)

#### The red circled states of 1(3,1) representation (after Gram-Schmidt
orthonormalisation) from where q-CG coefficients can be extracted

#### All the weight states belonging to irreducible representation 1(2,2)

### • q-CG Coefficients for ${\tiny\yng(3)}$ and ${\tiny\yng(1)}$ for
$U_{q}(\mathfrak{sl}_{3})$ group

${\Yautoscale 1\yng(3)}\otimes{\Yautoscale 1\yng(1)}=\underbrace{\Yautoscale
1\yng(4)}_{[4]}\oplus\underbrace{\Yautoscale 1\yng(3,1)}_{[2,1]}$

#### All the weight states belonging to irreducible representation 1(4)

#### All the black dotted states belonging to irreducible representation
1(3,1)

#### All the red circled states belonging to irreducible representation 1(3,1)
(only linearly independent to the black dotted states with same weights)

### • q-CG Coefficients for tensor product of ${\tiny\yng(3)}$ and
${\tiny\yng(2)}$ for $U_{q}(\mathfrak{sl}_{3})$ group

${\Yautoscale 1\yng(3)}\otimes{\Yautoscale 1\yng(2)}=\underbrace{\Yautoscale
1\yng(5)}_{[5]}\oplus\underbrace{\Yautoscale
1\yng(4,1)}_{[3,1]}\oplus\underbrace{\Yautoscale 1\yng(3,2)}_{[1,2]}$

#### All the weight states belonging to irreducible representation 1(5)

#### All the black dotted states belonging to irreducible representation
1(3,1)

#### All the black dotted states belonging to irreducible representation
1(3,2)

### • Example of a state with $3$-multiplicity belonging to $(2,2)$
irreducible representation in the tensor product of ${\tiny\yng(3)}$ and
${\tiny\yng(3)}$ for $U_{q}(\mathfrak{sl}_{3})$ group

${\Yautoscale 1\yng(3)}\otimes{\Yautoscale 1\yng(3)}=\underbrace{\Yautoscale
1\yng(6)}_{[6]}\oplus\underbrace{\Yautoscale
1\yng(5,1)}_{[4,1]}\oplus\underbrace{\Yautoscale
1\yng(4,2)}_{[2,2]}\oplus\underbrace{\Yautoscale 1\yng(3,3)}_{[0,3]}$

#### The center state belonging to 1(4,2) representation with $3$-multiplicity
(normalized and linearly independent)

#### The center $3$-miltiplicity state belonging to 1(4,2) representation
(after Gram-Schmidt orthonormalisation) from where q-CG coefficients can be
extracted

## References

  * [1] L. C. Biedenharn and J. D. Louck. Angular momentum in quantum physics. Cambridge University Press, 2009.
  * [2] L. C. Biedenharn and J. D. Louck. The Racah-Wigner algebra in quantum theory. Cambridge University Press, 1984.
  * [3] Kulish, P.P., Reshetikhin, N.Y. Quantum linear problem for the sine-Gordon equation and higher representations. J Math Sci 23, 2435–2441 (1983).
  * [4] Drinfel’d, V.G. Quantum groups. J Math Sci 41, 898–915 (1988)
  * [5] Alekseev, A., Shatashvili, S. Quantum groups and WZNW models. Commun.Math. Phys. 133, 353–368, (1990)
  * [6] Yasuhiro Akutsu and Miki Wadati, Knots, Links, Braids and Exactly Solvable Models in Statistical Mechanics, Communications in mathematical physics, 117 (2):2432(1988).
  * [7] Romesh K Kaul. Chern-simons theory, knot invariants, vertex models and three-manifold invariants. arXiv:hep-th/9804122, 1998.
  * [8] Saswati Dhara, Romesh K. Kaul, P. Ramadevi, and Vivek Kumar Singh. Bi-partite vertex model and multi-colored link invariants.  arXiv:1811.07538 [hep-th], 2018.
  * [9] Dennis Bonatsos and C Daskaloyannis. Quantum groups and their applications in nuclear physics. Prog.Part.Nucl.Phys. 43 (1999) 537-618,  arXiv:nucl-th/9909003.
  * [10] Raychev, P. Quantum Groups: Application to Nuclear and Molecular Spectroscopy. Advances in Quantum Chemistry Volume 26, Pages 239-357, ( 1995).
  * [11] A N Kirillov and N Yu Reshetikhin. Representations of the algebra $U_{q}(sl(2))$, q-orthogonal polynomials and invariants of links. In New Developments in the Theory of Knots, Toshitake Kohno, Ed., pages 202–256. World Scientific, 1990.
  * [12] Masao Nomura, Relations for Clebsch–Gordan and Racah coefficients in $su_{q}(2)$ and Yang–Baxter equations. Journal of Mathematical Physics 30, 2397 (1989)
  * [13] E. Ardonne, J. Slingerland, Clebsch–Gordan and 6j-coefficients for rank 2 quantum groups, J. Phys. A: Math. Theor. 43 395205, (2010)
  * [14] Atakishiev, N.M., Suslov, S.K. Clebsch-Gordan coefficients for the quantum algebra $su_{q}(2)$. Theor Math Phys 98, 1–7 (1994).
  * [15] Howard Georgi. Lie algebras in particle physics: from isospin to unified theories. CRC Press, 2018\.


# Boundary Condition and the Auxiliary Phase in Feynman Path Integral

Chung-Ru Lee  Department of Mathematics
National University of Singapore<EMAIL_ADDRESS>Chin-Rong Lee  Physics
Department
National Chung Cheng University<EMAIL_ADDRESS>
###### Abstract

When employing Feynman path integrals to compute propagators in quantum
physics, the concept of summing over the set of all paths is not always naïve.
In fact, an auxiliary phase often has to be included as a weight for each
summand. In this article we discuss the nature of this auxiliary phase when
the classical path involved is reflected through the instance of a free
particle confined to a line segment.

##  I Introduction

The wave function of a free particle trapped in an infinite potential well has
been studied thoroughly using both the Schrödinger equation and Feynman path
integral [1].

Fix some $L>0$ and let

$H=\frac{p^{2}}{2m}+V(x)=-\frac{\hbar^{2}}{2m}\frac{d^{2}}{dx^{2}}+V(x),$

where $V(x)=\begin{cases}0&0\leq x\leq L\\\
\infty&\text{otherwise}\end{cases}$. The corresponding (time-independent)
Schrödinger equation is the eigenvalue problem

$\displaystyle H\psi=E\psi$ (1)

subject to the Dirichlet boundary condition $\psi(0)=\psi(L)=0$.

On the spectral end, the arising eigenvalues $E$ are discrete. One simply
label them as $E_{n}$ (each with multiplicity one) and the corresponding
eigenfunctions as $\psi_{n}=\left|n\right>$. In fact, after normalization

$\psi_{n}(x)=\sqrt{\frac{2}{L}}\sin(k_{n}x),$

where $k_{n}=\frac{n\pi}{L}$ and therefore
$E_{n}=\frac{\hbar^{2}}{2m}k_{n}^{2}=\frac{n^{2}\pi^{2}\hbar^{2}}{2mL^{2}}$
for $n=1,2,3,\dots$.

Decomposed by the spectrum of $H$, the propagator can then be computed by

$\displaystyle
K(y,t_{1};x,t_{0})=\frac{2}{L}\sum_{n=1}^{\infty}e^{\frac{i}{\hbar}E_{n}(t_{1}-t_{0})}\sin(k_{n}x)\sin(k_{n}y).$
(2)

On the other hand, since this is a case with a quadratic Laplacian, it
suffices to consider only the contribution from all classical paths [2, 3, 4,
5, 6]. The expansion along the momentum $p$ gives an expression for
$K(y,t_{1};x,t_{0})$:

$\displaystyle\sum_{r=-\infty}^{\infty}\frac{\epsilon_{r}}{2\pi\hbar}\int_{\mathbb{R}}e^{-\frac{i}{\hbar}\frac{p^{2}}{2m}(t_{1}-t_{0})}e^{\frac{i}{\hbar}p(y_{r}-x)}dp.$

where the sum over $r$ is the sum indexed by possible classical paths, and
$\epsilon_{r}$ is a unitary phase factor associated to the path to $y_{r}$.
Detail of these derivation can be found in [1, 7, 8], where they pointed out
that the $\epsilon_{r}$ above should be $(-1)^{r}$. Under such ansatz, the
results derived from the two ways of computing the propagator match.

One disparity between the two approaches lies within the assignment of phases.
Since Schrödinger equation deals with wave functions, it is by construction
that phases are included when considering the interaction between states. On
the other hand, even though path integral taken all paths into account, so far
it does not seem to exist an intrinsic way of associating phases to each path
in general. Related discussion can be found in [9, 10, 11].

To further study this auxiliary phase factor, certain modification on the
model has to be made. Instead of considering the infinite potential well, one
consider the wave function of an $1$-dimensional free particle confined to a
line segment $[0,L]$. This interpretation makes it sensible to discuss other
boundary conditions such as the Neumann boundary condition and so on.

In particular, the original problem of an infinite potential well can be
regarded as the special case of imposing the Dirichlet boundary condition on
both ends.

The main conclusion of this article goes as follows:

######  Ansatz.

When the boundary condition on each boundary point is assigned as Dirichlet or
Neumann type, the phase $\epsilon$ associated to a classical path
$\gamma:[t_{0},t_{1}]\rightarrow[0,L]$ can be computed by multiplying $-1$
(resp. $1$) each time the path reflects upon touching any boundary point with
Dirichlet (resp. Neumann) boundary condition.

##  II Neumann Boundary Conditions

In this section we consider (1) with the boundary condition
$\psi^{\prime}(0)=\psi^{\prime}(L)=0$. Once again, the eigenvalues in this
case are discrete multiplicity-free and will be labelled as $E_{n}$. The
corresponding eigenfunctions are

$\psi_{n}(x)=\sqrt{\frac{2}{L}}\cos(k_{n}x)$

with $k_{n}=\frac{n\pi}{L}$, $E_{n}=\frac{n^{2}\pi^{2}\hbar^{2}}{2mL^{2}}$ for
$n=1,2,\dots$. Note that here the case $n=0$ also contributes a nontrivial
solution $\psi_{0}=\sqrt{\frac{1}{L}}$.

Decompose by the spectrum of $H$, the propagator can $K(y,t_{1};x,t_{0})$
thereby be computed by

$\displaystyle\frac{1}{L}+\frac{2}{L}\sum_{n=1}^{\infty}e^{-\frac{i}{\hbar}E_{n}(t_{1}-t_{0})}\cos(k_{n}x)\cos(k_{n}y).$

Performing the path integral calculation gives another expression for
$K(y,t_{1};x,t_{0})$:

$\displaystyle\frac{1}{2\pi\hbar}\sum_{r=-\infty}^{\infty}\epsilon_{r}\int_{\mathbb{R}}e^{-\frac{i}{\hbar}\frac{p^{2}}{2m}(t_{1}-t_{0})}e^{\frac{i}{\hbar}p(y_{r}-x)}dp.$
(3)

$r=-2$$r=-1$$r=0$$r=1$$r=2$$0$$L$$2L$$3L$$-L$$-2L$$(x,t_{0})$$(y,t_{1})$$(y_{1},t_{1})$$(y_{2},t_{1})$$(y_{-1},t_{1})$$(y_{-2},t_{1})$
Figure 1: Several of the classical paths connecting $(x,t_{0})$ and
$(y,t_{1})$

The Ansatz indicates that $\epsilon_{r}=1$ in this case. Notice that

$y_{r}=\begin{cases}rL+y&\text{for even }r\\\ (r+1)L-y&\text{for odd
}r.\end{cases}$

Reset the parameter modulo $2$ as $r=2l$ for even $r$ or $2l-1$ for odd $r$
with $l\in\mathbb{Z}$ and plugging into (3), $K(y,t_{1};x,t_{0})$ is then

$\displaystyle\frac{1}{\pi\hbar}\int_{-\infty}^{\infty}\sum_{l=-\infty}^{\infty}e^{\frac{2ilLp}{\hbar}}e^{-\frac{i}{\hbar}\frac{p^{2}}{2m}(t_{1}-t_{0})}e^{-\frac{i}{\hbar}px}\cos(py/\hbar)dp$

By Poisson summation formula,

$\displaystyle\int_{-\infty}^{\infty}\sum_{l=-\infty}^{\infty}$ $\displaystyle
e^{2ilLp/\hbar}f(p)dp$
$\displaystyle=\frac{\pi\hbar}{L}\sum_{n=-\infty}^{\infty}f(\frac{n\pi\hbar}{L})=\frac{\pi\hbar}{L}\sum_{n=-\infty}^{\infty}f(k_{n}\hbar).$

Thus $K(y,t_{1};x,t_{0})$ equals

$\displaystyle\frac{1}{L}\sum_{n=-\infty}^{\infty}e^{-\frac{i}{\hbar}E_{n}(t_{1}-t_{0})}e^{-ik_{n}x}\cos(k_{n}y)$
$\displaystyle=$
$\displaystyle\frac{2}{L}\left(\frac{1}{2}+\sum_{n=1}^{\infty}e^{-\frac{i}{\hbar}E_{n}(t_{1}-t_{0})}\cos(k_{n}x)\cos(k_{n}y)\right).$
(4)

The last equation (4) follows from writing
$e^{-ik_{n}x}=\cos(k_{n}x)-i\sin(k_{n}x)$ and observe the parity of the
functions. The formula above matches the result of the spectral decomposition.

##  III Mixed Boundary Conditions

We now consider (1) with the boundary condition $\psi^{\prime}(0)=\psi(L)=0$.
Then the eigenfunctions, again labelled as $\psi_{n}$ are given by

$\psi_{n}(x)=\sqrt{\frac{2}{L}}\cos(k_{n}x)$

with $k_{n}=(n-\frac{1}{2})\frac{\pi}{L}$ and
$E_{n}=(n-\frac{1}{2})^{2}\frac{\pi^{2}\hbar^{2}}{2mL^{2}}$ for $n=1,2,\dots$.
The spectral decomposition tells us that $K(y,t_{1};x,t_{0})$ equals

$\frac{2}{L}\sum_{n=1}^{\infty}e^{-\frac{i}{\hbar}E_{n}(t_{1}-t_{0})}\cos(k_{n}x)\cos(k_{n}y).$

The path integral approach considers the (weighted) sum over classical paths

$\frac{1}{2\pi\hbar}\sum_{r=-\infty}^{\infty}\epsilon_{r}\int_{\mathbb{R}}e^{-\frac{i}{\hbar}\frac{p^{2}}{2m}(t_{1}-t_{0})}e^{\frac{i}{\hbar}p(y_{r}-x)}dp.$

The Ansatz indicates that $\epsilon_{r}=1$ if $r=-1,0$ modulo $4$ and
$\epsilon_{r}=-1$ if $r=1,2$ modulo $4$. We can therefore rewrite the sum as

$\displaystyle\frac{1}{\pi\hbar}\int_{-\infty}^{\infty}\sum_{l=-\infty}^{\infty}$
$\displaystyle
e^{4ilLp/\hbar}e^{-\frac{i}{\hbar}\frac{p^{2}}{2m}(t_{1}-t_{0})}e^{-\frac{i}{\hbar}px}$
$\displaystyle\cos(py/\hbar)(1-e^{2iLp/\hbar})dp$

Employing the Poisson summation formula,

$\int_{-\infty}^{\infty}\sum_{l=-\infty}^{\infty}e^{4ilLp/\hbar}f(p)dp=\frac{\pi\hbar}{2L}\sum_{b=-\infty}^{\infty}f(\frac{b\pi\hbar}{2L}).$

Thus $K(y,t_{1};x,t_{0})$ equals

$\displaystyle\frac{1}{2L}\sum_{b=-\infty}^{\infty}$ $\displaystyle
e^{-\frac{i}{\hbar}\frac{1}{2m}(\frac{b\pi\hbar}{2L})^{2}(t_{1}-t_{0})}$
$\displaystyle e^{-ib\pi x/2L}\cos(b\pi y/2L)(1-e^{ib\pi}).$

Note that $e^{ib\pi}=(-1)^{b}$, so

$1-e^{ib\pi}=\begin{cases}2&\text{for odd }b\\\ 0&\text{for even
}b\end{cases}.$

Writing the odd $b$ as $2n-1$, we have
$\frac{1}{2m}(\frac{b\pi\hbar}{2L})^{2}=\frac{\pi^{2}\hbar^{2}}{2mL^{2}}(n-\frac{1}{2})^{2}=E_{n}$
and $\frac{b\pi}{2L}=\frac{\pi}{L}(n-\frac{1}{2})=k_{n}$. That is,
$K(y,t_{1};x,t_{0})$ equals

$\displaystyle\frac{1}{L}\sum_{n=-\infty}^{\infty}e^{-\frac{i}{\hbar}E_{n}(t_{1}-t_{0})}e^{-ik_{n}x}\cos(k_{n}y)$
$\displaystyle=$
$\displaystyle\frac{2}{L}\sum_{n=-\infty}^{\infty}e^{-\frac{i}{\hbar}E_{n}(t_{1}-t_{0})}\cos(k_{n}x)\cos(k_{n}y).$
(5)

Again, this matches the result from spectral decomposition.

##  IV Remarks

Using the terminology of this article, in [1] it was stated that for Dirichlet
boundary condition, $\epsilon_{r}=(-1)^{r}$. This is a result of a phase
change by $-1$ each time the classical path reflects along the boundaries.

From a classical point of view, this phase change should be a local factor and
is dependent only upon the condition around the boundary point.

######  Conjecture.

The phase factor associated to each reflection can be determined using either
the model of a free particle on a ray with suitable boundary condition
imposed, or a finite potential barrier model (details in the following
passage). The auxiliary phase that occurs as the weight for each classical
path in the sum equals the product over all reflections of that path.

In this article we discussed the auxiliary phase that is associated to the
boundary point, depending on the boundary condition on the equation imposing
on that point being of Dirichlet or Neumann type. We also proved that the
resulting formulae on the propagator matches those arising from the Schödinger
equation, with a trivial normalization factor.

There are several generalizations of this result that should be worth
investigating:

  1. 1.

In this article, we interpret the infinite potential well problem as the
Schödinger equation on a line segment with Dirichlet boundary condition and
verified that the auxiliary phase is $-1=e^{i\pi}$. It can be shown that for a
potential barrier of finite height $h$, the phase factor associated to the
reflection should be $e^{-i\theta}$, where

$\theta=\cot^{-1}\left(\frac{k^{2}-q^{2}}{2kq}\right)$

with $k,q$ determined by $h$ (refer to appendix for detail).

Assuming the Conjecture, the phase factor computed above can then be applied
to the problem of a finite potential well. In fact, by doing so, one can
obtain its bound states spectra through the sum over classical paths weighted
by the corresponding auxiliary phase (which are computed by
$\epsilon_{r}=e^{-ir\theta}$).

  2. 2.

To study whether the Ansatz holds in computing the auxiliary phase on a higher
dimensional model when reflecting along the boundary. It would be particularly
interesting to know if the geometry (shape) of the boundary plays a part.

  3. 3.

Deriving a formula for the phase factor in this model under other boundary
conditions such as the Robin boundary condition.

## Appendix: auxiliary phase for a finite potential well

Consider the Schrödinger equation with a (finite) constant step barrier:

$H=-\frac{\hbar^{2}}{2m}\frac{d^{2}}{dx^{2}}+V(x)$

where $V(x)=\begin{cases}0&x\leq 0\\\ h&\text{otherwise}\end{cases}$.

It is a standard calculation for scattering problem that can be found in, say
[12, 13]. Defining the wave function
$\psi(x)=\begin{cases}\psi_{0}(x)&\text{for }x<0\\\ \psi_{1}(x)&\text{for
}x\geq 0\end{cases}$. We consider an incoming wave with energy $E<h$. It turns
out that

$\psi_{0}(x)=e^{ikx}+Re^{-ikx}\qquad\text{and}\qquad\ \psi_{1}(x)=Te^{-qx}.$

with $R=\frac{k-iq}{k+iq}$, where $k=\sqrt{\frac{2m}{\hbar^{2}}E}$ and
$q=\sqrt{\frac{2m}{\hbar^{2}}(h-E)}$. The physical interpretation here is that
$R=e^{-i\theta}$ is the phase change in the reflected wave (moving toward the
negative direction). It is where we easily see that the phase factor
$e^{-i\theta}\rightarrow-1$ as $h\rightarrow\infty$.

Furthermore, writing $e^{-i\theta}=\cos(\theta)-i\sin(\theta)$ gives the
formula $\theta=\cot^{-1}\left(\frac{k^{2}-q^{2}}{2kq}\right)$.

## References

  * Goodman [1981] M. Goodman, Path integral solution to the infinite square well, American Journal of Physics 49, 843 (1981).
  * Feynman and Hibbs [1965] R. P. Feynman and A. R. Hibbs,  _Quantum mechanics and path integrals_ , International series in pure and applied physics (McGraw-Hill, New York, NY, 1965).
  * MacKenzie [2000] R. MacKenzie, Path integral methods and applications, arXiv: Quantum Physics (2000).
  * Schulman [1981] L. S. Schulman,  _Techniques and Applications of Path Integration_ (John Wiley and sons, New York, NY, 1981).
  * Kleinert [2004] H. Kleinert,  _Path integrals in quantum mechanics, statistics, polymer physics, and financial markets; 3rd ed._ (World Scientific, River Edge, NJ, 2004) based on a Course on Path Integrals, Freie Univ. Berlin, 1989/1990.
  * Zinn-Justin [2011] J. Zinn-Justin,  _Path integrals in Quantum Mechanics_ (Oxford Univ. Press, 2011).
  * Janke and Kleinert [1979] W. Janke and H. Kleinert, Summing paths for a particle in a box, Lettere Nuovo Cimento 25 (1979).
  * Sökmen [1984] I. Sökmen, Exact path integral solution to the infinite square well, Physics Letters A 106, 212 – 214 (1984).
  * Dowker [1972] J. S. Dowker, Quantum mechanics and field theory on multiply connected and on homogeneous spaces, Journal of Physics A: General Physics 5, 936 (1972).
  * Mouchet [2021] A. Mouchet, Path Integrals in a Multiply-Connected Configuration Space (50 Years After), Foundations of Physics 51, 107 (2021), arXiv:2010.01504 [quant-ph] .
  * Suzuki [2011] F. Suzuki, Homotopy and Path Integrals, arXiv e-prints , arXiv:1107.1459 (2011), arXiv:1107.1459 [quant-ph] .
  * Gasiorowicz [1974] S. G. Gasiorowicz,  _Quantum physics_ (Wiley, New York, NY, 1974).
  * Griffiths and Schroeter [2018] D. J. Griffiths and D. F. Schroeter,  _Introduction to quantum mechanics; 3rd ed._ (Cambridge University Press, Cambridge, 2018).