Tokyo Electron Quantum Optimization for Semiconductor Etch Process Control

The Problem

Atomic layer etch (ALE) is the semiconductor industry’s answer to the physics limits of plasma etch at sub-5nm nodes. Rather than continuously etching material, ALE alternates between a surface modification step (passivating one atomic monolayer) and a removal step (stripping only the passivated layer). Each cycle removes precisely one to two atomic layers, angstrom-level control. This precision is what enables the gate-all-around transistor structures in 3nm and 2nm nodes.

The tradeoff is complexity. A single ALE process has 12 or more control parameters: radio-frequency power for each step, gas flow rates (multiple precursor gases), chamber pressure, substrate temperature, bias voltage, and step duration. The uniformity of material removal across a 300mm wafer (the etch non-uniformity, or ENU, metric) is a non-linear function of all 12 parameters simultaneously. Process engineers traditionally optimize using Design of Experiments (DoE) methodology: factorial designs or response surface methods that sample parameter combinations systematically. A full factorial DoE for 12 parameters at 3 levels per parameter requires 531,441 runs, entirely impractical. Fractional factorial designs reduce this to 81 to 96 runs, sacrificing higher-order interaction terms.

Tokyo Electron’s ALE tools serve chipmakers whose yield losses from 0.5% excess non-uniformity cost millions of dollars per production quarter. The question: could quantum optimization explore the 12-dimensional process space more efficiently than fractional DoE?

QUBO Formulation for ALE Process Optimization

The ALE optimization was formulated as a quadratic unconstrained binary optimization (QUBO) problem by discretizing each continuous parameter into binary-encoded levels. Each of the 12 parameters was discretized to 8 levels (3 bits per parameter), yielding a 36-bit binary vector representing a complete process recipe.

The objective function combines the measured ENU at a given parameter setting with soft constraints enforcing process window boundaries (parameters outside physical limits are penalized).

import numpy as np
from qiskit_optimization import QuadraticProgram
from qiskit_optimization.converters import QuadraticProgramToQubo
from dwave.system import DWaveSampler, EmbeddingComposite
import dimod

# Parameter discretization: 12 params, 3 bits each = 36 binary variables
N_PARAMS = 12
BITS_PER_PARAM = 3
N_VARS = N_PARAMS * BITS_PER_PARAM  # 36 qubits

# Decode binary vector to physical parameter values
param_ranges = {
    "rf_power_mod": (50, 300),    # Watts
    "rf_power_rem": (100, 500),
    "pressure": (5, 50),           # mTorr
    "gas_flow_cl2": (10, 100),     # sccm
    "gas_flow_ar": (50, 300),
    "bias_voltage": (-200, -20),   # V
    "step_time_mod": (2, 20),      # seconds
    "step_time_rem": (1, 10),
    "temperature": (20, 80),       # Celsius
    "dc_bias": (10, 100),
    "etch_cycles": (10, 50),
    "arf_freq": (2, 60),           # MHz
}

def decode_params(binary_vec, param_ranges):
    """Convert 36-bit binary vector to physical parameter dict."""
    params = {}
    param_names = list(param_ranges.keys())
    for i, name in enumerate(param_names):
        bits = binary_vec[i * BITS_PER_PARAM:(i + 1) * BITS_PER_PARAM]
        level = int("".join(str(b) for b in bits), 2)  # 0-7
        lo, hi = param_ranges[name]
        params[name] = lo + (hi - lo) * level / 7
    return params

# Build QUBO from surrogate model of ENU
def build_enu_qubo(surrogate_model, param_ranges, penalty_lambda=10.0):
    """
    Construct QUBO where Q[i,j] encodes the ENU objective
    and process window constraints.
    surrogate_model: fitted response surface (e.g. polynomial or GP)
    """
    qp = QuadraticProgram("ALE_ENU_optimization")
    var_names = [f"x{i}" for i in range(N_VARS)]
    for v in var_names:
        qp.binary_var(v)

    # Linear terms from surrogate gradient at operating point
    linear_coeffs = surrogate_model.linear_coefficients()
    qp.minimize(
        linear=dict(zip(var_names, linear_coeffs)),
        quadratic=surrogate_model.quadratic_coefficients()
    )

    converter = QuadraticProgramToQubo()
    qubo = converter.convert(qp)
    return qubo

