# Breaks and Code Quality: Investigating the Impact of Forgetting on Software
Development
Registered Report

Dario Amoroso d’Aragona1, Luca Pascarella2, Andrea Janes3, Valentina
Lenarduzzi4, Rafael Peñaloza5, Davide Taibi1,4
1Tampere University — 2ETH Zurich — 3FHV Vorarlberg University of Applied
Sciences
4University of Oulu — 5University of Milano-Bicocca
<EMAIL_ADDRESS><EMAIL_ADDRESS><EMAIL_ADDRESS>
<EMAIL_ADDRESS><EMAIL_ADDRESS><EMAIL_ADDRESS>
###### Abstract

Developers interrupting their participation in a project might slowly forget
critical information about the code, such as its intended purpose, structure,
the impact of external dependencies, and the approach used for implementation.
Forgetting the implementation details can have detrimental effects on software
maintenance, comprehension, knowledge sharing, and developer productivity,
resulting in bugs, and other issues that can negatively influence the software
development process. Therefore, it is crucial to ensure that developers have a
clear understanding of the codebase and can work efficiently and effectively
even after long interruptions.  This registered report proposes an empirical
study aimed at investigating the impact of the developer’s activity breaks
duration and different code quality properties. In particular, we aim at
understanding if the amount of activity in a project impact the code quality,
and if developers with different activity profiles show different impacts on
code quality.  The results might be useful to understand if it is beneficial
to promote the practice of developing multiple projects in parallel, or if it
is more beneficial to reduce the number of projects each developer
contributes.

###### Index Terms:

Forgetting curve, Code Quality, Empirical Software Engineering

##  I Introduction

When developers are not working for a long time on the same project, they
might forget some details about the source code, including the purpose of some
lines of code, the code structure, the effect of external dependencies, or the
followed implementation strategy. The result, can can hinder software
maintenance, comprehension, and developer productivity [1], with possible
consequences on bugs, and other issues in software development [2, 3].

The Ebbinghaus curve is a well-known model for describing a) forgetting as a
function of time and b) retaining as a function of repeated learning [4, 5].
Applied to software development (see Figure 1), we hypothesize that when time
elapses and a developer does not repeatedly work on a project, he or she might
forget some details and might be more prone to introducing mistakes. This was
also observed by [6], where they reported that “several subjects each noted
that he or she has to work with code [continuously] otherwise I forget after a
while [1 month]”.

Figure 1: Illustration of the forgetting curve [4], extended with examples
that exemplify its application to software development.

Many studies analyze the activity of learning. However, the countermeasure to
forgetting is not learning but remembering. Learning and remembering require
different strategies, as re-learning from scratch (to remember) may be
considered an inefficient effort and perceived as boring.

To investigate the phenomenon of code forgetting in more detail and to be able
to develop countermeasures, in this registered report, we want to study
whether we can observe a relationship between interruptions during
participation in a project (assuming that these interruptions cause
forgetting) and a degradation of source code quality. Concretely, we
operationalize participation as the “observable, performed activities on the
source code repository” (e.g., commits, pull requests, etc.), interruptions as
“the time that occurred between one activity and the next, performed by the
same developer in the same project”, and degradation of source code quality as
“a worsening change in source code metrics”.

Paper Structure: Section II describes the empirical study design and Sect. III
presents the data collection and analysis protocols. Section IV outlines the
execution plan and Sect. V identifies the threats to validity. Section VI
identifies the threats to validity, and Sect. VII concludes the paper.

##  II Empirical Study Design

In this section, we describe our empirical study reporting the goal and
research questions, the context, data collection, and data analysis. We
designed our study based on the guidelines defined by Wohlin et al. [7]. In
Figure 2, we describe the entire process we will adopt to answer our RQs.

We split our investigation into two different approaches, hereinafter called
“Iterations”. In Iteration 1, we aim at understanding whether, for a developer
in general, the time that elapses between his/her activities correlates
negatively with the code quality of the new contribution (considered at
project and also at module level) when the developer gets back to the code
(since it ignores the personal characteristics of the individual developer, we
call this the Naïve model).

In Iteration 2, we will study if the relationship between interruptions and
source code quality degradation can be better explained if the degree of
contribution of a developer is also taken into consideration (Advanced model).
We assume that primary contributors (authored more than 50% of the code [8])
forget at a slower pace than secondary contributors.

Figure 2: Empirical Study Design Process

###  II-A Goal, Research Questions, Metrics, and Hypothesis

We formalized the goal of this study according to the GQM approach [9] as
Investigate interruptions of development activities for the purpose of
evaluation with respect to the impact of their length on source code quality
from the point of view of developers in the context of open-source software.

To measure source code quality, we will consider readability and quality
metrics, see Sect. III-A.

Based on the aforementioned goal, we defined two Research Questions (RQ).

RQ1. _How strong is the developer activity break duration correlated with a
degradation of code quality metrics?_

As “activity break” we will consider the time that occurred between the
previous activity in the project and the next activity performed by the same
developer in the same package. We consider all activities, which we are able
to measure and where we assume that knowledge of the code is required:

  * •

Commits

  * •

Opening/closing/reviewing/commenting pull requests

  * •

Opening/closing/commenting issues

We will collect different metrics.

Readability Metrics. We will measure the readability by using the eight
readability metrics defined by Scalabrino et al. [10], which are based on
textual properties of the source code, described in Table III. Several studies
highlighted that textual features are significant descriptors in the
evaluation of code comprehension and, therefore, are meaningful indicators of
the overall readability level of source code [11, 12, 13]. Moreover,
Scalabrino et al. [10] demonstrated that their newly-defined metrics are
indeed a proxy of the actual readability perceived by developers. In other
words, the considered metrics are suitable to quantitatively assess the
readability of source code and are qualitatively perceived as relevant by
practitioners.

Anti-Patterns and Code Smells. We will consider the Code Smells defined by
Fowler [14] and the anti-patterns defined by Brown [15] (Table I).

Software Metrics and Technical Debt detected by SonarQube. We will include
software metrics computed by SonarQube as well as the information related to
the Technical Debt. SonarQube includes the three categories of issues (Code
Smells, Bugs, and Security Vulnerabilities) and the three Technical Debt types
(Squale Index, Reliability Remediation Effort, and Security Remediation
Effort). We must notice that the Code Smells detected by SonarQube are not the
ones defined by Fowler [14] (Table II).

We hypothesize that the antipatterns, code smells, and SonarQube metrics
(Table I and Table II) are directly related to activity break duration (H1.1).
Instead, the readability metrics (Table III) are (mostly) inversely related to
activity break duration (H1.2). In Table I, Table II, and Table III, we report
if we expect an increase or a decrease of the relative metric in the rightmost
column.

RQ2. _How strong is the developer activity break duration correlated with the
degradation of code quality metrics for classes of developers created
according to their participation to a given project?_

In this RQ we aim at understanding if developers with similar activity
profiles (e.g. the super active, active, average, inactive, and super
inactive) have a different impact on code quality.

As for metrics, we will consider the same ones adopted for RQ1 but applied to
clusters of developers with similar activity profiles. To cluster the
developers according to their behavior in the project we will follow the same
approach used by Calefato et al. [16], thus we will calculate for each
developer the Truck Factor [8].

Compared with RQ1, when clustering developers based on their median activity
break duration, we hypothesize stronger correlations between the antipatterns,
code smells, and SonarQube metrics (Table I and Table II) and activity break
duration (H2.1). The same behavior is expected for the readability metrics
(Table III) with a stronger inversely proportional correlation with the
activity break duration (H2.2).

###  II-B Context

We will use projects included in available datasets (e.g., Technical Debt
Dataset [17] version 2.0, Pandora [18]) that fulfill our criteria: developed
in Java, older than three years, more than 500 commits and 100 classes, and
usage of an issue tracking system with at least 100 issues reported. In
addition to capturing and depicting reality, we are interested in projects
that are using SonarCloud in their development process to avoid launching
SonarCloud afterward which can lead to inaccurate results because in that
case, we would be analyzing problems that the developers would not be aware
of. Finally, we are interested in projects that can be considered mature. In
case the available datasets do not contain the information required we will
consider the possibility to extend them or creating a new one.

###  II-C Verifiability and Replicability

To allow verifiability and replicability, we will make all the raw data
available in our online appendix, including the different scripts we will use
in the paper.

##  III Data Collection and Data Analysis

###  III-A Data collection

To answer our RQs, we will find the projects that full fill our criteria and
we will collect different software metrics. In particular, for this analysis,
we aim to extract the proxy metrics described in Section II-A to estimate, for
example, the correlation between the code complexity and the developer’s
cognitive perception of the code complexity as previously done by Arisholm _et
al._ [19] for the Line-of-Code (LOC) proxy metric or as in the case of
Nagappan and Ball [20] regarding code churn. It is worth noticing that some of
them could be already included in the selected dataset, while others must be
evaluated project-wise.

###  III-B Calculate project behavior towards code quality

For each project and for each commit, we will compute the _delta_ ($\Delta$)
of the aforementioned metrics between that commit and the commit immediately
before, to establish whether there was an increase ($\Delta>0$), a decrease
($\Delta<0$), or no variation in the metric values ($\Delta=0$) caused by the
actions carried out by the developer. The interpretation of the results
depends on the specific metrics.

###  III-C Extract activity breaks

For each developer, we will extract the activity break time (in days) as
defined in Section II-A. Days will be grouped along the _last_ commit of the
day. This is justified by the assumption that a user committing several times
in a day has not forgotten the code between those commits. Thus, activity
breaks will always be positive natural numbers.

###  III-D Iteration One

#### Correlate activity breaks with metric values

For each developer, we will select the related commits and, for each metric,
we will consider the $\Delta$ computed between that commit and the commit
immediately before (which may or may not have been made by the same
developer). We will correlate the $\Delta$ values with the activity break
time.

In order to account for a non-linear forgetting rate, as justified by the
Ebbinghaus curves presented before, we will compute _piecewise correlations_ ,
based on a piecewise linear regression model [21]. In a piecewise regression
model (also known as _segmented regression_) the independent variable is
partitioned into a given number $n$ of intervals, and a regression model is
fit into each of the intervals to clarify its relationship to the dependent
variable. We will use a linear regression using the least squares method to
best fit the data on each of the segments or _bins_. A fundamental step of
piecewise regression is the decision on where to separate the different
segments, known as a _breakpoint_. The ideal breakpoint would maximize the
difference in slopes between the regression models before and after the
breakpoint. There are different strategies for finding such a breakpoint. A
fast and robust approach is to group data points with a “similar” slope
through a clustering method like a decision tree.

We will compute a piecewise regression model to understand the relationship
between the activity break duration (independent variable) and the delta for
each metric (dependent variable). In order to find the best descriptor, we
will test different numbers of bins (from 3 up to a maximum of 10) and
different clustering strategies, and will choose the model that presents the
smallest error w.r.t. the data. In case there are too many data points with
the same activity break (i.e., where the dependent variable is the same), we
will group them in a representative set using centroid-based clustering to
limit the cases to a pre-defined number of data points which is coherent with
the remaining data. The choice of the number of centroids is made to
explicitly regularise outliers in the data.

Yet, we are not interested in the regression models _per se_ , but rather as a
means to understand the impact of forgetting (longer activity breaks) on the
quality of the code. An important piece of information is given by the
activity breakpoints, which tell us the activity break lengths where the
impact on the variable changes behaviors; in other words, they can suggest the
_critical_ break lengths where the consequences of forgetting the code become
more obvious. To provide an adequate measure of the influence of the activity
break on the metric value, the regression models will be used to compare the
differences between the predictions for change in a 1-day break among the
available segments.

Figure 3: Activity break influence measurement

Figure 3 depicts a dataset where the activity break time (independent
variable) is partitioned into four segments, with a linear regression
associated with each segment. On the left, we see the difference in the
predicted $\Delta$ at 1-day break between the model of the first bin (no
forgetting observed) and each of the remaining bins. The breakpoints represent
the moments where the behavior w.r.t. the break time changes.

After constructing the piecewise regression model and computing the
differences in the segment behavior as described above, we will make a
statistical analysis to verify whether the differences are statistically
significant and whether the significance increases as the bin includes longer
activity breaks, as our hypothesis suggests. We will also verify the
differences between developers, following an inter-study analysis.

One can think of several confounding factors that may bias the analysis. For
instance, the factors shown in Table III-D—how much of the existing code was
written by the developer, and how much of their previous work was modified by
someone else—may greatly affect the quality of each commit, but one should not
forget that there is no an established method for identifying a pre-specified
set of important confounders and in practice, confounding is not fully
overcome [22]. To alleviate the effect of these confounders, we will use a
regression detection model and an analysis of covariances (ANCOVA) [23, 24].
Moreover, we verify the false positive by a manual inspection that will be
done by two authors - and including a third one in case of disagreement.

