Paper summary

Privacy-Preserving Control of Partitioned Energy Resources

Evan Laufer, Philip Levis, Ram Rajagopal · Stanford University

EnergySP '24, ACM SIGEnergy Workshop on Cybersecurity and Privacy of Energy Systems, co-located with ACM e-Energy '24 · Singapore · June 4, 2024

This page was written by an AI model to give a high-level overview of the paper. Please check the paper for detail: ACM Digital Library.

The big idea

Distributed energy resources (DERs) are batteries, solar panels and similar equipment owned and controlled by consumers and third parties rather than by the utility. They are now a large part of the grid: over 500,000 Tesla Powerwalls in the United States can supply 7 GW, more than half of the 13 GW that utility-owned batteries provide. Some DERs are partitioned: a community solar and battery installation sells shares to people in a neighborhood, and each owner controls their own slice. That lets people join and leave, puts the equipment in a good location, and serves people who cannot install a battery at home.

Partitioning has a privacy cost. The operator that runs the shared battery sees every owner's commands, and commands reveal daily life: a home that starts requesting 40 kW at 3 PM is probably charging an electric vehicle. Private aggregation systems such as Prio already let a server add up many users' values without seeing any single one. Energy control adds three problems they do not address. The operator must check limits on both power (a rate) and energy (its integral over time), so no owner exceeds their power limit, overcharges, or drains below zero. The timing of commands leaks information on its own. And the clients are often embedded controllers with MHz of CPU and kB to MB of RAM, not GHz servers.

The paper's system, Weft, combines three ideas. Clients send a schedule of power values for a whole upcoming epoch instead of live commands, so message timing says nothing. Each schedule is split into additive secret shares, one for the operator's server and one for a third-party server that does not collude with it; each share alone looks random. The key observation is that additive shares can be added without being opened, so the servers can compute shares of the running sum of a schedule (the energy) and of the total across all clients (what the battery should actually do), and can carry a share of each client's stored energy from one epoch to the next.

To keep clients honest, each client attaches zero-knowledge range proofs that every power value lies in its allowed range and every running sum stays between empty and full. Because one proof system cannot be cheap in compute, memory and communication at once, Weft offers three: bit-splitting proofs (least memory), sorting proofs (least compute), and commitment proofs, a new extension of Bulletproofs to secret-shared data (least communication). An optional disjunctive schedule compression round shrinks schedules to the time slots where some client changes its value, at the cost of revealing those slots.

Weft runs as a Linux process and as a Tock OS process on an nRF52840 microcontroller (64 MHz Cortex-M4, 256 kB RAM, of which an application gets 96 kB). With bit-splitting proofs the microcontroller proves a 1,440-value schedule in 66 s and a 4,000-value schedule, the largest that fits (one value every 22 seconds for a day), in 4.5 minutes. On a desktop at 10,000 values, the three proofs take 0.36 s, 0.09 s and 73.59 s of client compute, 191 kB, 2.4 MB and 524 MB of client RAM, and send 1.13 MB, 0.66 MB and 41.5 KB to the operator. On a measured trace from one California home's battery and solar system, compression at 10 W resolution halves a 1,440-value schedule; the paper notes this is a lower bound, since a real schedule compresses only to the union of all clients' changes.

Controlling a shared battery without revealing anyone's schedule
secret-shared schedules · two non-colluding servers · only the total is opened
Client Two servers that do not collude Resource Home controller schedule S for the next epoch: one power value per time slot each value split into 2 shares, 8 kW → 61 + 47 (mod 100) plus range proofs for power and energy limits every other client does the same Leader: resource operator checks the proofs on its shares sums share 1 of every client keeps a share of each client's stored energy Follower: third party checks the proofs on its shares sums share 2 of every client keeps a share of each client's stored energy share 1 + proofs share 2 + proofs verify together; partial sum Shared battery runs only the aggregate schedule 1 + 8 + 7 + 5 = 21 kW total only The servers learn: the per-slot total over all clients, and that each client's schedule is valid. Neither server learns: any one client's schedule, or how much energy is left in its partition. Assumption: the operator's server and the third party (e.g. ISRG) do not collude.
From the paper's Sections 3, 4 and Figure 1 (the 1 + 8 + 7 + 5 = 21 kW example is the paper's). The schedule bars and the mod-100 share split are illustrative; real shares are elements of a large finite field or of 64-bit integers.

