Search

A critical milestone for quantum computers is to demonstrate fault-tolerant computation that outperforms computation on physical qubits. The tesseract subsystem color code protects four logical qubits in 16 physical qubits, to distance four. Using the tesseract code on Quantinuum's trapped-ion quantum computers, we prepare high-fidelity encoded graph states on up to 12 logical qubits, beneficially combining for the first time fault-tolerant error correction and computation. We also protect encoded states through up to five rounds of error correction. Using performant quantum software and hardware together allows moderate-depth logical quantum circuits to have an order of magnitude less error than the equivalent unencoded circuits., Comment: 12 pages, 13 figures

The enormous scale of state-of-the-art foundation models has limited their accessibility to scientists, because customized experiments at large model sizes require costly hardware and complex engineering that is impractical for most researchers. To alleviate these problems, we introduce NNsight, an open-source Python package with a simple, flexible API that can express interventions on any PyTorch model by building computation graphs. We also introduce NDIF, a collaborative research platform providing researchers access to foundation-scale LLMs via the NNsight API. Code, documentation, and tutorials are available at https://www.nnsight.net., Comment: Code at https://nnsight.net

There is a tight connection between credit access and voting. We show that uncertainty in access to credit pushes voters toward more conservative candidates in US elections. Using a 1% sample of the US population with valid credit reports, we relate access to credit to voting outcomes in all county-by-congressional districts over the period 2004-2016. Specifically, we construct exogenous measures of uncertainty to credit access, i.e. credit score values around which individual total credit amount jumps the most (e.g. around which uncertainty on access to credit is the highest). We then show that a 10pp increase in the share of marginal voters located just around these thresholds increases republican votes by 2.7pp, and reduces that of democrats by 2.6pp. Furthermore, winning candidates in more uncertain constituencies tend to follow a more conservative rhetoric.

Empirical evidence for a gap between the computational powers of classical and quantum computers has been provided by experiments that sample the output distributions of two-dimensional quantum circuits. Many attempts to close this gap have utilized classical simulations based on tensor network techniques, and their limitations shed light on the improvements to quantum hardware required to frustrate classical simulability. In particular, quantum computers having in excess of $\sim 50$ qubits are primarily vulnerable to classical simulation due to restrictions on their gate fidelity and their connectivity, the latter determining how many gates are required (and therefore how much infidelity is suffered) in generating highly-entangled states. Here, we describe recent hardware upgrades to Quantinuum's H2 quantum computer enabling it to operate on up to $56$ qubits with arbitrary connectivity and $99.843(5)\%$ two-qubit gate fidelity. Utilizing the flexible connectivity of H2, we present data from random circuit sampling in highly connected geometries, doing so at unprecedented fidelities and a scale that appears to be beyond the capabilities of state-of-the-art classical algorithms. The considerable difficulty of classically simulating H2 is likely limited only by qubit number, demonstrating the promise and scalability of the QCCD architecture as continued progress is made towards building larger machines., Comment: Includes minor updates to the text and an updated author list to include researchers who made technical contributions in upgrading the machine to 56 qubits but were left off the original version by mistake

The ~200 m/s impact of a single 400-kg Bjurb\"ole L/LL ordinary chondrite meteorite onto sea ice resulted in the catastrophic disruption of the projectile. This resulted in a significant fraction of decimeter-sized fragments that exhibit power law cumulative size and mass distributions. This size range is underrepresented in impact experiments and asteroid boulder studies. The Bjurb\"ole projectile fragments share similarities in shape (sphericity, and roughness at small and large scale) with asteroid boulders. However, the mean aspect ratio (3D measurement) and apparent aspect ratio (2D measurement) of Bjurb\"ole fragment is 0.83 and 0.77, respectively, indicating that Bjurb\"ole fragments are more equidimensional compared to both fragments produced in smaller scale impact experiments and asteroid boulders. These differences may be attributed either to the fragment source (projectile vs. target), to the high porosity and low strength of Bjurb\"ole, to the lower impact velocity compared with typical asteroid collision velocities, or potentially to fragment erosion during sea sediment penetration or cleaning., Comment: Data repository https://www.doi.org/10.5281/zenodo.10062980