Table I: Anti-Patterns and Code Smells collected in this work Abbrev. |  Metric |  H1.1/H2.1
---|---|---
PCS |  Code Smells (8) detected by Ptidej: Feature envy, Inappropriate intimacy, Large class, Lazy class, Refused bequest, Speculative generality, and Swiss army knife [14] | $\uparrow$
[1pt/1pt] PAP |  Anti-Patterns (9) detected by Ptidej: Blob, Class data should be private, Downcasting, Excessive use of literals, Functional decomposition, God Class, Orphan variable or constant class, Spaghetti code, and Tradition breaker [15] | $\uparrow$
Table II: SonarQube metrics collected in this work

Abbrev. |  Metric | H1.1/H2.1
---|---|---
NOC |  # of lines containing either comment or commented-out code | $\uparrow$
[1pt/1pt] NOCD |  Density of comment linesa | $\uparrow$
[1pt/1pt] COM |  Cyclomatic Complexity per functionb | $\uparrow$
[1pt/1pt] FC |  Complexity average per function | $\uparrow$
[1pt/1pt] COGC |  Cognitive complexityc | $\uparrow$
[1pt/1pt] DL |  # of lines involved in duplications | $\uparrow$
[1pt/1pt] DB |  # of duplicated blocks of lines | $\uparrow$
[1pt/1pt] DF |  # of files involved in duplications | $\uparrow$
[1pt/1pt] DLD |  Density of duplicated linesd | $\uparrow$
[1pt/1pt] NTI |  # of all SonarQube issues | $\uparrow$
[1pt/1pt] BUG |  # of SonarQube BUG issues | $\uparrow$
[1pt/1pt] CS |  # of SonarQube CODE SMELL issues | $\uparrow$
[1pt/1pt] SV |  # of SonarQube SECURITY VULNERABILITIES issues | $\uparrow$
[1pt/1pt] BLOCKER |  # of SonarQube BLOCKER issues | $\uparrow$
[1pt/1pt] CRITICAL |  # of SonarQube CRITICAL issues | $\uparrow$
[1pt/1pt] MAJOR |  # of SonarQube MAJOR issues | $\uparrow$
[1pt/1pt] MINOR |  # of SonarQube MINOR issues | $\uparrow$
[1pt/1pt] INFO |  # of SonarQube INFO issues | $\uparrow$
[1pt/1pt] TD |  Squale indexe | $\uparrow$
[1pt/1pt] RRE |  Reliability remediation effortf | $\uparrow$
[1pt/1pt] SRE |  Security remediation effortg | $\uparrow$

0.4em1a# of comment lines $\div$ (# of lines of code + # of comment lines)
$\times$ 100

0.4em1bcalculated based on the # of paths through the code

0.4em1chow difficult it is to understand the code based on various criteria
like control flow, nesting, or recursion

0.4em1d(# of duplicated lines $\div$ # of lines) $\times$ 100

0.4em1eaccumulated technical debt based on issues classified as CODE SMELL

0.4em1faccumulated technical debt based on issues classified as BUG

0.4em1gaccumulated technical debt based on issues classified as SECURITY
VULNERABILITY

Table III: Redability Metrics collected in this work

Abbrev. |  Metric |  H1.2/H2.2
---|---|---
CIC |  Comments and identifiers consistency overlap between the terms used in function comments and the ones in the function bodies | $\downarrow$
[1pt/1pt] CICsyn |  Comments and identifiers consistency, extended considering synonym terms | $\downarrow$
[1pt/1pt] ITID |  Identifier terms in dictionarya | $\downarrow$
[1pt/1pt] NMI |  Narrow meaning identifiersb | $\downarrow$
[1pt/1pt] CR |  Comments readability | $\downarrow$
[1pt/1pt] NM |  # of meaningsc | $\uparrow$
[1pt/1pt] TC |  Textual coherenced | $\downarrow$
[1pt/1pt] NOC |  # of conceptse | $\uparrow$
[1pt/1pt] NOCnorm |  NOC normalized on the # of statements | $\uparrow$

0.4em1a% of identifiers used in the code that are also part of the English
dictionary

0.4em1bsum of the particularity of the identifiers

0.4em1cpolysemy level of the terms appearing in the methods bodies

0.4em1doverlap between the terms used in the pairs of syntactic blocks

0.4em1e# of topics detected among statements

Table IV: Confounding factors

Abbrev. |  Metric |  Rationale
---|---|---
LMOD |  % of lines modified by distinct developers between the previous commit and the actual commit |  Other developers might have modified the code in the meantime. Mistakes, the introduction of code smells, etc. might not be due to forgetting, but to a misinterpretation of the modifications introduced by others.
[1pt/1pt] OEXP |  % of lines authored in the project up to considered commit |  Developers that participated to a large extent to the project (due to their repeated exposure to the code) might forget slower than others.
[1pt/1pt]

###  III-E Iteration Two

We now describe the step(s) regarding Iteration 2.

####  III-E1 Classify developers according to their contribution in the
project

Given the information about the activity breaks by each developer, as
previously done by Calefato et al. [16] we will characterize different
developers according to the Truck Factor [8]. Specifically, we will analyze
the Truck Factor of each developer, and construct classes depending on their
relative behavior _average_ , _inactive_ , and _super inactive_ classes are
formed by each of the five quintiles, respectively. That is, super active
developers are the 20% with the lowest average Truck Factor value, and so on.

####  III-E2 Correlate breaks with metric values for each developer
classification

Following a strategy akin to Iteration One (Section III-D), we will find a
correlation between the break time and the deltas for each metric value.
However, in this case, rather than focusing on the specific break time of the
developer, we take as the main feature their Truck Factor [8]. In this case,
we will analyze the impact of a developer’s commitment in each specific metric
value, depending on their relative activity in the project. To achieve this,
we will compute the correlation between the average activity break time
(independent variable) and the associated delta (dependent variable). The bins
in this case are constructed following the developer classification breaks.
The remaining analysis is made through the same strategy described in the
previous section.

##  IV Execution Plan

We now explain the execution plan we scheduled according to the study design
we defined in the previous sections.

###  IV-A Data Collection

First of all, we will identify the most suitable projects dataset. We are
aware that not all data will be available in the dataset, so we aim to apply
the following methodology to calculate process metrics and code readability of
projects where source code is developed relying on the  versioning system Git
and hosted on a publicly available hub like GitHub. First, for each project,
we clone the online repository that includes code changes performed on all
branches during the software development. Second, we parse the cloned
repository with PyDriller [25], a lightweight Python framework designed to
ease the mining of Git repositories. This framework simplifies the retrieval
of the two versions of each file changed in a commit, i.e., the version before
and after the committed change. By following this approach, we can calculate
the process metrics as described in Table III-D, considering the evolution of
the changes applied on each file per developer. Finally, we will use the tool
developed by Scalabrino et al. [10] to obtain the values of the readability
metrics of these two versions of each file.

###  IV-B Calculate project readability and code quality

For each commit in the dataset, we will perform the following steps:

1) query the dataset and group the commits by package;

2) for each group, query the dataset to get the quality information described
in Table I and Table II;

3) collect the information described in Table III-D and Table III calculated
in the previous step in Section IV-A;

4) calculate the difference for each metric to obtain the $\Delta$ and we will
store the commit identifier and the $\Delta$ in a new database.

###  IV-C Extract activity breaks

We need to extract the elapsed time between each commit made by each
developer. We will perform the following steps:

1) query the dataset to select all the commits performed by the same developer
in the same package;

2) extract all the activities performed by the same developer in the project;

3) create a single list with all the activities and commits and sort them from
oldest to newest;

4) calculate the differences in terms of the number of days between each
commit and activity;

5) add the number of elapsed days to the dataset created in phase three of
Section IV-B.

###  IV-D Iteration 1

In this iteration we first correlate activity breaks with metric values: we
will select a number $n$ of bins, and then for each developer: 1) compute a
piecewise regression model w.r.t. the dependent variable; 2) for each segment
$i$, given by a linear equation $y=a_{i}x+b_{i}$ predict the behaviour
$\overline{y}_{i}(1)$ at value $x=1$; and 3) the _impact of forgetting_ at bin
$i$ is the difference between the predicted value for bin $i$ and for bin $1$:
$\overline{y}_{i}(1)-\overline{y}_{1}(1)$. Subsequently, we will study the
impact of confounding factors. An ANCOVA test will be used to understand the
impact of the confounding factors from Table III-D to the quality of the
results.

###  IV-E Iteration 2

This iteration consists of two steps: first, we classify developers according
to their behavior toward commit frequency. We will compute Truck Factor [8]
for each developer; the average Truck Factor; and calculate the five
quintiles. Each developer will be assigned to one of five bins according to
the quintile they belong to. Then, second, we correlate breaks with metric
values for each developer classification. For the developers in each quintile,
we will compute a (classical) linear regression model of the dependent
variable ($\Delta$) w.r.t. the independent variable (break time). We will
analyze these five models for statistical differences.

##  V Threats to Validity

In this section, we discuss the threats that might affect the validity of our
empirical study, following the structure suggested by Runeson and Höst [26].

Construct Validity. The planned study uses two main constructs: interruptions
during participation in a project and degradation of source code quality.
Simply observing participation as source code commits might overestimate
disruptions and underestimate participation, since developers may also comment
on or review others’ code. We, therefore, include other activities, such as
pull requests. In addition, we are not able to capture other forms of
interactions such as reading code. However, writing code requires a much
higher level of "recall" than reading code, so we consider this aspect
secondary.

To study the degradation of source code quality, we plan to use a set of
validated measures from the Technical Debt Dataset and calculate additional
readability [10] and source code metrics (Table III-D) directly from the
source code repository. Despite our efforts to minimize measurement errors, we
cannot rule out the possibility of false positives or errors in the measures
obtained using these tools. The selected projects did not use SonarQube or any
of the metrics we are calculating during the analysis time frame. As well as
for the vast majority of works on Fowler’s code smells, developers did not use
the rules adopted in the study. Our results reflect exactly what developers
would obtain using SonarQube out of the box in their project, without
customizing the rule-set.

Internal Validity. We are aware that static analysis tools detect a non-
negligible amount of false positives [27]. However, since we aim at
replicating the same conditions that are commonly adopted by practitioners
when using the same tools, we will not modify or remove any possible false
positives, to accurately reflect the results that developers can obtain by
running the same tools. We are aware that we cannot claim a direct cause-
effect relationship between the commit breaks and the selected software
metrics, and that the quality of the code can be influenced by other factors.
We are also aware that pieces of code with different purposes (e.g., classes
controlling the business logic) can be more complex than others, and
consequently harder to remember.

Last, we are aware that some human factors that can play a relevant role,
cannot be measured (e.g., the developer’s age, individual skills, etc.).

External Validity. We will select projects stem from a very large set of
application domains, ranging from external libraries, frameworks, and web
utilities to large computational infrastructures. The application domain was
not an important criterion for the selection of the projects to be analyzed,
but in any case, we tried to balance the selection and pick systems from as
many contexts as possible. Choosing only one or a very small number of
application domains, or projects with similar age or size, could have been an
indication of the non-generality of our study, as only prediction models from
the selected application domain would have been chosen. Since we are
considering only open-source projects, we cannot directly speculate on
industrial projects. Moreover, we only considered Java projects due to the
limitation of the used tools (SonarQube provides a different set of Sonar
issues for each language) and the results of projects developed on different
languages might not be directly comparable.

##  VI Related Work

Klammer and Gueldenberg [28] performed a systematic literature review about
unlearning and forgetting in organizations, distinguish unlearning
(intentional) from forgetting (unintentional), and examine positive and
negative consequences of unlearning and forgetting.

Averell and Heathcote [29] study the form of forgetting curves with an
experiment that measures different variables over 28 days to observe
forgetting and conclude that exponential forgetting curves are the best fit
for their participants.

A study conducted by Kruger et al. [2] surveyed developers of software
projects on file familiarity, suggesting that the forgetting curve of
Ebbinghaus[4, 5] is applicable in software development and that repetitions
have a strong relationship with the familiarity of source code.

Fritz et al. [6] investigated if a programmer’s activity can be used to build
a model of what a programmer knows about a code base and through questions to
19 Java developers about files they worked on regularly or recently, they
identified a significant correlation between regularly working on a file and
familiarity. LaToza and Myers [30] gathered over 300 questions asked by
programmers while developing software and categorize them, indicating that
developers often ask specific questions about a scenario, highlighting the
importance of being familiar with the source code.

Calefato et al. [16] investigated the life-cycle of developers in Open Source
projects to delineate a pattern to identify if a developer is abandoning the
project or is taking a break. For this purpose, Calefato et al. developed a
methodology to identify the break time of developers. In addition, to
calculate the risk of degradation of the project, the authors calculated the
Truck Factor [8] for each developer.

To the best of our knowledge, there are no studies that delve deeper into the
phenomenon of source code forgetting by examining whether a correlation exists
between a change in the quality of source code and a developer activity break.

##  VII Conclusion

In this registered report, we aim to examine the correlation between a
developer’s activity break and various code quality attributes. Our goal is to
understand if 1) breaks between activities impact positively or negatively on
code quality and 2) if developer activity profiles (super active, active,
average, inactive, and super inactive) impact on code quality.