Key takeaways

  • Owners of a partitioned battery or solar installation reveal their daily routine through their commands; Weft lets the operator run the resource and check every command without seeing any owner's values.
  • Clients send secret-shared schedules for a whole epoch to two non-colluding servers, so neither values nor message timing leak; the servers open only the total.
  • Because additive shares can be summed unopened, the servers get shares of each client's running energy and check both a rate limit and an integral (energy) limit, across epochs.
  • Three range proofs trade resources: bit-splitting minimizes memory, sorting minimizes compute, and commitment proofs (Bulletproofs over secret shares) minimize communication.
  • With bit-splitting, a 64 MHz Cortex-M4 proves a day-long 4,000-value schedule in 4.5 minutes within 96 kB of RAM; optional compression can shrink schedules further by revealing when some client changes its value.
Mechanism, step by step

From secret-shared schedules to verified power and energy limits

The setting, the cryptographic building blocks, how Weft checks rate and integral limits on hidden values, its three range proofs, and what they cost.

1 · Partitioned energy resources and why they leak

A distributed energy resource is controlled by consumers or third parties instead of the energy company. The paper notes that DERs often have poor utilization (home batteries, for example, are typically used only to minimize their owner's energy cost), and that recent systems raise utilization by aggregating and sharing them. In the paper's setting, many clients each own a partition of one resource, such as a share of a community battery, while a single operator runs the physical device. Following prior work on battery virtualization, the operator decides whether the battery charges or discharges by summing all partitions' charge and discharge requests.

Each partition comes with limits the operator must enforce: a minimum rate n (possibly negative, for discharging), a maximum rate m, and a maximum usage e. These limits may differ per client and are known to the servers. The operator therefore needs to check two things about each client's commands, while the clients want the commands kept secret:

  1. Power (rate): no client charges or discharges faster than its partition allows.
  2. Energy (integral): no client overcharges above its partition's capacity or discharges below zero. This depends on the whole history of a client's commands, not on any single one.

2 · The cryptographic building blocks

  1. Additive secret sharing. A value v is split into n shares: n − 1 are random numbers and the last is v minus all of them, with arithmetic modulo some number (for example 64-bit unsigned integers that wrap on overflow). Adding all shares recovers v; any smaller set looks completely random.
  2. Additive homomorphism. Shares can be added and subtracted without being opened: summing the shares of v and of w gives shares of v + w. Everything Weft computes on hidden values is built from this property.
  3. Secure aggregation and Prio. Secure aggregation lets servers compute a sum of many clients' values while learning nothing about individual values (client privacy) and rejecting malformed values (server robustness). Prio does this with at least two servers that do not collude: each client sends one share to each server, each server sums its shares, and only the combined sum is revealed. For robustness, Prio uses a kind of zero-knowledge proof called a SNIP.
  4. Bulletproofs. A zero-knowledge proof system whose range proofs show that a public Pedersen commitment C hides a value w with 0 ≤ w < 2n, without revealing w. Compared to Prio's SNIPs, Bulletproofs need more memory and computation but about 10× less communication, which the paper argues can matter for DERs on low-speed, long-range wireless links.

3 · Threat model and goals

Weft adopts Prio's security model. The resource operator runs one server (the leader), which controls the resource. At least one more server (the follower) is run by a third party assumed not to collude with the operator. The paper argues this is practical because organizations such as the Internet Security Research Group (ISRG) offer the service; in a deployment of secure aggregation for COVID-19 exposure notifications, the servers were run by the NIH and ISRG.

PartyTrusted for integrity?Trusted for privacy?What it should learn
ServersYes: they do not modify client requestsNo: they may try to infer client data from requests, from relating requests, or from timingWhether each request is valid, and the sum of power over all clients
ClientsNo: they may submit malformed requestsNo: they may try to learn about other clientsOnly their own requests and their own partition's state

Clients and servers talk over authenticated, encrypted channels. The goals are client privacy (the operator learns only the sum of all requests), server integrity (invalid requests are detected and rejected), and efficiency: servers are at least desktop-class, and in some configurations clients are embedded devices such as smart meters or energy system controllers.

4 · Schedules instead of commands

Standard REST APIs for energy resources set a single charge or discharge value that replaces the previous one. Weft could secret-share such values and re-aggregate on each update, but that leaks: whenever a client sends a new value, the operator sees how the aggregate changes and can compute how that client's request changed.

Weft instead encodes requests as schedules: arrays of power values, one per time interval. The resource defines the interval and the schedule length. Shortly before each epoch starts, every client sends its schedule for that epoch. Because changes are now decoupled from message timing, the arrival of a message reveals nothing.

Why this matters for energy: the paper counts command timing as one of three challenges that prior private aggregation does not address. A value can be perfectly hidden and still leak through when it was sent; fixed-time schedules close that channel.

5 · Checking rate and integral limits on hidden values

For a schedule S, the servers must be convinced of the rate constraint n ≤ S[i] ≤ m for every slot, and the integral constraint that the running sum of the schedule stays between 0 and e. Both reduce to range checks, which the client proves in zero knowledge (Section 6). The integral needs one more step.

Two range checks on one schedule
rate per slot · running sum carried across epochs · all computed on shares
Schedule S: one power value per slot max rate m 0 min rate n Stored energy: ec plus the running sum of S full e empty 0 start: ec, carried from the last epoch Client proves every S[i] is in [n, m]. Servers add their shares to get shares of every running sum, with no communication. Client proves every running sum is in [0, e]. After the epoch: [ec] += Σ [S[i]]
From Sections 4.2 and 4.3 of the paper. The schedule values and limits are illustrative; the paper does not fix a schedule length or limits. Square brackets denote a server's secret share.
  1. Rate. The client generates one range proof per schedule value, showing it lies in [n, m].
  2. Integral within a schedule. Because the schedule is an array, its integral up to slot t is the partial sum of slots 0 to t. The paper's key insight: since shares are additively homomorphic, each server computes shares of every partial sum by adding up its own shares. The client computes the same partial sums in the clear and proves each one is in range with the same kind of range proof.
  3. Integral across schedules. A battery partition's energy must stay in [0, e] across epochs, and the remaining energy is itself private. Each server keeps a share [ec] of the client's current sum; the constraint becomes 0 ≤ ec + (partial sum) ≤ e.
  4. Carrying state forward. When a schedule ends, each server adds the sum of its schedule shares to its share of ec, locally, with no help from the client or the other server.

6 · Three range proofs, three trade-offs

The range proofs are the most expensive part of both client and server, and the paper finds no single proof that is cheap in compute, memory and communication. Each of Weft's three minimizes one. All prove v ∈ [n, m] by proving that both v − n and m − v fit in b = ⌈log2(m − n)⌉ bits, or by an equivalent test on the sorted values.

ProofHow it worksMinimizesPays for it in
Bit-splitting (on Prio)The client sends shares of each bit of v − n and m − v. The servers check on their shares that the bits sum to the value (a linear check), and a Prio proof shows each bit is 0 or 1 (the predicate x(x − 1) = 0). A batching technique (the G-gate optimization) folds all bit checks into one proof of size O(√|S|).Memory: the degree-2 predicates keep FFTs small, and use grows as O(√|S|)Communication: |S| · b extra field elements, 640 kB for |S| = 10,000, b = 16 and a 32-bit field
Sorting (on Prio)The client sends a sorted list Ŝ of the schedule plus every integer in [n, m]. The servers reveal Ŝ's first and last entries (which must equal n and m), use Prio to check that neighbors differ by 0 or 1, and check that Ŝ is a permutation of the input with a polynomial identity tested at a random point (a permutation argument from Bayer et al.).Compute; it also sends less than bit-splitting when [n, m] is small and |S| is largeMemory: the permutation check runs an FFT over |S| + m − n values held in RAM
Commitment (modified Bulletproofs)Each server forms a Pedersen commitment to its share using randomness chosen by the client; the leader multiplies the commitments, which yields a commitment to the unshared value; the client sends a Bulletproof that this commitment opens to a value in range.Communication: O(log(b · |S|)) proof dataCompute and memory: group exponentiations for proving and verifying

Plain Bulletproofs cannot work on secret shares, and a direct adaptation has two costs that the paper's modifications remove:

  1. Share width. Shares would have to live in the Pedersen group, about 256 bits each; using 256-bit instead of 64-bit shares adds 2.4 MB of communication per 100,000 shares. Shares of any width (for example 64 bits) produce a "carry" when summed, which cannot be reduced modulo 264 inside a commitment's exponent. Weft adds the carry bit to Bulletproofs' internal bit decomposition, with more carry bits for more servers.
  2. Commitments per value. Each server would send the leader one commitment per value, which with 512-bit commitments adds 6.4 MB over 100,000 proofs. Because verifying an aggregate Bulletproof exponentiates and multiplies the commitments, and that operation is associative, the multiplications can be reordered so each server sends a single value.

The paper's appendices give full protocols and proofs: each proof is zero-knowledge when the client and at least one server are honest, and sound when all servers are honest.

7 · Disjunctive schedule compression

Long schedules make range proofs too big for embedded RAM. Coarser time slots would help but take flexibility away from clients. The optional compression keeps fine slots but sends values only for slots where some client changes its value:

  1. Before sending schedules, each client computes, for every slot, a bit saying whether its value is unchanged from the previous slot, and sends boolean secret shares of these bits to the servers.
  2. The servers keep an accumulator per slot, initialized to all ones (this initial state need not be secret), and multiply in each client's bits entry by entry using standard multi-party computation (MPC) techniques.
  3. Once all clients have contributed, the servers reveal the accumulator to each other and to the clients, which now know which slots some client changes.
  4. Clients send values and proofs only for those slots.
What it leaks: the servers and clients learn when some client changes its schedule, though not which client or by how much. The paper presents compression as an optional trade of a small amount of information for smaller schedules; it adds negligible RAM and CPU (shares of change bits on the client, bitwise operations on the servers) plus the extra round of bits and boolean MPC.

8 · Implementation and setup

Weft runs as a Linux process and as a Tock OS process on the nRF52840. It uses modified versions of the libprio and bulletproofs crates (Rust libraries, general knowledge). For Tock, the authors changed libprio to materialize less data in memory so larger schedules fit in a small RAM.

PlatformHardwareMeasured
Embedded clientnRF52840 system-on-chip: 64 MHz 32-bit Cortex-M4, 1 MB flash, 256 kB RAM shared with the kernel and network stack; an application is limited to 96 kB in the authors' environmentClient RAM and compute, bit-splitting proofs
DesktopIntel Core i9 with 8 performance and 8 efficiency cores (up to 5.2 GHz), 30 MB shared L3, 14 MB total L2, DDR4-3200Client and server costs for all three proofs

The main variable is the schedule size in values. Server costs are measured only on the desktop; the paper treats server memory and communication as tiny for server-class machines, and assumes server-to-server traffic is not a bottleneck.

9 · Results

Client cost of a 10,000-value schedule, per proof system
log scales · each proof wins on one resource · desktop measurements
Bit-splitting Sorting Commitment Peak client RAM Client compute Client to leader data lower is better lower is better lower is better 191 kB 2.4 MB 524 MB 0.36 s 0.09 s 73.59 s 1.13 MB 0.66 MB 41.5 KB 100 kB10 MB1 GB 0.01 s1 s100 s 10 kB1 MB100 MB Server verification of the same schedule: 0.085 s (bit-splitting), 0.065 s (sorting), 9.99 s (commitment). The schedule's values alone are 40 KB; the paper calls commitment proofs' 41.5 KB close to optimal.
Values from Sections 7.2 to 7.4 of the paper (its Figures 2, 3 and 5 plot bit-splitting and sorting against schedule size; the commitment numbers are given in the text). Bar lengths are drawn on log scales by this summary.

Memory. At 10,000 values, bit-splitting needs 8% of sorting's RAM and 0.04% of the commitment proofs' 524 MB, which exceeds the memory of most IoT devices. Bit-splitting's 191 kB approaches the nRF52840's entire 256 kB, and an application there gets 96 kB, enough for a 4,000-value schedule (a day at 22-second intervals). A 1,440-value schedule uses 45 kB.

Compute and communication. All three verify quickly on a desktop server. On the client, sorting is fastest and commitment proofs slowest; for communication the order reverses, with bit-splitting sending the most. The microcontroller numbers below are for bit-splitting, the only proof that fits there:

SchedulenRF52840 compute (bit-splitting)Client RAM (bit-splitting)Data sent: bit-splitting / sorting / commitment
1,440 values66 s45 kB183 kB / 159 kB / 7.1 kB
4,000 values (largest that fits in 96 kB)4.5 minuteswithin 96 kBnot reported separately

The paper judges 4.5 minutes acceptable because the schedule covers a day.

Compression. The paper tests disjunctive schedule compression on a trace from one home's battery and solar system in California. The trace records the system's measured output rather than its commands, so it is noisy, and power is rounded down into a fixed number of steps before counting changes (its Table 2):

Number of power stepsStep sizeCompressed scheduleReduction
uncompressedn/a1,4400%
10,0001 W1,15820%
1,00010 W69752%
100100 W (this summary's arithmetic)21585%
101 kW2898%

These are lower bounds on the compressed size: with many clients, a schedule compresses only to the union of all clients' change points.

10 · Limitations the paper states

  1. Trust. Privacy rests on the third-party server not colluding with the operator. Soundness assumes all servers are honest, since a dishonest server could always send invalid shares during aggregation; servers are trusted for integrity throughout.
  2. No proof wins everywhere. Techniques that reduce one resource increase others. Commitment proofs suit more powerful clients (the paper suggests Raspberry Pis) or low-bandwidth links, but their memory rules out typical IoT devices.
  3. Embedded limits. On the nRF52840, the 96 kB per-application RAM caps schedules at 4,000 values.
  4. Compression leaks and is measured narrowly. It reveals when some client changes its value, and its effect is measured on a single home's discretized output trace, which gives a lower bound on compressed size.
  5. Single-server designs. Secure aggregation without a non-colluding third party exists, but the paper notes that extending those schemes to proofs over integrals (energy) is an open problem.
Common questions

FAQ

Q·What exactly does the operator learn?▾

For each time slot, the sum of all clients' scheduled power, which it needs to run the battery, and whether each client's schedule passed the rate and energy checks. It does not learn any one client's values or how much energy remains in a client's partition. If disjunctive schedule compression is enabled, it also learns which slots some client changes its value in, though not which client.

Q·How is this different from Prio?▾

Weft builds on Prio's model and uses it for two of its three proofs. What it adds is specific to energy: checking an integral (energy) constraint on top of a rate constraint, carrying a secret-shared energy state from one epoch to the next, sending fixed-time schedules so message timing does not leak, an implementation that runs on a microcontroller, and commitment proofs that extend Bulletproofs to secret-shared data.

Q·How is it different from prior privacy work on shared energy storage?▾

The closest work (Wang, Chau and Zhou) uses MPC, zero-knowledge proofs and blockchains so users of a shared storage unit can minimize their total cost jointly. In Weft each client owns and individually controls a partition and can optimize its own cost, which is what forces the operator to verify each client's commands. The prior work also targets desktop-class machines. Work on private smart-meter data collection addresses aggregation for billing and statistics in a single-server setting, a different problem.

Q·Why are two servers needed, and what if they collude?▾

Additive sharing hides a value only if no one sees all of its shares. With the operator holding one share and an independent third party the other, neither alone learns anything. If they collude, they can add their shares and recover every client's schedule, so privacy rests on non-collusion. The paper points to organizations such as ISRG that run such servers as a service. Secure aggregation with a single server exists, but extending it to proofs over integrals is, in the paper's words, an open problem.

Q·Why not just send live charge and discharge commands, encrypted?▾

Because the change reveals the value. A standard energy API replaces the previous setpoint with a new one; if a client sends a new secret-shared value whenever it changes its mind, the operator sees the aggregate move at that moment and can work out how that client's request changed. Sending a whole schedule shortly before each epoch decouples changes from message timing.

Q·What stops a client from draining its partition below zero?▾

The integral constraint. Each server holds a share of the client's current stored energy ec. For a new schedule, the servers add shares to get shares of ec plus every partial sum, and the client must prove each of those lies between 0 and its maximum e. A schedule that would ever go below empty or above full fails a proof and is rejected. After the epoch, the servers fold the schedule into ec locally.

Q·Can a malicious server make a bad schedule pass, or a good one fail?▾

The model rules this out by assumption: servers are trusted for integrity (they do not modify requests) and untrusted only for privacy. The soundness proofs assume all servers are honest, because a dishonest server could always send invalid shares during aggregation. The zero-knowledge proofs need only the client and one server to be honest.

Q·Which proof should a deployment use?▾

It depends on the client's scarcest resource. On a small microcontroller, bit-splitting is the only one that fits (191 kB at 10,000 values versus 2.4 MB for sorting and 524 MB for commitment proofs). With a fast client and ample bandwidth, sorting is quickest (0.09 s on the desktop at 10,000 values). On a slow, long-range wireless link with a more capable client, such as a Raspberry Pi in the paper's example, commitment proofs send 41.5 KB instead of about 1 MB.

Q·Does this really run on an embedded controller?▾

Yes, with bit-splitting proofs, on an nRF52840 (64 MHz Cortex-M4) as a Tock OS process limited to 96 kB of RAM. A 1,440-value schedule takes 66 s and uses 45 kB; the largest schedule that fits, 4,000 values (a day at 22-second intervals), takes 4.5 minutes. The authors modified libprio to materialize less data in memory to get there.

Q·How much privacy does schedule compression give up?▾

It reveals the set of slots in which at least one client changes its value. It does not reveal which client changed, or the values. The slot set is computed with MPC over boolean shares, so individual clients' change bits stay hidden. The paper calls this leaking "a small amount of information" and makes the optimization optional.

Q·What does the evaluation not show?▾

Server costs are measured only on a desktop, and server memory, server-to-server traffic and the boolean MPC cost of compression are not measured, which the paper treats as small for server-class systems. The microcontroller results cover bit-splitting only. Compression is measured on one home's output trace, so its numbers are a lower bound on compressed size. The paper reports no end-to-end run controlling a physical shared battery with many clients (inference from the evaluation section).

Q·Do the operator's limits per client have to be secret?▾

No. The minimum rate n, maximum rate m and maximum usage e can differ per client and are assumed known to the servers and the operator. What stays private is the client's schedule and its stored energy.

Background terms
Distributed energy resource (DER)A source or store of electricity, such as a home battery or rooftop solar, that is owned and controlled by consumers or third parties rather than by the energy company.
Partitioned energy resourceOne physical resource, such as a community battery, divided into shares that different clients own and control individually, while one operator runs the device.
Power and energyPower is the rate of energy flow at an instant (kW); energy is power integrated over time (kWh). In Weft a schedule holds power values, and energy is their running sum.
ScheduleAn array of power values, one per fixed time interval, that a client submits for a whole epoch before it starts; the resource sets the interval and length.
Additive secret sharingA way to split a value into several numbers that are individually random but add up (modulo some number) to the value; all shares are needed to recover it.
Additively homomorphicA property of an encoding under which adding encoded values gives an encoding of their sum, so sums can be computed without decoding.
Secure aggregationA protocol in which servers compute an aggregate, such as a sum, of many clients' inputs while learning nothing else about any input, and can reject malformed inputs.
PrioA secure aggregation system in which clients send secret shares to two or more non-colluding servers, which sum shares locally and verify validity with SNIPs.
Non-colluding serversServers run by independent organizations under the assumption that they do not pool their data; at least one honest server keeps the shares private.
Zero-knowledge proofA protocol by which a prover convinces verifiers that a statement about secret data is true, such as "this value is in range", without revealing anything else about the data.
SNIPSecret-shared non-interactive proof: Prio's zero-knowledge proof that a secret-shared value satisfies a validity predicate, checked by the servers on their shares.
Range proofA zero-knowledge proof that a hidden value lies in an interval, here [n, m] for power or [0, e] for energy.
Bit decompositionWriting a number as a sum of powers of two times bits that are each 0 or 1; a value with a valid b-bit decomposition lies in [0, 2b).
Pedersen commitmentA cryptographic value gvhr in a group that binds its creator to v while hiding it; multiplying two commitments gives a commitment to the sum of their values.
BulletproofsA zero-knowledge proof system that proves a Pedersen commitment hides a value in a range, with proofs whose size grows only logarithmically in the number of bits proved.
Multi-party computation (MPC)Techniques that let several parties jointly compute a function of their private inputs, such as a product of secret-shared bits, without revealing the inputs.
Tock OS and nRF52840Tock is an embedded operating system for microcontrollers that isolates applications as processes; the nRF52840 is a Nordic Semiconductor system-on-chip with a 64 MHz Cortex-M4, 1 MB flash and 256 kB RAM.
Summary of E. Laufer, P. Levis and R. Rajagopal, "Privacy-Preserving Control of Partitioned Energy Resources," EnergySP '24, published in the proceedings of ACM e-Energy '24. Numbers are from the paper unless marked as this summary's arithmetic.