Morphological mapping is a fundamental step in studying the processes that shaped an asteroid surface. Yet, it is challenging and often requires multiple independent assessments by trained experts. Here, we present fast methods to detect and characterize meaningful terrains from the topographic roughness: entropy of information, and local mean surface orientation. We apply our techniques to Didymos and Dimorphos, the target asteroids of NASA's DART mission: first attempt to deflect an asteroid. Our methods reliably identify morphological units at multiple scales. The comparative study reveals various terrain types, signatures of processes that transformed Didymos and Dimorphos. Didymos shows the most heterogeneity and morphology that indicate recent resurfacing events. Dimorphos is comparatively rougher than Didymos, which may result from the formation process of the binary pair and past interaction between the two bodies. Our methods can be readily applied to other bodies and data sets., Comment: submitted to PSJ

Quantum state teleportation is commonly used in designs for large-scale fault-tolerant quantum computers. Using Quantinuum's H2 trapped-ion quantum processor, we implement the first demonstration of a fault-tolerant state teleportation circuit for a quantum error correction code - in particular, the planar topological [[7,1,3]] color code, or Steane code. The circuits use up to 30 trapped ions at the physical layer qubits and employ real-time quantum error correction - decoding mid-circuit measurement of syndromes and implementing corrections during the protocol. We conduct experiments on several variations of logical teleportation circuits using both transversal gates and lattice surgery protocols. Among the many measurements we report on, we measure the logical process fidelity of the transversal teleportation circuit to be 0.975(2) and the logical process fidelity of the lattice surgery teleportation circuit to be 0.851(9). Additionally, we run a teleportation circuit that is equivalent to Knill-style quantum error correction and measure the process fidelity to be 0.989(2).

CodeLLMs are transforming software development as we know it. This is especially true for tasks where rule-based approaches fall short, like type prediction. The type prediction task consists in adding a new type annotation to a partially typed program, such that the resulting program is closer to being fully typed. The intractability of rule-based approaches and high cost of manual annotation make CodeLLMs an attractive solution to the problem. However, CodeLLMs are still far from being deployed on the large-scale due to doubts surrounding their reliability. To shed some light on how CodeLLMs approach type prediction, we investigate what happens when a model mispredicts a type. We show that by applying semantics-preserving edits to code, CodeLLMs are eventually misled into mispredicting type annotations. However, by leveraging activation steering we are able to "steer" the model back to the correct prediction, making models more robust against semantically irrelevant prompt features. We show that steering achieves comparable performance to fine-tuning directly on the type prediction task. Furthermore, we find that steering vectors computed from Python code are effective at correcting TypeScript mispredictions, and vice versa. To our knowledge, this is the first evidence of its kind to suggest that CodeLLMs learn task representations that transfer across languages., Comment: 14 pages, 7 figures

The promise of quantum computers hinges on the ability to scale to large system sizes, e.g., to run quantum computations consisting of more than 100 million operations fault-tolerantly. This in turn requires suppressing errors to levels inversely proportional to the size of the computation. As a step towards this ambitious goal, we present experiments on a trapped-ion QCCD processor where, through the use of fault-tolerant encoding and error correction, we are able to suppress logical error rates to levels below the physical error rates. In particular, we entangled logical qubits encoded in the [[7,1,3]] code with error rates 9.8 times to 500 times lower than at the physical level, and entangled logical qubits encoded in a [[12,2,4]] code with error rates 4.7 times to 800 times lower than at the physical level, depending on the judicious use of post-selection. Moreover, we demonstrate repeated error correction with the [[12,2,4]] code, with logical error rates below physical circuit baselines corresponding to repeated CNOTs, and show evidence that the error rate per error correction cycle, which consists of over 100 physical CNOTs, approaches the error rate of two physical CNOTs. These results signify an important transition from noisy intermediate scale quantum computing to reliable quantum computing, and demonstrate advanced capabilities toward large-scale fault-tolerant quantum computing., Comment: 13 pages, 8 figures

On September 26, 2022, NASA's Double Asteroid Redirection Test (DART) mission successfully impacted Dimorphos, the natural satellite of the binary near-Earth asteroid (65803) Didymos. Numerical simulations of the impact provide a means to explore target surface material properties and structures, consistent with the observed momentum deflection efficiency, ejecta cone geometry, and ejected mass. Our simulation, which best matches observations, indicates that Dimorphos is weak, with a cohesive strength of less than a few pascals (Pa), similar to asteroids (162173) Ryugu and (101955) Bennu. We find that a bulk density of Dimorphos, rhoB, lower than 2400 kg/m3, and a low volume fraction of boulders (<40 vol%) on the surface and in the shallow subsurface, are consistent with measured data from the DART experiment. These findings suggest Dimorphos is a rubble pile that might have formed through rotational mass shedding and re-accumulation from Didymos. Our simulations indicate that the DART impact caused global deformation and resurfacing of Dimorphos. ESA's upcoming Hera mission may find a re-shaped asteroid, rather than a well-defined crater.