The results of this work will enable researchers and companies to understand
if is beneficial to let developers work on multiple projects in parallel or if
it is better to have them focus mainly on one project continuously.

## References

  * [1] R. Robbes, M. Lungu, and A. Janes, “API fluency,” in _International Conference on Software Engineering: New Ideas and Emerging Results, ICSE (NIER)_ , 2019.
  * [2] J. Krüger, J. Wiemann, W. Fenske, G. Saake, and T. Leich, “Do You Remember This Source Code?” in _International Conference on Software Engineering (ICSE)_ , 2018.
  * [3] E. Doğan and E. Tüzün, “Towards a taxonomy of code review smells,” _Information and Software Technology_ , vol. 142, p. 106737, 2022.
  * [4] H. Ebbinghaus, _Über das Gedächtnis: Untersuchungen zur experimentellen Psychologie_. Duncker & Humblot, 1885.
  * [5] ——, “Memory: A contribution to experimental psychology,” _Annals of neurosciences_ , vol. 20, no. 4, 2013.
  * [6] T. Fritz, G. C. Murphy, and E. Hill, “Does a Programmer’s Activity Indicate Knowledge of Code?” in _European Software Engineering Conference and the ACM SIGSOFT Symposium on The Foundations of Software Engineering_ , 2007.
  * [7] C. Wohlin, P. Runeson, M. Höst, M. Ohlsson, and B. R. ¨and A. Wesslén, _Experimentation in Software Engineering: An Introduction_. Springer Publishing Company, Incorporated, 2000.
  * [8] G. Avelino, L. Passos, A. Hora, and M. Valente, “A novel approach for estimating truck factors,” 05 2016, pp. 1–10.
  * [9] V. R. Basili, G. Caldiera, and H. D. Rombach, “The goal question metric approach,” _Encyclopedia of Software Engineering_ , 1994.
  * [10] S. Scalabrino, M. Linares-Vásquez, R. Oliveto, and D. Poshyvanyk, “A comprehensive model for code readability,” _Journal of Software: Evolution and Process_ , vol. 30, 2018.
  * [11] L. Guerrouj, “Normalizing source code vocabulary to support program comprehension and software quality,” in _International Conference on Software Engineering (ICSE)_ , 2013.
  * [12] N. Peitek, S. Apel, C. Parnin, A. Brechmann, and J. Siegmund, “Program Comprehension and Code Complexity Metrics: An fMRI Study,” in _International Conference on Software Engineering (ICSE)_ , 2021.
  * [13] G. Sellitto, E. Iannone, Z. Codabux, V. Lenarduzzi, A. De Lucia, F. Palomba, and F. Ferrucci, “Toward Understanding the Impact of Refactoring on Program Comprehension,” in _International Conference on Software Analysis, Evolution and Reengineering (SANER)_ , 2022.
  * [14] F. Martin and B. Kent, “Refactoring: Improving the Design of Existing Code,” _Addison-Wesley Longman Publishing Co., Inc._ , 1999.
  * [15] W. J. Brown, R. C. Malveau, H. W. S. McCormick, and T. J. Mowbray, _AntiPatterns: Refactoring Software, Architectures, and Projects in Crisis: Refactoring Software, Architecture and Projects in Crisis_. John Wiley and Sons, 1998.
  * [16] F. Calefato, M. A. Gerosa, G. Iaffaldano, F. Lanubile, and I. Steinmacher, “Will you come back to contribute? investigating the inactivity of oss core developers in github,” _Empirical Software Engineering_ , vol. 27, 05 2022\.
  * [17] V. Lenarduzzi, N. Saarimäki, and D. Taibi, “The Technical Debt Dataset,” in _15th conference on PREdictive Models and data analycs In Software Engineering_ , ser. PROMISE ’19, 2019.
  * [18] H. Nguyen, F. Lomio, F. Pecorelli, and V. Lenarduzzi, “PANDORA: Continuous Mining Software Repository and Dataset Generation,” in _International Conference on Software Analysis, Evolution and Reengineering (SANER)_ , 2022.
  * [19] E. Arisholm, L. C. Briand, and E. B. Johannessen, “A systematic and comprehensive investigation of methods to build and evaluate fault prediction models,” _Journal of Systems and Software_ , vol. 83, no. 1, 2010.
  * [20] N. Nagappan and T. Ball, “Use of relative code churn measures to predict system defect density,” in _Proceedings of the 27th international conference on Software engineering_ , 2005.
  * [21] V. E. McGee and W. T. Carleton, “Piecewise Regression,” _Journal of the American Statistical Association_ , vol. 65, no. 331, 1970.
  * [22] J. Higgins, J. Thomas, J. Chandler, M. Cumpston, T. Li, M. Page, and W. VA, Eds., _Cochrane Handbook for Systematic Reviews of Interventions version 6.3 (updated February 2022)_. Cochrane, 2022, available from www.training.cochrane.org/handbook.
  * [23] R. McNamee, “Regression modelling and other methods to control confounding,” _Occupational and Environmental Medicine_ , vol. 62, no. 7, pp. 500–506, 2005\.
  * [24] D. C. Montgomery, _Design and Analysis of Experiments_ , 10th ed. Wiley, 2019.
  * [25] D. Spadini, M. Aniche, and A. Bacchelli, “PyDriller: Python Framework for Mining Software Repositories,” in _Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering_ , ser. ESEC/FSE 2018, 2018.
  * [26] R. Per and H. Martin, “Guidelines for Conducting and Reporting Case Study Research in Software Engineering,” _Empirical Softw. Engg._ , vol. 14, no. 2, 2009.
  * [27] B. Johnson, Y. Song, E. Murphy-Hill, and R. Bowdidge, “Why don’t software developers use static analysis tools to find bugs?” in _International Conference on Software Engineering_ , ser. ICSE ’13, 2013, p. 672–681.
  * [28] A. Klammer and S. Gueldenberg, “Unlearning and forgetting in organizations: A systematic review of literature,” _Journal of Knowledge Management_ , vol. 23, pp. 860–888, 06 2019.
  * [29] L. Averell and A. Heathcote, “The form of the forgetting curve and the fate of memories,” _Journal of Mathematical Psychology_ , vol. 55, no. 1, 2011, special Issue on Hierarchical Bayesian Models.
  * [30] T. D. LaToza and B. A. Myers, “Hard-to-Answer Questions about Code,” in _Evaluation and Usability of Programming Languages and Tools_ , 2010.


# E-infinity structure in hyperoctahedral homology

Daniel Graves  School of Mathematics, University of Leeds, Woodhouse, Leeds,
LS2 9JT, UK

###### Abstract.

Hyperoctahedral homology for involutive algebras is the homology theory
associated to the hyperoctahedral crossed simplicial group. It is related to
equivariant stable homotopy theory via the homology of equivariant infinite
loop spaces. In this paper we show that there is an E-infinity algebra
structure on the simplicial module that computes hyperoctahedral homology. We
deduce that hyperoctahedral homology admits Dyer-Lashof homology operations.
Furthermore, there is a Pontryagin product which gives hyperoctahedral
homology the structure of an associative, graded-commutative algebra. We also
give an explicit description of hyperoctahedral homology in degree zero.
Combining this description and the Pontryagin product we show that
hyperoctahedral homology fails to preserve Morita equivalence.

###### Key words and phrases:

hyperoctahedral homology, crossed simplicial group, $E_{\infty}$-algebra,
Dyer-Lashof operations, Pontryagin product

###### 1991 Mathematics Subject Classification:

55N35, 13D03, 18N70, 55S12, 55N45

## Introduction

_Hyperoctahedral homology for involutive algebras_ is the homology theory
associated to the hyperoctahedral crossed simplicial group [FL91, Section 3].
It was introduced by Fiedorowicz [Fie, Section 2] and developed by the author
[Gra22]. The hyperoctahedral crossed simplicial group is the largest of the
_fundamental_ crossed simplicial groups, meaning that every other crossed
simplicial group is either a subobject or an extension of a subobject [FL91,
Theorem 3.6]. It is therefore of interest to study the properties of the
associated homology theory. It has applications in equivariant stable homotopy
theory. In particular, the author showed [Gra22, Theorem 8.8] that for a group
of odd order $G$ and a commutative ground ring $k$, there is an isomorphism of
graded $k$-modules $HO_{\star}(k[G])\cong
H_{\star}\left(\Phi\Omega_{C_{2}}Q_{C_{2}}BG\right)$ where $BG$ is the
classifying space of the group, $Q_{C_{2}}$ is the $C_{2}$-equivariant free
infinite loop space functor, $\Omega_{C_{2}}$ is the $C_{2}$-equivariant based
loops functor and $\Phi$ is the $C_{2}$-fixed point functor.

In this paper we show that the simplicial $k$-module used to compute the
hyperoctahedral homology of an involutive algebra has the structure of an
_$E_{\infty}$ -algebra_ in the category of simplicial $k$-modules.

The notion of $E_{\infty}$-algebra first appeared in work of Boardman and Vogt
[BV68] and was developed by May [May72] amongst others. An
$E_{\infty}$-algebra structure on an object means that is has a multiplication
operation that is both associative and commutative up to all higher
homotopies. One important implication of an $E_{\infty}$-algebra structure is
that it yields tools for calculation. We will show that the
$E_{\infty}$-algebra structure on the simplicial $k$-module which calculates
hyperoctahedral homology in this paper gives rise to two such tools: _Dyer-
Lashof homology operations_ and a _Pontryagin product_.

Dyer-Lashof homology operations are an important tool for calculation in
algebraic topology and homological algebra. They were introduced in [DL62] and
used to calculate the homology of infinite loop spaces. Consider the
isomorphism of graded $k$-modules $HO_{\star}(k[G])\cong
H_{\star}\left(\Phi\Omega_{C_{2}}Q_{C_{2}}BG\right)$. When we take
$k[G]=\mathbb{F}_{p}[\mathbb{Z}]$, the right hand side has an action of the
Dyer-Lashof algebra. The result of this paper shows that the left hand side
also has an action of the Dyer-Lashof algebra in this case. The author hopes
that this is the first stage in showing that this isomorphism of graded
$k$-modules is in fact more structured. In particular, it is hoped that it
preserves the Dyer-Lashof actions. This is a non-trivial statement and should
certainly be investigated in the case of symmetric homology first.

The notion of a Pontryagin product has its roots in [Pon39]. In its simplest
formulation it provides a graded product structure on the singular homology of
topological spaces although there are many variants and generalizations. For
example, there is a Pontryagin product on $H$-spaces [Hat02, 3.C]. The
Pontryagin product in this paper gives hyperoctahedral homology the structure
of an associative, graded-commutative algebra. This is a remarkable property
that hyperoctahedral homology shares with symmetric homology: there is a
graded-commutative structure on hyperoctahedral homology, even when the
algebra under consideration is not commutative! In light of this it is natural
to ask whether the homology theory associated to an arbitrary crossed
simplicial group has the structure of a graded ring or a graded-commutative
ring. However, in general the homology theory associated to a crossed
simplicial group is not known to have any structure beyond that of a graded
module.

The method of proof in this paper closely follows [Aul14] in which an
$E_{\infty}$-algebra structure is found for symmetric homology. Ault’s proof
has four main stages:

  * •

construct an analogue of the _Barratt-Eccles operad_ in the category of small
categories;

  * •

construct a left operad module, in the sense of [Fre04, 2.1.6], over this
operad using under-categories of the symmetric category;

  * •

use this left operad module structure to deduce an $E_{\infty}$-algebra
structure on an object closely related to the concept of a _Schur functor_
[MSS02, Definition 1.24];

  * •

deduce that this induces an $E_{\infty}$-algebra structure on the simplicial
$k$-module that computes symmetric homology.

We will see that hyperoctahedral homology shares many of the properties of
symmetric homology. The keys to finding an $E_{\infty}$-algebra structure for
hyperoctahedral homology are as follows. Firstly we define the _tuple
category_ in Section 2. In some sense this can be seen as an “involutive”
version of the material in [Aul14, Section 2.2]. In Section 3 we define a left
operad module over the categorical version of the Barratt-Eccles operad using
under-categories of the hyperoctahedral category. The main work in this
section is identifying the correct functors required to verify the left operad
module structure. These are found in Lemma 3.7 and Definition 3.9. Once these
have been established, the technical details of the proofs of Lemma 3.7, Lemma
3.10 and Theorem 4.4 pass over from the symmetric case _mutatis mutandis_.

The paper is organized as follows. In Section 1 we collate the background
material that we will require for the remainder of the paper. In Subsection
1.1 we define the categories that we will use throughout the paper. In
Subsection 1.2 we recall constructions from _functor homology_ , in particular
the tensor product of functors, $\mathrm{Tor}$ functors over a small category
and simplicial $k$-modules used to compute them. Subsection 1.3 recalls the
definition of _hyperoctahedral homology_ for an involutive algebra, in terms
of functor homology. We recall the _hyperoctahedral category_ and the
_hyperoctahedral bar construction_. Finally, in Subsection 1.4 we recall the
necessary material from the theory of operads. We recall the notion of an
_$E_{\infty}$ -operad in a symmetric monoidal model category_. As examples we
recall analogues of the _Barratt-Eccles operad_ in the category of small
categories and in the category of simplicial $k$-modules. We recall the
definition of a _left operad module_ in the sense of [Fre04, 2.1.6].

