  We study fault-tolerant distributed optimization of a sum of convex (cost)
functions with real-valued scalar input/output in the presence of crash faults
or Byzantine faults. In particular, the goal is to optimize a global cost
function $\frac{1}{n}\sum_{i\in \mathcal{V}} h_i(x)$, where $\mathcal{V}=\{1,
\ldots, n\}$ is the collection of agents, and $h_i(x)$ is agent $i$'s local
cost function, which is initially known only to agent $i$. Since the above
global cost function cannot be optimized exactly in presence of crash faults or
Byzantine faults, we define two weaker versions of the problem for crash faults
and Byzantine faults, respectively.
  When some agents may crash, the goal for the weaker problem is to generate an
output that is an optimum of a function formed as $$C(\sum_{i\in \mathcal{N}}
h_i(x)+\sum_{i\in \mathcal{F}} \alpha_i h_i(x)),$$ where $\mathcal{N}$ is the
set of non-faulty agents, $\mathcal{F}$ is the set of faulty agents (crashed
agents), $0\le \alpha_i\le 1$ for each $i\in \mathcal{F}$ and $C$ is a
normalization constant such that $C(|\mathcal{N}|+\sum_{i\in \mathcal{F}}
\alpha_i)=1$. We present an iterative algorithm in which each agent only needs
to perform local computation, and send one message per iteration.
  When some agents may be Byzantine, the system cannot take full advantage of
the data kept by non-faulty agents. The goal for the associated weaker problem
is to generate an output that is an optimum of a function formed as
$$\sum_{i\in \mathcal{N}}\alpha_i h_i(x),$$ such that $\alpha_i\geq 0$ for each
$i\in \mathcal{N}$ and $\sum_{i\in \mathcal{N}}\alpha_i=1$. We present an
iterative algorithm, where only local computation is needed and only one
message per agent is sent in each iteration, that ensures that at least
$|\mathcal{N}|-f$ agents have weights ($\alpha_i$'s) that are lower bounded by
$\frac{1}{2(|\mathcal{N}|-f)}$.