We explore binary asteroid formation by spin-up and rotational disruption considering the NASA DART mission's encounter with the Didymos-Dimorphos binary, which was the first small binary visited by a spacecraft. Using a suite of $N$-body simulations, we follow the gravitational accumulation of a satellite from meter-sized particles following a mass-shedding event from a rapidly rotating primary. The satellite's formation is chaotic, as it undergoes a series of collisions, mergers, and close gravitational encounters with other moonlets, leading to a wide range of outcomes in terms of the satellite's mass, shape, orbit, and rotation state. We find that a Dimorphos-like satellite can form rapidly, in a matter of days, following a realistic mass-shedding event in which only ${\sim}2-3\%$ of the primary's mass is shed. Satellites can form in synchronous rotation due to their formation near the Roche limit. There is a strong preference for forming prolate (elongated) satellites, although some simulations result in oblate spheroids like Dimorphos. The distribution of simulated secondary shapes is broadly consistent with other binary systems, measured through radar or lightcurves. Unless Dimorphos's shape is an outlier, and considering the observational bias against lightcurve-based determination of secondary elongations for oblate bodies, we suggest there could be a significant population of oblate secondaries. If these satellites initially form with elongated shapes, a yet-unidentified pathway is needed to explain how they become oblate. Finally, we show that this chaotic formation pathway occasionally forms asteroid pairs and stable triples, including co-orbital satellites and satellites in mean motion resonances., Comment: 41 pages, 23 figures, accepted to PSJ, movies available at https://zenodo.org/doi/10.5281/zenodo.8387043

Recent advancements in large language models (LLMs) have spurred interest in using them for generating robot programs from natural language, with promising initial results. We investigate the use of LLMs to generate programs for service mobile robots leveraging mobility, perception, and human interaction skills, and where accurate sequencing and ordering of actions is crucial for success. We contribute CodeBotler, an open-source robot-agnostic tool to program service mobile robots from natural language, and RoboEval, a benchmark for evaluating LLMs' capabilities of generating programs to complete service robot tasks. CodeBotler performs program generation via few-shot prompting of LLMs with an embedded domain-specific language (eDSL) in Python, and leverages skill abstractions to deploy generated programs on any general-purpose mobile robot. RoboEval evaluates the correctness of generated programs by checking execution traces starting with multiple initial states, and checking whether the traces satisfy temporal logic properties that encode correctness for each task. RoboEval also includes multiple prompts per task to test for the robustness of program generation. We evaluate several popular state-of-the-art LLMs with the RoboEval benchmark, and perform a thorough analysis of the modes of failures, resulting in a taxonomy that highlights common pitfalls of LLMs at generating robot programs. We release our code and benchmark at https://amrl.cs.utexas.edu/codebotler/., Comment: 8 pages, Accepted at IEEE Robotics and Automation Letters (RA-L)

Fault-tolerant protocols enable large and precise quantum algorithms. Many such protocols rely on a feed-forward processing of data, enabled by a hybrid of quantum and classical logic. Representing the control structure of such programs can be a challenge. Here we explore two such fault-tolerant subroutines and analyze the performance of the subroutines using Quantum Intermediate Representation (QIR) as their underlying intermediate representation. First, we look at QIR's ability to leverage the LLVM compiler toolchain to unroll the quantum iteration logic required to perform magic state distillation on the $[[5,1,3]]$ quantum error-correcting code as originally introduced by Bravyi and Kitaev [Phys. Rev. A 71, 022316 (2005)]. This allows us to not only realize the first implementation of a real-time magic state distillation protocol on quantum hardware, but also demonstrate QIR's ability to optimize complex program structures without degrading machine performance. Next, we investigate a different fault-tolerant protocol that was first introduced by Paetznick and Svore [arXiv:1311.1074 (2013)], that reduces the amount of non-Clifford gates needed for a particular algorithm. We look at four different implementations of this two-stage repeat-until-success algorithm to analyze the performance changes as the results of programming choices. We find the QIR offers a viable representation for a compiled high-level program that performs nearly as well as a hand-optimized version written directly in quantum assembly. Both of these results demonstrate QIR's ability to accurately and efficiently expand the complexity of fault-tolerant protocols that can be realized today on quantum hardware.