In Section 2 we define the _tuple category_. For an involutive monoid $M$, the
tuple category is constructed from tuples of elements in $M$, morphisms in the
hyperoctahedral category and the hyperoctahedral bar construction. We show
that the tuple category is symmetric strict monoidal, giving it the structure
of an $E_{\infty}$-algebra in the category of small categories.

In Section 3 we construct a left operad module over the Barratt-Eccles operad
in the category of small categories, using under-categories in the
hyperoctahedral category. In Section 4 we will use the left operad module
structure to deduce that there is an $E_{\infty}$-algebra structure on the
simplicial $k$-module which computes hyperoctahedral homology. As a corollary
we obtain Dyer-Lashof homology operations and a Pontryagin product for
hyperoctahedral homology.

In Section 5, we give an explicit description of hyperoctahedral homology in
degree zero. We prove that for an involutive $k$-algebra $A$, the degree zero
hyperoctahedral homology is isomorphic to the quotient of $A$ by the ideal
generated by the relation $a_{0}a_{1}a_{2}-a_{2}\overline{a_{1}}a_{0}$. In
particular degree zero hyperoctahedral homology has a ring structure induced
from the one in $A$. We show that this description of degree zero
hyperoctahedral homology together with the Pontryagin product implies that
hyperoctahedral homology does not preserve Morita equivalence.

### Acknowledgements

I am very grateful to Sarah Whitehouse for her helpful comments and
suggestions. I would like to thank the anonymous referee for their suggestions
and for their very interesting comments and questions.

### Conventions

Throughout the paper, $k$ will denote a unital commutative ground ring. All
the algebras considered are unital.

##  1\. Background material

We begin this section by collating definitions and notation for the categories
that we will use throughout the rest of the paper. In Subsection 1.2 we recall
the constructions from functor homology necessary to define hyperoctahedral
homology in Subsection 1.3. We recall the hyperoctahedral category and the
hyperoctahedral bar construction. We recall the simplicial $k$-module used to
compute hyperoctahedral homology, which we will later show bears the structure
of an $E_{\infty}$-algebra. Finally in Subsection 1.4 we recall the required
material on operad theory, specifically the notions of $E_{\infty}$-operad in
a symmetric monoidal model category and the notion of a left operad module.

###  1.1. Categories

We begin by defining the categories that we will require throughout the paper.

######  Definition 1.1.

The following categories will be used throughout the paper.

  * •

Let $\mathbf{Cat}$ be the category of small categories and functors.

  * •

Let $\Delta$ be the category whose objects are the sets
$[n]=\left\\{0,\dotsc,n\right\\}$ for $n\geqslant 0$ with order-preserving
maps as morphisms [Lod98, B.1].

  * •

Let $\mathbf{sSet}$ denote the category of simplicial sets.

  * •

Let $\mathbf{Mod}_{k}$ and $\mathbf{sMod}_{k}$ denote the categories of
$k$-modules and simplicial $k$-modules respectively.

  * •

Let $\mathbf{Top}$ denote the category of compactly-generated Hausdorff
topological spaces and continuous maps.

  * •

For a finite group $G$, let $\mathbb{E}G$ denote the category whose objects
are the elements $g\in G$ with a unique morphism
$g_{2}g_{1}^{-1}\in\mathrm{Hom}_{\mathbb{E}G}\left(g_{1},g_{2}\right)$.

  * •

Let $\mathbf{IMon}$ denote the category of involutive monoids and involution-
preserving morphisms.

  * •

Let $\mathbf{S}$ denote the symmetric groupoid. The objects are the sets
$\underline{n}=\left\\{1,\dotsc,n\right\\}$ for $n\geqslant 0$ and
$\mathrm{Hom}_{\mathbf{S}}\left(\underline{n},\underline{n}\right)=\Sigma_{n}$.

  * •

For a category $\mathbf{C}$ and an object $C\in\mathbf{C}$, we denote the
under-category by $C\downarrow\mathbf{C}$, see [ML98, II.6] for instance.

  * •

Let $\left\\{\mathbf{C}_{i}\right\\}$ be a set of small categories whose
object sets are pairwise disjoint. Let $\coprod_{i}\mathbf{C}_{i}$ denote the
category whose object set is
$\coprod_{i}\mathrm{Ob}\left(\mathbf{C}_{i}\right)$ and whose set of morphisms
is $\coprod_{i}\mathrm{Mor}\left(\mathbf{C}_{i}\right)$.

###  1.2. Functor homology

Throughout the paper we will make use of concepts from _functor homology_. We
recall the necessary constructions from [PR02] and [GZ67].

######  Definition 1.2.

Let $\mathbf{C}$ be a small category. We define the _category of left
$\mathbf{C}$-modules_, denoted $\mathbf{CMod}$, to be the functor category
$\mathrm{Fun}\left(\mathbf{C},\mathbf{Mod}_{k}\right)$. We define the
_category of right $\mathbf{C}$-modules_, denoted $\mathbf{ModC}$, to be the
functor category $\mathrm{Fun}\left(\mathbf{C}^{op},\mathbf{Mod}_{k}\right)$.

It is well-known that the categories $\mathbf{CMod}$ and $\mathbf{ModC}$ are
abelian with enough projectives and injectives, see for example [PR02, Section
1.6].

######  Definition 1.3.

Let $k^{\star}$ denote the right $\mathbf{C}$-module that is constant at the
trivial $k$-module. We will refer to this functor as the _$k$ -constant right
$\mathbf{C}$-module_.

######  Definition 1.4.

Let $G$ be an object of $\mathbf{ModC}$ and $F$ be an object of
$\mathbf{CMod}$. We define the tensor product $G\otimes_{\mathbf{C}}F$ to be
the $k$-module

$\frac{\bigoplus_{C\in\mathrm{Ob}(\mathbf{C})}G(C)\otimes_{k}F(C)}{\left\langle
G(\alpha)(x)\otimes y-x\otimes F(\alpha)(y)\right\rangle}$

where $\left\langle G(\alpha)(x)\otimes y-x\otimes F(\alpha)(y)\right\rangle$
is the $k$-submodule generated by the set

$\left\\{G(\alpha)(x)\otimes y-x\otimes
F(\alpha)(y)\mathrel{\mathop{\ordinarycolon}}\alpha\in\mathrm{Hom}(\mathbf{C}),\,\,x\in
src(G(\alpha)),\,\,y\in src(F(\alpha))\right\\}.$

This quotient module is spanned $k$-linearly by equivalence classes of
elementary tensors in
$\bigoplus_{C\in\mathrm{Ob}(\mathbf{C})}G(C)\otimes_{k}F(C)$ which we will
denote by $\left[x\otimes y\right]$.

######  Definition 1.5.

One constructs the tensor product of $\mathbf{C}$-modules as a bifunctor

$-\otimes_{\mathbf{C}}-\colon\mathbf{ModC}\times\mathbf{CMod}\rightarrow\mathbf{Mod}_{k}$

on objects by $(G,F)\mapsto G\otimes_{\mathbf{C}}F$. Given two natural
transformations $\Theta\in\mathrm{Hom}_{\mathbf{ModC}}\left(G,G_{1}\right)$
and $\Psi\in\mathrm{Hom}_{\mathbf{CMod}}\left(F,F_{1}\right)$, the morphism
$\Theta\otimes_{\mathbf{C}}\Psi$ is determined by $\left[x\otimes
y\right]\mapsto\left[\Theta_{C}(x)\otimes\Psi_{C}(y)\right]$.

It is well-known that the bifunctor $-\otimes_{\mathbf{C}}-$ is right exact
with respect to both variables and preserves direct sums, see for example
[PR02, Section 1.6].

######  Definition 1.6.

We denote the left derived functors of $-\otimes_{\mathbf{C}}-$ by
$\mathrm{Tor}_{\star}^{\mathbf{C}}(-,-)$.

Recall the nerve of a small category $\mathbf{C}$ [Lod98, B.12].
$N_{\star}\mathbf{C}$ is the simplicial set such that $N_{n}\mathbf{C}$ for
$n\geqslant 1$ consists of all strings of composable morphisms of length $n$
in $\mathbf{C}$ and $N_{0}\mathbf{C}$ is the set of objects in $\mathbf{C}$.
The face maps are defined to either compose adjacent morphisms in the string
or truncate the string and the degeneracy maps insert identity morphisms into
the string. We will denote an element of $N_{n}\mathbf{C}$ by
$\left(f_{n},\dotsc,f_{1}\right)$ where
$f_{i}\in\mathrm{Hom}_{\mathbf{C}}\left(C_{i-1},C_{i}\right)$.

We will be particularly interested in the case where $G$ is a functor of the
form $k\left[N_{n}\left(-\downarrow\mathbf{C}\right)\right]$. That is, we take
the $n^{th}$ level of the nerve of an under-category and then take the free
$k$-module on this set. We can view this construction as a resolution of the
$k$-constant right $\mathbf{C}$-module $k^{\star}$ in the category
$\mathbf{ModC}$. We observe that in this case
$k\left[N_{\star}\left(-\downarrow\mathbf{C}\right)\right]\otimes_{\mathbf{C}}F$
has the structure of a simplicial $k$-module, where the face and degeneracy
maps are induced from nerve construction, and the homology of this simplicial
$k$-module is $\mathrm{Tor}_{\star}^{\mathbf{C}}\left(k^{\star},F\right)$.

There is an isomorphic construction due to Gabriel and Zisman [GZ67, Appendix
2].

######  Definition 1.7.

Let $F\in\mathbf{CMod}$. We define

$C_{n}(\mathbf{C},F)=\bigoplus_{(f_{n},\dotsc,f_{1})}F(C_{0})$

where the sum runs through all elements $(f_{n},\dotsc,f_{1})$ of
$N_{n}\mathbf{C}$ and
$f_{i}\in\mathrm{Hom}_{\mathbf{C}}\left(C_{i-1},C_{i}\right)$. We write a
generator of $C_{n}(\mathbf{C},F)$ in the form $(f_{n},\dotsc,f_{1},x)$ where
$(f_{n},\dotsc,f_{1})\in N_{n}\mathbf{C}$ indexes the summand and $x\in
F(C_{0})$. The face maps $\partial_{i}\colon C_{n}(\mathbf{C},F)\rightarrow
C_{n-1}(\mathbf{C},F)$ are determined by

$\partial_{i}(f_{n},\dotsc,f_{1},x)=\begin{cases}(f_{n},\dotsc,f_{2},F(f_{1})(x))&i=0,\\\
(f_{n},\dotsc,f_{i+1}\circ f_{i},\dotsc,f_{1},x)&1\leqslant i\leqslant n-1,\\\
(f_{n-1},\dotsc,f_{1},x)&i=n.\end{cases}$

The degeneracy maps insert identity maps into the string. We will denote the
homology of the associated chain complex by
$H_{\star}\left(\mathbf{C},F\right)$.

######  Remark 1.8.

As mentioned above, for a left $\mathbf{C}$-module $F$ there is an isomorphism
of simplicial $k$-modules $C_{\star}\left(\mathbf{C},F\right)\cong
k\left[N_{\star}\left(-\downarrow\mathbf{C}\right)\right]\otimes_{\mathbf{C}}F$.
This is well-known; for example, details of this isomorphism are discussed in
[Aul10, Section 1.3] for specific choices of $\mathbf{C}$ and $F$.

###  1.3. Hyperoctahedral homology

Recall from [FL91, Definition 1.1] that a family of groups
$\left\\{G_{n}\right\\}_{n\geqslant 0}$ is a _crossed simplicial group_ if
there exists a small category $\Delta G$ such that: the objects of $\Delta G$
are the sets $[n]$ for $n\geqslant 0$; $\Delta G$ contains $\Delta$ as a
subcategory; $\mathrm{Aut}_{\Delta G}([n])=G_{n}$; and any morphism in
$\mathrm{Hom}_{\Delta G}\left([n],[m]\right)$ can be written uniquely as a
pair $\left(\varphi,g\right)$ where $g\in G_{n}$ and
$\varphi\in\mathrm{Hom}_{\Delta}\left([n],[m]\right)$.

The final condition ensures that the category $\Delta G$ has a well defined
composition, which is denoted by
$\left(\psi,h\right)\circ\left(\varphi,g\right)=\left(\psi\circ
h_{\star}(\varphi),\varphi^{\star}(h)\circ g\right)$ where the morphisms
$h_{\star}(\varphi)$ and $\varphi^{\star}(h)$ are determined by the crossed
simplicial group $\left\\{G_{n}\right\\}$.

######  Definition 1.9.