Hybrid QAOA and D-Wave Approach

The optimization used a two-stage hybrid strategy. D-Wave Advantage handled the initial continuous-to-discrete conversion and identified promising parameter neighborhoods via quantum annealing. QAOA on IBM Eagle then performed fine-grained combinatorial search within those neighborhoods, using warm-started initial states from the D-Wave solutions.

from qiskit_optimization.algorithms import MinimumEigenOptimizer, WarmStartQAOAOptimizer
from qiskit_algorithms import QAOA
from qiskit_algorithms.optimizers import COBYLA
from qiskit_aer import AerSimulator

# Stage 1: D-Wave annealing for coarse neighborhood search
def dwave_neighborhood_search(qubo_matrix, num_reads=1000):
    """
    Submit QUBO to D-Wave Advantage.
    Returns top-10 low-energy solutions as QAOA warm starts.
    """
    bqm = dimod.BinaryQuadraticModel.from_numpy_matrix(qubo_matrix)
    sampler = EmbeddingComposite(DWaveSampler())
    response = sampler.sample(bqm, num_reads=num_reads, chain_strength=2.0)
    top_solutions = [s.sample for s in response.truncate(10)]
    return top_solutions

# Stage 2: QAOA refinement with warm start
def qaoa_refinement(qubo, warm_start_solution, p=3):
    """
    Warm-start QAOA: initialize variational angles from
    classical (D-Wave) solution rather than uniform superposition.
    """
    backend = AerSimulator()
    qaoa = QAOA(
        optimizer=COBYLA(maxiter=300),
        reps=p,
        initial_point=None  # warm start sets initial state
    )
    optimizer = WarmStartQAOAOptimizer(
        pre_solver=None,
        relax_for_pre_solver=False,
        qaoa=MinimumEigenOptimizer(qaoa),
        epsilon=0.25
    )
    result = optimizer.solve(qubo)
    return result

# Iterative optimization loop
best_enu = float("inf")
history = []

for iteration in range(30):
    # Evaluate current best recipe on ALE tool (simulated measurement)
    current_params = decode_params(best_solution, param_ranges)
    enu_measured = measure_etch_uniformity(current_params)  # tool call

    history.append({"iteration": iteration, "enu": enu_measured})
    print(f"Iteration {iteration:2d}: ENU = {enu_measured:.3f}%")

    if enu_measured < best_enu:
        best_enu = enu_measured
        # Update surrogate with new measurement and reoptimize
        surrogate.update(current_params, enu_measured)
        qubo = build_enu_qubo(surrogate, param_ranges)
        d_wave_solutions = dwave_neighborhood_search(qubo.to_matrix())
        best_solution = qaoa_refinement(qubo, d_wave_solutions[0])

Results vs Classical DoE

Classical fractional factorial DoE for 12 parameters at 8 levels per parameter requires a resolution IV design with a minimum of 96 runs to estimate main effects and two-factor interactions. The quantum hybrid approach reached a solution with 1.3% ENU in 23 iterations (each iteration being a full ALE tool measurement at a proposed parameter set).

The 23 vs 96 run comparison reflects the efficiency of quantum optimization’s non-uniform sampling: rather than following a deterministic grid, the QAOA + D-Wave approach concentrates measurements in the parameter subspace where the surrogate model predicts lowest ENU. This is particularly effective when the ENU landscape has a small number of deep optima surrounded by high-ENU plateaus, the typical structure for plasma etch processes where small parameter changes near resonance conditions produce large uniformity jumps.

The 0.8 percentage point improvement in ENU (from 2.1% to 1.3%) translates directly to die yield on leading-edge chips. For a 300mm wafer with 400 chips, reducing ENU from 2.1% to 1.3% improves yield for sub-5nm features by approximately 3 to 5 percentage points, a commercially significant gain per tool per production lot. Tokyo Electron is extending the approach to chemical mechanical planarization (CMP) process optimization, where the parameter space structure is similarly amenable to quantum combinatorial search.

Learn more: Qiskit Reference