The Didymos binary asteroid was the target of the Double Asteroid Redirection Test (DART) mission, which intentionally impacted Dimorphos, the smaller member of the binary system. We used the Near-Infrared Spectrograph (NIRSpec) and Mid-Infrared Instrument (MIRI) instruments on JWST to measure the 0.6-5 $\mu$m and 5-20 $\mu$m spectra of Didymos approximately two months after the DART impact. These observations confirm that Didymos belongs to the S asteroid class and is most consistent with LL chondrite composition as was previously determined from its 0.6-2.5-$\mu$m reflectance spectrum. Measurements at wavelengths $>$ 2.5 $\mu$m show Didymos to have thermal properties typical for an S-complex asteroid of its size and to be lacking absorptions deeper than $\sim$2\% due to OH or H2O. Didymos' mid-infrared emissivity spectrum is within the range of what has been observed on S-complex asteroids observed with Spitzer Space Telescope and is most consistent with emission from small ($<$ 25 $\mu$m) surface particles. We conclude that the observed reflectance and physical properties make the Didymos system a good proxy for the type of ordinary chondrite asteroids that cross near-Earth space, and a good representative of likely future impactors., Comment: Accepted by the Planetary Science Journal, 16 October 2023 Paper has 29 pages, 13 figures, 1 table

Over the past few years, Large Language Models of Code (Code LLMs) have started to have a significant impact on programming practice. Code LLMs are also emerging as building blocks for research in programming languages and software engineering. However, Code LLMs produce impressive results on programming languages that are well represented in their training data (e.g., Java, Python, or JavaScript), but struggle with low-resource languages that have limited training data available. Low resource languages include OCaml, Racket, and several others. This paper presents an effective approach for boosting the performance of Code LLMs on low-resource languages using semi-synthetic data. Our approach, MultiPL-T, translates training data from high-resource languages into training data for low-resource languages in the following way. 1) We use a Code LLM to synthesize tests for commented code from a high-resource language, filtering out faulty tests and code with low test coverage. 2) We use a Code LLM to translate Python code to a target low-resource language, and use tests to validate the translation. We apply this approach to generate tens of thousands of validated training items for Julia, Lua, OCaml, R, and Racket. Furthermore, we use an open model (StarCoderBase) with open training data (The Stack), which allows us to decontaminate benchmarks, train models without violating licenses, and run experiments that could not otherwise be done. With MultiPL-T generated data, we present fine-tuned versions of StarCoderBase and Code Llama for Julia, Lua, OCaml, R, and Racket. On established benchmarks (MultiPL-E), these models outperform other open Code LLMs. The MultiPL-T approach is easy to apply to new languages, and is significantly more efficient and effective than alternatives such as training longer.

We describe and benchmark a new quantum charge-coupled device (QCCD) trapped-ion quantum computer based on a linear trap with periodic boundary conditions, which resembles a race track. The new system successfully incorporates several technologies crucial to future scalability, including electrode broadcasting, multi-layer RF routing, and magneto-optical trap (MOT) loading, while maintaining, and in some cases exceeding, the gate fidelities of previous QCCD systems. The system is initially operated with 32 qubits, but future upgrades will allow for more. We benchmark the performance of primitive operations, including an average state preparation and measurement error of 1.6(1)$\times 10^{-3}$, an average single-qubit gate infidelity of $2.5(3)\times 10^{-5}$, and an average two-qubit gate infidelity of $1.84(5)\times 10^{-3}$. The system-level performance of the quantum processor is assessed with mirror benchmarking, linear cross-entropy benchmarking, a quantum volume measurement of $\mathrm{QV}=2^{16}$, and the creation of 32-qubit entanglement in a GHZ state. We also tested application benchmarks including Hamiltonian simulation, QAOA, error correction on a repetition code, and dynamics simulations using qubit reuse. We also discuss future upgrades to the new system aimed at adding more qubits and capabilities., Comment: 24 pages, 24 figures. Made some minor edits and added several more authors