For $n\geqslant 0$, the _hyperoctahedral group_ $H_{n+1}$ is defined to be the
semi-direct product $C_{2}^{n+1}\rtimes\Sigma_{n+1}$, where
$C_{2}=\left\langle t\mid t^{2}=1\right\rangle$ and $\Sigma_{n+1}$ acts on
$C_{2}^{n+1}$ by permuting the factors.

It is shown in [FL91, 3.3, 3.4] that the family of hyperoctahedral groups
$\left\\{H_{n+1}\right\\}_{n\geqslant 0}$ and the family of symmetric groups
$\left\\{\Sigma_{n+1}\right\\}_{n\geqslant 0}$ are crossed simplicial groups.

######  Definition 1.10.

Let $\Delta S$ and $\Delta H$ denote the categories associated to the
symmetric and hyperoctahedral crossed simplicial groups respectively. The
composition laws in each category are determined by the relations given in
[Lod98, E.6.1.7] and [Gra22, Definition 1.2] respectively.

######  Remark 1.11.

Let $\Delta S_{+}$ and $\Delta H_{+}$ denote the categories formed from
$\Delta S$ and $\Delta H$ by appending an initial object, which will be
denoted by $[-1]$. Both $\Delta S_{+}$ and $\Delta H_{+}$ are symmetric strict
monoidal categories, as proved in [Aul10, Proposition 9] and [Gra22,
Proposition 6.2] respectively.

######  Remark 1.12.

Fiedorowicz and Loday provide a classification theorem for crossed simplicial
groups [FL91, Theorem 3.6]. This shows that there are seven _fundamental
crossed simplicial groups_. The largest of these is the hyperoctahedral
crossed simplicial group; the remainder being subgroups of hyperoctahedral
groups. Any other crossed simplicial group is an extension of a fundamental
crossed simplicial group. From this perspective it is important to understand
the properties of hyperoctahedral homology. However it also raises interesting
questions. Fiedorowicz and Loday prove that any semi-direct extension of the
symmetric groups is a crossed simplical group [FL91, Theorem 3.10]. The author
plans to investigate the homology theories associated to these crossed
simplicial groups.

######  Definition 1.13.

Let $A$ be an involutive, associative $k$-algebra with the involution denoted
by $a\mapsto\overline{a}$. The _hyperoctahedral bar construction_ is the
functor $\mathsf{H}_{A}\colon\Delta H\rightarrow\mathbf{Mod}_{k}$ given on
objects by $[n]\mapsto A^{\otimes n+1}$ for $n\geqslant 0$. Let
$(\varphi,g)\in\mathrm{Hom}_{\Delta H}\left([n],[m]\right)$. Then
$\varphi\in\mathrm{Hom}_{\Delta}\left([n],[m]\right)$ and
$g=\left(z_{0},\dotsc,z_{n};\sigma\right)\in H_{n+1}$. We define

$\mathsf{H}_{A}\left(\varphi,g\right)(a_{0}\otimes\cdots\otimes
a_{n})=\left(\underset{{}_{i\in(\varphi\circ\sigma)^{-1}(0)}}{{\prod}}a_{i}^{z_{i}}\right)\otimes\cdots\otimes\left(\underset{{}_{i\in(\varphi\circ\sigma)^{-1}(m)}}{{\prod}}a_{i}^{z_{i}}\right)$

on elementary tensors and extend $k$-linearly, where the product is ordered
according to the map $\varphi$ and

$a^{z_{i}}=\begin{cases}a&z_{i}=1\\\ \overline{a}&z_{i}=t.\end{cases}$

Note that an empty product is defined to be the multiplicative unit $1_{A}$.

######  Definition 1.14.

Let $A$ be an involutive, associative algebra. For $n\geqslant 0$, we define
the _$n^{th}$ hyperoctahedral homology of $A$_ to be

$HO_{n}(A)\coloneqq\mathrm{Tor}_{n}^{\Delta
H}\left(k^{\star},\mathsf{H}_{A}\right).$

######  Remark 1.15.

We recall from [Gra22, Definition 6.3] that the hyperoctahedral bar
construction extends to a functor $\mathsf{H}_{A+}\in\mathrm{Fun}\left(\Delta
H_{+},\mathbf{Mod}_{k}\right)$ by defining $\mathsf{H}_{A+}([-1])=k$ and, for
$n\geqslant 0$ and $i_{n}\in\mathrm{Hom}_{\Delta H_{+}}\left([-1],[n]\right)$,
defining $\mathsf{H}_{A+}(i_{n})$ to be the inclusion of $k$-algebras
$k\rightarrow A^{\otimes(n+1)}$. Furthermore, by [Gra22, Theorem 6.4], there
is an isomorphism of graded $k$-modules $HO_{\star}(A)\cong
H_{\star}\left(\Delta H_{+},\mathsf{H}_{A+}\right)$.

######  Definition 1.16.

Let $M$ be a monoid with involution. We define a functor
$\mathsf{H}_{M}\colon\Delta H_{+}\rightarrow\mathbf{IMon}$ on objects by

$\mathsf{H}_{M}\left([n]\right)=\begin{cases}M^{n+1}&n\geqslant 0\\\
\emptyset&n=-1.\end{cases}$

where $M^{n+1}$ denotes the $(n+1)$-fold Cartesian product. $\mathsf{H}_{M}$
is defined on morphisms in $\Delta H$ analogously to $\mathsf{H}_{A}$. We
define $\mathsf{H}_{M}\left(i_{n}\right)$ to be the unique map
$\emptyset\rightarrow M^{n+1}$. We call $\mathsf{H}_{M}$ the _hyperoctahedral
bar construction for monoids_.

###  1.4. Operad theory

Recall [Hov99, 4.2.6] that a symmetric monoidal model category is category
that bears both the structure of a symmetric monoidal category [Hov99, 4.1.4]
and of a model category [Hov99, 1.1.3] subject to some compatibility
conditions.

######  Example 1.17.

We will be particularly interested in the following symmetric monoidal model
categories.

  * •

The category $\mathbf{sSet}$ with the level-wise Cartesian product and the
Quillen model structure [Hov99, 4.2.8].

  * •

The category $\mathbf{sMod}_{k}$ with the level-wise tensor product of
$k$-modules and the projective model structure [Qui67, II.4.12].

  * •

The category $\mathbf{Cat}$ with the product of categories and the Thomason
model structure [Tho80].

######  Definition 1.18.

Let $\mathbf{C}$ be a small symmetric monoidal model category with unit
$\mathbbm{1}$. An _$E_{\infty}$ -operad_ in $\mathbf{C}$ is a functor
$\mathcal{O}\in\mathrm{Fun}\left(\mathbf{S}^{op},\mathbf{C}\right)$ such that

  * •

the conditions of an operad [May72, Definition 1.1] are satisfied;

  * •

for each $n\geqslant 0$, $\mathcal{O}(n)$ is weakly equivalent to
$\mathbbm{1}$ in the model structure;

  * •

for each $n\geqslant 0$, the action of $\Sigma_{n}$ on $\mathcal{O}(n)$ is
free.

######  Example 1.19.

Some interesting examples of $E_{\infty}$-operads in $\mathbf{Top}$ are the
_little $\infty$-cubes operad_ [May72, Section 4], the _Barratt-Eccles operad_
[BE74], [BF04, 1.1] and the _hyperoctahedral operad_ [Gra22, Definition 7.9].

######  Remark 1.20.

Observe that if $\mathcal{O}$ is an $E_{\infty}$-operad in a symmetric
monoidal model category $\mathbf{C}$ and
$F\in\mathrm{Fun}\left(\mathbf{C},\mathbf{D}\right)$ is symmetric monoidal
then there is an $E_{\infty}$-operad in $\mathbf{D}$ induced from
$\mathcal{O}$ by $F$. We will be particularly interested in the categories
$\mathbf{Cat}$, $\mathbf{sSet}$ and $\mathbf{sMod}_{k}$ with the nerve functor
$N\in\mathrm{Fun}\left(\mathbf{Cat},\mathbf{sSet}\right)$ and the free
$k$-module functor
$k[-]\in\mathrm{Fun}\left(\mathbf{sSet},\mathbf{sMod}_{k}\right)$.

######  Example 1.21.

Following [Aul14, Example 2.7] we describe an analogue of the Barratt-Eccles
operad in $\mathbf{Cat}$. The nerve functor then recovers a familiar
description of the Barratt-Eccles operad in the category of simplicial sets
and the free $k$-module functor induces an analogue of the Barratt-Eccles
operad in the category $\mathbf{sMod}_{k}$. Following Ault, the operads in
$\mathbf{Cat}$ and $\mathbf{sMod}_{k}$ will be denoted by
$\mathcal{D}_{\mathbf{Cat}}$ and $\mathcal{D}_{\mathbf{Mod}}$ respectively.

For $m\geqslant 0$ let $\mathcal{D}_{\mathbf{Cat}}(m)=\mathbb{E}\Sigma_{m}$.
Let $m,k_{1},\dotsc,k_{m}\geqslant 0$ and let $k=\sum_{i=1}^{m}k_{i}$. The
operad structure maps are the functors

$\mathcal{D}_{\mathbf{Cat}}(m)\times\mathcal{D}_{\mathbf{Cat}}(k_{1})\times\cdots\times\mathcal{D}_{\mathbf{Cat}}(k_{m})\rightarrow\mathcal{D}_{\mathbf{Cat}}(k)$

given on objects by

$\left(\sigma,\tau_{1},\dotsc,\tau_{m}\right)\mapsto\tau_{\sigma^{-1}(1)}\times\cdots\times\tau_{\sigma^{-1}(m)}.$

That is, we form the permutation where $\tau_{i}$ acts on a block of size
$k_{i}$ and we permute the blocks according to the permutation
$\sigma\in\Sigma_{m}$.

The right action of $\Sigma_{m}$ of $\mathbb{E}\Sigma_{m}$ is given by
composition of group elements and is therefore a free action. The category
$\mathbb{E}\Sigma_{m}$ is contractible since the nerve of the category
$\mathbb{E}\Sigma_{m}$ is a simplicial model of the total space of
$\Sigma_{m}$. Therefore $\mathcal{D}_{\mathbf{Cat}}$ is an $E_{\infty}$-operad
in $\mathbf{Cat}$.

######  Definition 1.22.

Let $\mathbf{C}$ be a symmetric monoidal model category and let $\mathcal{O}$
be an $E_{\infty}$-operad in $\mathbf{C}$. An $\mathcal{O}$-algebra [MSS02,
Definition II.1.20] is called an _$E_{\infty}$ -algebra in $\mathbf{C}$_.

######  Example 1.23.

As shown in [Aul14, 2.5], a symmetric strict monoidal category has the
structure of a $\mathcal{D}_{\mathbf{Cat}}$-algebra and is therefore an
$E_{\infty}$-algebra in $\mathbf{Cat}$.

######  Definition 1.24.

Let $\left(\mathbf{C},\otimes\right)$ be a symmetric monoidal category. Let
$\mathcal{O}$ be an operad in $\mathbf{C}$. A _left $\mathcal{O}$-module_ is a
functor $\mathcal{M}\in\mathrm{Fun}\left(\mathbf{S}^{op},\mathbf{C}\right)$
together with composition products

$\mathcal{O}(n)\otimes\mathcal{M}(p_{1})\otimes\cdots\otimes\mathcal{M}(p_{n})\rightarrow\mathcal{M}\left(p_{1}+\cdots+p_{n}\right)$

satisfying associativity, left unit and equivariance conditions analogous to
those of an operad.

######  Proposition 1.25.

Let $\left(\mathbf{C},\oplus,\otimes\right)$ be a cocomplete distributive
symmetric monoidal category. Let $\mathcal{O}$ be an operad in $\mathbf{C}$.
Let $\mathcal{M}$ be a left $\mathcal{O}$-module and let $Z$ be an object in
$\mathbf{C}$. Then

$\mathcal{M}\left\langle Z\right\rangle\coloneqq\bigoplus_{m\geqslant
0}\mathcal{M}\left(\underline{m}\right)\otimes_{\Sigma_{m}}Z^{\otimes m}$

admits the structure of an $\mathcal{O}$-algebra.

###### Proof.

This is stated as [Aul14, Proposition 3.7]. It can be proved analogously to
[MSS02, Proposition 1.25] using the left operad module structure maps in place
of the operad structure maps. ∎

##  2\. The tuple category

In this section we define the _tuple category_. Given an involutive monoid $M$
we construct a category whose objects are tuples of elements in $M$ and whose
morphisms are constructed from the hyperoctahedral category $\Delta H_{+}$. We
show that the tuple category is symmetric strict monoidal, making it an
$E_{\infty}$-algebra in $\mathbf{Cat}$. This structure is key in the proof of
Lemma 3.10.

######  Definition 2.1.

For an involutive monoid $M$ we define the _tuple category of $M$_, denoted by
$T(M)$ as follows. The objects of $T(M)$ are finite, possibly empty, tuples of
elements in $M$. The empty tuple is denoted by $()$. For each morphism
$f\in\mathrm{Hom}_{\Delta H_{+}}\left([p-1],[q-1]\right)$ for $p,\,q\geqslant
0$ and $\mathbf{m}\in M^{p}$ there is a morphism
$\left(f,\mathbf{m}\right)\in\mathrm{Hom}_{T(M)}\left(\mathbf{m},\mathsf{H}_{M}(f)(\mathbf{m})\right)$.
Composition is defined via the composition of morphisms in the category
$\Delta H_{+}$ and is well-defined by the functoriality of $\mathsf{H}_{M}$.

######  Definition 2.2.

We define a functor
$T(-)\in\mathrm{Fun}\left(\mathbf{IMon},\mathbf{Cat}\right)$ on objects by the
assignment of Definition 2.1. Let $\mathbf{m}\in M^{p}$ and let
$\left(f,\mathbf{m}\right)\in\mathrm{Hom}_{T(M)}\left(\mathbf{m},\mathsf{H}_{M}(f)(\mathbf{m})\right)$.
For a morphism $\varphi\in\mathrm{Hom}_{\mathbf{IMon}}\left(M,N\right)$,
$T(f)\in\mathrm{Hom}_{\mathbf{Cat}}\left(T(M),T(N)\right)$ is the functor
defined on objects by $T(\varphi)(\mathbf{m})=\varphi(\mathbf{m})$ and on
morphisms by $T(\varphi)(f,\mathbf{m})=(f,\varphi(\mathbf{m}))$, where
$\varphi$ is evaluated on the tuple $\mathbf{m}$ point-wise.

######  Lemma 2.3.

Let $M$ be an involutive monoid. The tuple category $T(M)$ has the structure
of a $\mathcal{D}_{\mathbf{Cat}}$-algebra. That is, it is an
$E_{\infty}$-algebra in $\mathbf{Cat}$.

###### Proof.

The product of two tuples in $T(M)$ is given by concatenation. The fact this
product is symmetric strict monoidal follows from the fact $\Delta H_{+}$ is
symmetric strict monoidal under the disjoint union. ∎

##  3\. A left operad module

In this section we will define a left operad module over
$\mathcal{D}_{\mathbf{Cat}}$ in terms of under-categories of the
hyperoctahedral groups. We will use the left operad module defined in this
section, in conjunction with Proposition 1.25, to give an $E_{\infty}$-algebra
structure on $C_{\star}\left(\Delta H_{+},\mathsf{H}_{A+}\right)$, the
simplicial $k$-module which computes hyperoctahedral homology.

######  Definition 3.1.

We define a functor
$\mathcal{I}\mathcal{F}(-)\in\mathrm{Fun}\left(\mathbf{S}^{op},\mathbf{Cat}\right)$
as follows. On objects we define
$\mathcal{I}\mathcal{F}\left(\underline{m}\right)=[m-1]\downarrow\Delta
H_{+}$. For $\sigma\in\Sigma_{m}$ and $(\varphi,g)\in[m-1]\downarrow\Delta
H_{+}$ we define
$\mathcal{I}\mathcal{F}(\sigma)(\varphi,g)=(\varphi,g\circ\sigma)$.

######  Remark 3.2.

Henceforth, for the sake of neatness, we will omit the underline on an object
when we apply the functor $\mathcal{I}\mathcal{F}$.

######  Definition 3.3.

Let $m,j_{1},\dotsc,j_{m}\geqslant 0$ and let $j=\sum_{i=1}^{m}j_{i}$. For
$1\leqslant i\leqslant m$ let $f_{i}\in\mathrm{Hom}_{\Delta
H_{+}}\left([j_{i}-1],[p_{i}-1]\right)$ and let $g_{i}\in\mathrm{Hom}_{\Delta
H_{+}}\left([p_{i}-1],[q_{i}-1]\right)$.

We define a family of functors

$\lambda\colon\mathcal{D}_{\mathbf{Cat}}(m)\times\prod_{i=1}^{m}\mathcal{I}\mathcal{F}(j_{i})\rightarrow\mathcal{I}\mathcal{F}(j)$

on objects by

$\lambda\left(\sigma,f_{1},\dotsc,f_{m}\right)=f_{\sigma^{-1}(1)}\times\cdots\times
f_{\sigma^{-1}(m)}.$

That is, $f_{i}$ acts on a block of size $j_{i}$ and we permute the $m$ blocks
according to $\sigma\in\Sigma_{m}$. The functor $\lambda$ is defined on
morphisms by

$\lambda\left(\tau\sigma^{-1},g_{1},\dotsc,g_{m}\right)\left(\sigma,f_{1},\dotsc,f_{m}\right)=g_{\tau^{-1}(1)}f_{\tau^{-1}(1)}\times\cdots\times
g_{\tau^{-1}(m)}f_{\tau^{-1}(m)}.$

That is, we compose $g_{i}$ with $f_{i}$, set this to act on a block of size
$j_{i}$ and then permute the blocks according to the permutation
$\tau\in\Sigma_{m}$. The functoriality of $\lambda$ follows from the
functoriality of the composition of morphisms in the under-category.

We will show in Lemma 3.10 that the structure from Definitions 3.1 and 3.3
define the structure of a left $\mathcal{D}_{\mathbf{Cat}}$-module on
$\mathcal{I}\mathcal{F}(-)$.

######  Definition 3.4.

Let $X=\left\\{x_{1},\overline{x_{1}},x_{2},\overline{x_{2}},\dotsc\right\\}$
be a set of formal indeterminates. Let $F(X)$ denote the free involutive
monoid on $X$.

######  Remark 3.5.

Observe that the set $X$ has a $C_{2}$-action given by
$x_{i}\mapsto\overline{x_{i}}$. Recall that a category $\mathbf{C}$ is called
_discrete_ if the only morphisms in $\mathbf{C}$ are identity morphisms. Note
that for each $m\geqslant 0$ we can consider the Cartesian product $X^{m}$ as
a discrete category. Furthermore, this category has a left action of the
hyperoctahedral group $H_{m}$ given by applying the $C_{2}$-action and
permuting the factors.

######  Remark 3.6.

Observe that for each $m\geqslant 0$ the category $\mathcal{I}\mathcal{F}(m)$
has a right action of the hyperoctahedral group $H_{m}$ defined by
$\left(\varphi,g\right)\bullet h=\left(\varphi,g\circ h\right)$.

######  Lemma 3.7.

There is an isomorphism of categories

$E\colon\coprod_{m\geqslant
0}\left(\mathcal{I}\mathcal{F}(m)\times_{H_{m}}X^{m}\right)\rightarrow
T(F(X))$

induced from the evaluation maps $\mathcal{I}\mathcal{F}(m)\times
X^{m}\rightarrow T(F(X))$ given by

$(f,y_{1},\dotsc,y_{m})\mapsto\mathsf{H}_{M}(f)(y_{1},\dotsc,y_{m}).$

###### Proof.

The proof is analogous to [Aul14, Lemma 3.4]. One shows that the evaluation
maps factor through $\mathcal{I}\mathcal{F}(m)\times_{H_{m}}X^{m}$ using the
functoriality of $\mathsf{H}_{M}$. One then constructs the inverse functor,
which is induced from the maps that completely factor the monomials in a tuple
in $T(F(X))$. ∎

For the remainder of this section, fix $m,j_{1},\dotsc,j_{m}\geqslant 0$ and
let $j=\sum_{i=1}^{m}j_{i}$.

######  Definition 3.8.

Let $\mathbf{y}=\left(y_{1},\dotsc,y_{j}\right)\in X^{j}$. Define
$\mathbf{y}_{1}=\left(y_{1},\dotsc,y_{j_{1}}\right)\in X^{j_{1}}$ and, for
$2\leqslant i\leqslant m$, define
$\mathbf{y}_{i}=\left(y_{j_{1}+\cdots+j_{i-1}+1},\dotsc,y_{j_{1}+\cdots+j_{i}}\right)\in
X^{j_{i}}$.

######  Definition 3.9.

We define the functors we require to verify that $\mathcal{I}\mathcal{F}$ is a
left $\mathcal{D}_{\mathbf{Cat}}$-module.

  * •

For $1\leqslant i\leqslant m$, let
$I_{i}\colon\mathcal{I}\mathcal{F}(j_{i})\rightarrow\mathcal{I}\mathcal{F}(j_{i})\times_{H_{j_{i}}}X^{j_{i}}$
be the inclusion functor $f\mapsto(f,\mathbf{y}_{i})$.

  * •

Let $\mathbf{I}=I_{1}\times\cdots\times I_{m}$.

  * •

Let
$I\colon\mathcal{I}\mathcal{F}(j)\rightarrow\mathcal{I}\mathcal{F}(j)\times_{H_{j}}X^{j}$
be the inclusion functor $f\mapsto(f,\mathbf{y})$.

  * •

For $i\geqslant 0$, let

$J_{i}\colon\mathcal{I}\mathcal{F}(i)\times_{H_{i}}X^{i}\rightarrow\coprod_{i\geqslant
0}\left(\mathcal{I}\mathcal{F}(i)\times_{H_{i}}X^{i}\right)$

be the inclusion of categories.

  * •

Let $\mathbf{J}=J_{j_{1}}\times\cdots\times J_{j_{m}}$.

######  Lemma 3.10.

The functors $\lambda$ of Definition 3.3 define a left
$\mathcal{D}_{\mathbf{Cat}}$-module structure on the functor
$\mathcal{I}\mathcal{F}(-)$ of Definition 3.1.

###### Proof.

Recall from Lemma 2.3 that the tuple category $T(F(X))$ has the structure of a
$\mathcal{D}_{\mathbf{Cat}}$-algebra. Therefore, for $m\geqslant 0$, we have
operad algebra structure maps

$\theta\colon\mathcal{D}_{\mathbf{Cat}}(m)\times T(F(X))^{m}\rightarrow
T(F(X))$

as defined in [Aul14, Section 2.5].

Recall the isomorphism of categories from Lemma 3.7 and the functors of
Definition 3.9.

Analogously to [Aul14, Diagram (16)], there is a commutative diagram

${\mathcal{D}_{\mathbf{Cat}}(m)\times\displaystyle\prod_{i=1}^{m}\mathcal{I}\mathcal{F}(j_{i})}$${\mathcal{I}\mathcal{F}(j)}$${\mathcal{D}_{\mathbf{Cat}}(m)\times\displaystyle\prod_{i=1}^{m}\left(\mathcal{I}\mathcal{F}(j_{i})\times_{H_{j_{i}}}X^{j_{i}}\right)}$${\mathcal{I}\mathcal{F}(j)\times_{H_{j}}X^{j}}$${\mathcal{D}_{\mathbf{Cat}}(m)\times\left[\displaystyle\coprod_{i\geqslant
0}\left(\mathcal{I}\mathcal{F}(i)\times_{H_{i}}X^{i}\right)\right]^{\times
m}}$${\displaystyle\coprod_{i\geqslant
0}\left(\mathcal{I}\mathcal{F}(i)\times_{H_{i}}X^{i}\right)}$${\mathcal{D}_{\mathbf{Cat}}(m)\times
T(F(X))^{m}}$${T(F(X))}$$\scriptstyle{\lambda}$$\scriptstyle{id\times\mathbf{I}}$$\scriptstyle{I}$$\scriptstyle{id\times\mathbf{J}}$$\scriptstyle{J_{j}}$$\scriptstyle{id\times
E^{\times m}}$$\scriptstyle{E}$$\scriptstyle{\theta}$

in $\mathbf{Cat}$.

The associativity condition of the functors $\lambda$ is induced from the
associativity conditions of the operad algebra structure maps $\theta$, since
all the vertical functors are injective. The left unit condition is satisfied
straightforwardly. The equivariance conditions are satisfied similarly to the
diagrams labelled Equivariance A and Equivariance B in [Aul14, Section 3.3]. ∎

######  Definition 3.11.

Let $\widetilde{\mathcal{I}\mathcal{F}}(-)\coloneqq
k\left[N_{\star}\left(-\downarrow\Delta
H_{+}\right)\right]\in\mathrm{Fun}\left(\mathbf{S}^{op},\mathbf{sMod}_{k}\right)$.

######  Corollary 3.12.

There is a left $\mathcal{D}_{\mathbf{Mod}}$-module structure on
$\widetilde{\mathcal{I}\mathcal{F}}(-)$.

###### Proof.

The required structure is induced from the $\mathcal{D}_{\mathbf{Cat}}$-module
structure on $\mathcal{I}\mathcal{F}(-)$ by the composite of the nerve functor
and the free $k$-module functor. ∎

##  4\. E-infinity structure

In this section we apply Proposition 1.25 to obtain an $E_{\infty}$-algebra in
the category of simplicial $k$-modules, constructed from the left
$\mathcal{D}_{\mathbf{Mod}}$-module $\widetilde{\mathcal{I}\mathcal{F}}$ of
Definition 3.11 and the hyperoctahedral bar construction. We prove that the
simplicial $k$-module $C_{\star}\left(\Delta H_{+},\mathsf{H}_{A+}\right)$ is
a quotient of this and that the quotient map induces the structure of an
$E_{\infty}$-algebra structure on $C_{\star}\left(\Delta
H_{+},\mathsf{H}_{A+}\right)$. As a corollary we observe that hyperoctahedral
homology of an involutive algebra admits Dyer-Lashof operations and a
Pontryagin product.

######  Lemma 4.1.

Let $A$ be an involutive $k$-algebra. The simplicial $k$-module
$\widetilde{\mathcal{I}\mathcal{F}}(-)\otimes_{\mathrm{Aut}\Delta
S_{+}}\mathsf{H}_{A+}$ admits the structure of an $E_{\infty}$-algebra in
$\mathbf{sMod}_{k}$.

###### Proof.

One identifies

$\widetilde{\mathcal{I}\mathcal{F}}(-)\otimes_{\mathrm{Aut}\Delta
S_{+}}\mathsf{H}_{A+}=\bigoplus_{n\geqslant
0}\widetilde{\mathcal{I}\mathcal{F}}(n)\otimes_{\Sigma_{n}}A^{\otimes
n}=\widetilde{\mathcal{I}\mathcal{F}}\left\langle A\right\rangle.$

The result now follows from Proposition 1.25 where we set
$\mathbf{C}=\mathbf{sMod}_{k}$, $\mathcal{O}=\mathcal{D}_{\mathbf{Mod}}$,
$\mathcal{M}=\widetilde{\mathcal{I}\mathcal{F}}(-)$ and $Z=A$. ∎

######  Definition 4.2.

Let $q\colon\widetilde{\mathcal{I}\mathcal{F}}\left\langle
A\right\rangle\rightarrow C_{\star}\left(\Delta H_{+},\mathsf{H}_{A+}\right)$
denote the quotient map of simplicial $k$-modules induced from the inclusion
of categories $\mathrm{Aut}\Delta S_{+}\hookrightarrow\Delta
S_{+}\hookrightarrow\Delta H_{+}$.

######  Definition 4.3.

We denote by

$\nu\colon\mathcal{D}_{\mathbf{Mod}}(m)\otimes_{\Sigma_{m}}\widetilde{\mathcal{I}\mathcal{F}}\left\langle
A\right\rangle^{\otimes
m}\rightarrow\widetilde{\mathcal{I}\mathcal{F}}\left\langle A\right\rangle$

the operad algebra structure maps implied by Lemma 4.1.

######  Theorem 4.4.

Let $A$ be an involutive $k$-algebra. The simplicial $k$-module
$C_{\star}\left(\Delta H_{+},\mathsf{H}_{A+}\right)$, which computes the
hyperoctahedral homology $HO_{\star}(A)$, bears the structure of an
$E_{\infty}$-algebra in the category $\mathbf{sMod}_{k}$.

###### Proof.

Analogously to [Aul14, Lemma 3.10], one can show that the $E_{\infty}$-algebra
structure maps $\nu$ of Definition 4.3 and the quotient map $q$ of Definition
4.2 are compatible in the sense that the diagram

${\mathcal{D}_{\mathbf{Mod}}(m)\otimes_{\Sigma_{m}}\widetilde{\mathcal{I}\mathcal{F}}\left\langle
A\right\rangle^{\otimes m}}$${\widetilde{\mathcal{I}\mathcal{F}}\left\langle
A\right\rangle}$${\mathcal{D}_{\mathbf{Mod}}\otimes_{\Sigma_{m}}C_{\star}\left(\Delta
H_{+},\mathsf{H}_{A+}\right)^{\otimes m}}$${C_{\star}\left(\Delta
H_{+},\mathsf{H}_{A+}\right)}$$\scriptstyle{\nu}$$\scriptstyle{id\otimes
q^{\otimes m}}$$\scriptstyle{q}$$\scriptstyle{\nu}$

commutes. That is, the structure map $\nu$ remains well defined upon passing
to the quotient and we deduce that $C_{\star}\left(\Delta
H_{+},\mathsf{H}_{A+}\right)$ has the structure of a
$\mathcal{D}_{\mathbf{Mod}}$-algebra. ∎

######  Corollary 4.5.

Let $A$ be an involutive $k$-algebra.

  1. (1)

When $k=\mathbb{F}_{p}$ for a prime $p$, the hyperoctahedral homology
$HO_{\star}(A)$ admits Dyer-Lashof homology operations.

  2. (2)

For any commutative ground ring $k$, $HO_{\star}(A)$ admits a Pontryagin
product, giving it the structure of a unital, associative, graded-commutative
algebra.

###### Proof.

The first part of the corollary follows directly from Theorem 4.4 and [CLM76,
Chapter I Theorem 1.1]. The second part of the corollary follows by defining
the product

$C_{\star}\left(\Delta H_{+},\mathsf{H}_{A+}\right)^{\otimes
2}\hookrightarrow\mathcal{D}_{\mathbf{Mod}}(2)\otimes_{\Sigma_{2}}C_{\star}\left(\Delta
H_{+},\mathsf{H}_{A+}\right)^{\otimes 2}\xrightarrow{\nu}C_{\star}\left(\Delta
H_{+},\mathsf{H}_{A+}\right)$

where $\nu$ is the $\mathcal{D}_{\mathbf{Mod}}$-algebra structure map from
Theorem 4.4. The fact that the product is unital follows from the fact that
our analogues of the Barratt-Eccles operad are unital operads. ∎

##  5\. Hyperoctahedral homology in degree zero

In this section we give an explicit description of hyperoctahedral homology in
degree zero. We will show that for a unital involutive $k$ algebra $A$,
$HO_{0}(A)$ is isomorphic to the quotient of $A$ by the ideal
$\left(a_{0}a_{1}a_{2}-a_{2}\overline{a_{1}}a_{0}\right)$. In particular, we
deduce that $HO_{0}(A)$ has a ring structure.

The material in this section is best presented using an isomorphic variant of
the category $\Delta H$, namely the category of involutive non-commutative
sets $\mathcal{I}\mathcal{F}(as)$. The isomorphism of [Gra22, Theorem 1.7]
tells that a morphism in $\mathrm{Hom}_{\Delta H}\left([n],[m]\right)$ can be
uniquely described as a map of sets $f\colon[n]\rightarrow[m]$ such that for
each element $i\in[m]$ the preimage $f^{-1}(i)$ has a total ordering and each
element comes adorned with a superscript label from the group $C_{2}$. We call
such a set a _$C_{2}$ -labelled ordered set_. We also recall that a
$C_{2}$-labelled ordered set $X$ has a $C_{2}$-action, $X^{t}$ that reverses
the total ordering and multiplies each of the labels by $t\in C_{2}$.

We will require two maps in particular.

######  Definition 5.1.

For each $n\geqslant 0$, let
$\mu_{n}\in\mathrm{Hom}_{\mathcal{I}\mathcal{F}(as)}\left([n],[0]\right)$ be
defined by

$\mu_{n}^{-1}(0)=\left\\{0^{1}<1^{1}<\cdots<n^{1}\right\\}.$

######  Definition 5.2.

Let $\nu\in\mathrm{Hom}_{\mathcal{I}\mathcal{F}(as)}\left([2],[0]\right)$ be
defined by $\nu^{-1}(0)=\left\\{2^{1}<1^{t}<0^{1}\right\\}$.

We begin by constructing a partial resolution of the $k$-constant right
$\mathcal{I}\mathcal{F}(as)$-module $k^{\star}$.

######  Lemma 5.3.

For each $n\geqslant 0$ there is an exact sequence of $k$-modules

$0\leftarrow
k\xleftarrow{\varepsilon}k\left[\mathrm{Hom}_{\mathcal{I}\mathcal{F}(as)}\left([n],[0]\right)\right]\xleftarrow{\rho}k\left[\mathrm{Hom}_{\mathcal{I}\mathcal{F}(as)}\left([n],[2]\right)\right]$

where $\varepsilon$ is defined by $\varepsilon(f)=1_{k}$ on generators and
extended $k$-linearly. The map $\rho$ is determined on generators by
$\rho(g)=\mu_{2}\circ g-\nu\circ g$ and extended $k$-linearly.

###### Proof.

The augmentation map $\varepsilon$ is surjective by definition. The composite
$\varepsilon\circ\rho$ is zero since the image of $\rho$ on generators
consists of two morphisms with differing signs. Therefore
$\mathrm{Im}(\rho)\subseteq\mathrm{Ker}(\varepsilon)$. It remains to show that
$\mathrm{Ker}(\varepsilon)\subseteq\mathrm{Im}(\rho)$.

We note that $\mathrm{Ker}(\varepsilon)$ is spanned by all differences
$f-f^{\prime}$ for $f$,
$f^{\prime}\in\mathrm{Hom}_{\mathcal{I}\mathcal{F}(as)}\left([n],[0]\right)$.
In fact, it is spanned by all differences of the form $f-\mu_{n}$ for
$f\in\mathrm{Hom}_{\mathcal{I}\mathcal{F}(as)}\left([n],[0]\right)$. Certainly
all the differences of the form $f-\mu_{n}$ are in the kernel of $\varepsilon$
and we can write any difference $f-f^{\prime}$ as
$\left(f-\mu_{n}\right)-\left(f^{\prime}-\mu_{n}\right)$. Therefore, in order
to show that $\mathrm{Ker}(\varepsilon)$ is contained in $\mathrm{Im}(\rho)$
it suffices to show that $f-\mu_{n}$ is in the image of $\rho$ for each
$f\in\mathrm{Hom}_{\mathcal{I}\mathcal{F}(as)}\left([n],[0]\right)$.

Consider a morphism
$g\in\mathrm{Hom}_{\mathcal{I}\mathcal{F}(as)}\left([n],[2]\right)$. This map
is determined by $g^{-1}(0)=X$, $g^{-1}(1)=Y$ and $g^{-1}(2)=Z$ where $X$, $Y$
and $Z$ are $C_{2}$-labelled, ordered sets. By definition
$\rho(g)=\mu_{2}\circ g-\nu\circ g$ where $\left(\mu_{2}\circ
g\right)^{-1}(0)=X<Y<Z$ and $\left(\nu\circ g\right)^{-1}(0)=Z<Y^{t}<X$.

In order to show that the differences $f-\mu_{n}$ lie in the image of $\rho$
it suffices to show that there is a finite sequence of morphisms
$f_{p},\dotsc,f_{0}$ in
$\mathrm{Hom}_{\mathcal{I}\mathcal{F}(as)}\left([n],[0]\right)$ such that
$f_{p}=f$, $f_{0}=\mu_{n}$ and for each pair $(f_{i},f_{i-1})$ there exists a
$g\in\mathrm{Hom}_{\mathcal{I}\mathcal{F}(as)}\left([n],[2]\right)$ such that
$\mu_{2}\circ g=f_{i}$ and $\nu\circ g=f_{i-1}$.

We construct this sequence of morphisms as follows.

  1. (1)

Let $f\in\mathrm{Hom}_{\mathcal{I}\mathcal{F}(as)}\left([n],[0]\right)$ be
defined by

$f^{-1}(0)=\left\\{i_{0}^{z_{0}}<\cdots<i_{n}^{z_{n}}\right\\}.$

  2. (2)

If $z_{0}=z_{1}=\cdots=z_{n}=1$ skip to Step 6. Otherwise apply Steps 3 to 5
until this is the case.

  3. (3)

If $z_{0}=t$ we choose $g$ with

$X=\emptyset,\quad Y=\left\\{i_{0}^{t}\right\\},\quad
Z=\left\\{i_{1}^{z_{1}}<\cdots<i_{n}^{z_{n}}\right\\}.$

  4. (4)

If $z_{0}=z_{1}=\cdots=z_{j-1}=1$ with $j<n$, we choose $g$ with

$X=\left\\{i_{0}^{1}<\cdots i_{j-1}^{1}\right\\},\quad
Y=\left\\{i_{j}^{t}\right\\},\quad
Z=\left\\{i_{j+1}^{z_{j+1}}<\cdots<i_{n}^{z_{n}}\right\\}.$

  5. (5)

If $z_{0}=z_{1}=\cdots z_{n-1}=1$ we choose $g$ with

$X=\left\\{i_{0}^{1}<\cdots i_{n-1}^{1}\right\\},\quad
Y=\left\\{i_{n}^{t}\right\\},\quad Z=\emptyset.$

  6. (6)

By applying the steps above we have obtained a morphism, say $\beta$, in
$\mathrm{Hom}_{\mathcal{I}\mathcal{F}(as)}\left([n],[0]\right)$ such that
$\beta^{-1}(0)$ is of the form

$\left\\{k_{0}^{1}<k_{1}^{1}<\cdots<k_{n}^{1}\right\\}.$

  7. (7)

If $k_{m}=m$ for $0\leqslant m\leqslant n$ then we have obtained $\mu_{n}$ and
we are done.

  8. (8)

If not, by repeatedly choosing $g$ such that $Y=\emptyset$ and $Z$ is a
singleton we cyclically permute the elements of the total ordering without
changing any of the labels. We do this until $k_{n}=n$.

  9. (9)

If $k_{m}=m$ for $0\leqslant m\leqslant n$ then we have obtained $\mu_{n}$ and
we are done.

  10. (10)

If not, suppose $k_{m}=m$ for $m>j$. Choose $g$ with

$X=\left\\{k_{0}^{1}<\cdots k_{j-1}^{1}\right\\},\quad
Y=\left\\{k_{j}^{1}\right\\},\quad
Z=\left\\{k_{j+1}^{1}<\cdots<k_{n}^{1}\right\\}.$

  11. (11)

By choosing $g$ such that $Y=\emptyset$ and $Z$ is singleton, we can
cyclically permute this total ordering until we obtain

$\left\\{k_{j}^{t}<k_{0}^{1}<\cdots k_{j-1}^{1}<k_{j+1}^{1}<\cdots
k_{n}^{n}\right\\}.$

  12. (12)

Choose $g$ with $X=\emptyset$, $Y=\left\\{j_{k}^{t}\right\\}$ and
$Z=\left\\{k_{0}^{1}<\cdots k_{j-1}^{1}<k_{j+1}^{1}<\cdots
k_{n}^{n}\right\\}$.

  13. (13)

By choosing $g$ with $Y=\emptyset$ and $Z$ a singleton, we cyclically permute
the resulting total ordering to get

$\left\\{k_{j}^{1}<k_{0}^{1}<\cdots<k_{j-1}^{1}<k_{j+1}^{1}<\cdots
k_{n}^{n}\right\\}.$

  14. (14)

The result of Steps 10 to 13 is to fix $k_{m}$ for $m>j$ and to cyclically
permute $k_{0}$ up to $k_{j}$ whilst leaving the labels unchanged. Repeating
this process a finite number of times we will obtain $\mu_{n}$ as required.

This shows that all the differences of the form $f-\mu_{n}$ lie in the image
of $\rho$ and so $\mathrm{Ker}(\varepsilon)\subseteq\mathrm{Im}(\rho)$.
Therefore the sequence is exact. ∎

Let $F\colon\mathcal{I}\mathcal{F}(as)\rightarrow\Delta H$ denote the
isomorphism of [Gra22, Theorem 1.7]. The map $F\left(\mu_{n}\right)$ is the
unique order-preserving map
$\left(\mu_{n},id_{n}\right)\in\mathrm{Hom}_{\Delta H}\left([n],[0]\right)$.
Furthermore, the map $F\left(\nu\right)$ is the map
$\left(\mu_{2},\left(1,t,1;(0\,2)\right)\right)\in\mathrm{Hom}_{\Delta
H}\left([2],[0]\right)$.

######  Corollary 5.4.

For each $n\geqslant 0$ there is an exact sequence of $k$-modules

$0\leftarrow k\xleftarrow{\varepsilon}k\left[\mathrm{Hom}_{\Delta
H}\left([n],[0]\right)\right]\xleftarrow{\rho}k\left[\mathrm{Hom}_{\Delta
H}\left([n],[2]\right)\right]$

where $\varepsilon$ is defined by
$\varepsilon\left(\left(\varphi,g\right)\right)=1_{k}$ on generators and
extended $k$-linearly. The map $\rho$ is determined on generators by
$\rho\left(\left(\psi,h\right)\right)=F\left(\mu_{2}\right)\circ\left(\psi,h\right)-F\left(\nu\right)\circ\left(\psi,h\right)$
and extended $k$-linearly.

###### Proof.

This follows directly from Lemma 5.3 and [Gra22, Theorem 1.7]. ∎

######  Corollary 5.5.

There is an exact sequence of right $\Delta H$-modules

$0\leftarrow k^{\star}\xleftarrow{\varepsilon}k\left[\mathrm{Hom}_{\Delta
H}\left(-,[0]\right)\right]\xleftarrow{\rho}k\left[\mathrm{Hom}_{\Delta
H}\left(-,[2]\right)\right]$

where $\varepsilon$ and $\rho$ are the natural transformations formed from the
$k$-module maps of Corollary 5.4.

###### Proof.

The exactness of a sequence of functors is checked object-wise, so this
follows directly from Corollary 5.4. ∎

######  Corollary 5.6.

Let $A$ be a unital, involutive $k$-algebra. The homology of the partial chain
complex

$0\leftarrow A\xleftarrow{d}A^{\otimes 3}$

where $d(a_{0}\otimes a_{1}\otimes
a_{2})=a_{0}a_{1}a_{2}-a_{2}\overline{a_{1}}a_{0}$ is isomorphic to
$HO_{0}(A)$.

###### Proof.

We apply the functor $-\otimes_{\Delta H}\mathsf{H}_{A}$ to the partial
resolution of $k^{\star}$ in Corollary 5.5 and take homology. ∎

######  Lemma 5.7.

The $k$-submodule
$k\left[\left\\{a_{0}a_{1}a_{2}-a_{2}\overline{a_{1}}a_{0}\right\\}\right]$ of
$A$ is, in fact, an ideal of $A$.

###### Proof.

We observe that given a product of four elements $a_{0}a_{1}a_{2}a_{3}$ we can
use the relation to obtain any product of four elements given by applying the
involution to any subset of the four factors, then permuting the four factors.
This follows from the algorithm of Lemma 5.3 by showing that we can use the
relation to obtain $\mu_{3}$ from any map in
$\mathrm{Hom}_{\mathcal{I}\mathcal{F}(as)}\left([3],[0]\right)$. ∎

######  Theorem 5.8.

Let $A$ be a unital, involutive $k$-algebra. There is an isomorphism

$HO_{0}(A)\cong\frac{A}{(a_{0}a_{1}a_{2}-a_{2}\overline{a_{1}}a_{0})}.$

In particular, $HO_{0}(A)$ has a ring structure induced from the ring
structure of $A$.

###### Proof.

This follows from Corollary 5.6 and Lemma 5.7. ∎

######  Remark 5.9.

We noted in the introduction that hyperoctahedral homology has the remarkable
property that it has a graded-commutative product structure even when the
algebra under consideration is not commutative. We see this in action with
this theorem. By taking $a_{1}$ to be the multiplicative identity $1_{A}$, we
recover the ideal generated by the commutator submodule of $A$. This appears
in degree zero symmetric homology [Aul10, Theorem 86].

######  Corollary 5.10.

Let $A$ be a unital, involutive $k$-algebra.

  1. (1)

If $A$ is a commutative algebra with the trivial involution then
$HO_{0}(A)\cong A$.

  2. (2)

Let $A$ be a commutative algebra with a non-trivial involution. In this case
$HO_{0}(A)$ is isomorphic to the coinvariants of $A$ under the involution.

  3. (3)

Let $A$ be a unital involutive $k$-algebra. If the ideal
$\left(a_{0}a_{1}a_{2}-a_{2}\overline{a_{1}}a_{0}\right)$ is equal to $A$,
then $HO_{\star}(A)$ is trivial in all degrees.

###### Proof.

The first two statements follow directly from Theorem 5.8. The third statement
follows from Theorem 5.8 and Corollary 4.5. In particular, since we have a
unital, associative, graded-commutative product we have have surjective maps
$HO_{0}(A)\otimes HO_{q}(A)\rightarrow HO_{q}(A)$ given by $1\otimes x\mapsto
x$ for all $q\geqslant 0$. However, if the ideal
$\left(a_{0}a_{1}a_{2}-a_{2}\overline{a_{1}}a_{0}\right)$ is equal to $A$,
$HO_{0}(A)$ is trivial and so $HO_{\star}(A)$ is trivial in all degrees. ∎

######  Corollary 5.11.

Hyperoctahedral homology fails to preserve Morita equivalence.

###### Proof.

Let $A$ be a commutative algebra with trivial involution. Consider the
involutive algebra of $(n\times n)$-matrices, $M_{n}(A)$, with $n>1$. By
taking $a_{1}$ to be the identity matrix we see that the ideal
$\left(a_{0}a_{1}a_{2}-a_{2}\overline{a_{1}}a_{0}\right)=M_{n}(A)$. By
Statement (3) of Corollary 5.10, the hyperoctahedral homology of $M_{n}(A)$ is
trivial in all degrees. However, by Statement (1) of Corollary 5.10
$HO_{0}(A)\cong A$. Therefore, hyperoctahedral homology does not preserve
Morita equivalence. ∎

######  Proposition 5.12.

When restricted to $HO_{0}(A)\otimes HO_{0}(A)\rightarrow HO_{0}(A)$, the
Pontryagin product of Corollary 4.5 is the algebra multiplication map in

$\frac{A}{\left(a_{0}a_{1}a_{2}-a_{2}\overline{a_{1}}a_{0}\right)}.$

###### Proof.

Using the degree zero and degree one terms of the chain complex
$C_{\star}\left(\Delta H_{+},\mathsf{H}_{A+}\right)$ one can show that
$HO_{0}(A)$ is generated $k$-linearly by equivalence classes of the form
$id_{[0]}\otimes a$. One then observes that the Pontryagin product structure
of Corollary 4.5 is the algebra multiplication as required. ∎

## References

  * [Aul10] Shaun V. Ault.  Symmetric homology of algebras.  Algebr. Geom. Topol., 10(4):2343–2408, 2010.
  * [Aul14] Shaun V. Ault.  Homology operations in symmetric homology.  Homology Homotopy Appl., 16(2):239–261, 2014.
  * [BE74] M. G. Barratt and Peter J. Eccles.  $\Gamma^{+}$-structures. I. A free group functor for stable homotopy theory.  Topology, 13:25–45, 1974.
  * [BF04] Clemens Berger and Benoit Fresse.  Combinatorial operad actions on cochains.  Math. Proc. Cambridge Philos. Soc., 137(1):135–174, 2004.
  * [BV68] J. M. Boardman and R. M. Vogt.  Homotopy-everything $H$-spaces.  Bull. Amer. Math. Soc., 74:1117–1122, 1968.
  * [CLM76] Frederick R. Cohen, Thomas J. Lada, and J. Peter May.  The homology of iterated loop spaces, volume 533.  Springer, Cham, 1976.
  * [DL62] E. Dyer and R. K. Lashof.  Homology of iterated loop spaces.  Am. J. Math., 84:35–88, 1962.
  * [Fie] Z. Fiedorowicz.  The symmetric bar construction.  URL: https://people.math.osu.edu/fiedorowicz.1/.
  * [FL91] Zbigniew Fiedorowicz and Jean-Louis Loday.  Crossed simplicial groups and their associated homology.  Trans. Amer. Math. Soc., 326(1):57–87, 1991.
  * [Fre04] Benoit Fresse.  Koszul duality of operads and homology of partition posets.  In Homotopy theory: relations with algebraic geometry, group cohomology, and algebraic $K$-theory. Papers from the international conference on algebraic topology, Northwestern University, Evanston, IL, USA, March 24–28, 2002, pages 115–215. Providence, RI: American Mathematical Society (AMS), 2004.
  * [Gra22] Daniel Graves.  Hyperoctahedral homology for involutive algebras.  Homology Homotopy Appl., 24(1):1–26, 2022.
  * [GZ67] P. Gabriel and M. Zisman.  Calculus of fractions and homotopy theory.  Ergebnisse der Mathematik und ihrer Grenzgebiete, Band 35. Springer-Verlag New York, Inc., New York, 1967.
  * [Hat02] Allen Hatcher.  Algebraic topology.  Cambridge: Cambridge University Press, 2002.
  * [Hov99] Mark Hovey.  Model categories, volume 63.  Providence, RI: American Mathematical Society, 1999.
  * [Lod98] Jean-Louis Loday.  Cyclic homology, volume 301 of Grundlehren der Mathematischen Wissenschaften [Fundamental Principles of Mathematical Sciences].  Springer-Verlag, Berlin, second edition, 1998.  Appendix E by María O. Ronco, Chapter 13 by the author in collaboration with Teimuraz Pirashvili.
  * [May72] J. P. May.  The geometry of iterated loop spaces.  Springer-Verlag, Berlin-New York, 1972.  Lectures Notes in Mathematics, Vol. 271.
  * [ML98] Saunders Mac Lane.  Categories for the working mathematician, volume 5 of Graduate Texts in Mathematics.  Springer-Verlag, New York, second edition, 1998.
  * [MSS02] Martin Markl, Steve Shnider, and Jim Stasheff.  Operads in algebra, topology and physics, volume 96.  Providence, RI: American Mathematical Society (AMS), 2002.
  * [Pon39] L. S. Pontryagin.  Homologies in compact Lie groups.  Rec. Math. Moscou, n. Ser., 6:389–422, 1939.
  * [PR02] T. Pirashvili and B. Richter.  Hochschild and cyclic homology via functor homology.  $K$-Theory, 25(1):39–49, 2002.
  * [Qui67] D.G. Quillen.  Homotopical algebra.  Lect. Notes Math., 43. Springer, Cham, 1967.
  * [Tho80] R. W. Thomason.  Cat as a closed model category.  Cah. Topologie Géom. Différ. Catégoriques, 21:305–324, 1980\.