Reviewerly/exHarmony huggingface dataset:
Universe as a nonlinear quantum simulation: Large- <mml:math xmlns:mml="http://www.w3.org/1998/Math/MathML"><mml:mi>n</mml:mi></mml:math> limit of the central-spin model

We investigate models of nonlinear qubit evolution based on mappings to an $n$-qubit central-spin model (CSM) in the large-$n$ limit, where mean-field theory is exact. Extending a theorem of Erd\"os and Schlein [J. Stat. Phys. 134, 859 (2009)], we establish that the CSM is rigorously dual to a nonlinear qubit when $n\ensuremath{\rightarrow}\ensuremath{\infty}$. The duality supports a type of nonlinear quantum computation in systems, such as a condensate, where a large number of ancillas couple symmetrically to a central qubit. It also enables a gate-model implementation of nonlinear quantum simulation with a rigorous error bound. Two variants of the model, with and without coupling between ancillas, map to effective models with different nonlinearity and symmetry. Without coupling the CSM simulates initial-condition nonlinearity, where the Hamiltonian is a linear combination of $\mathrm{tr}({\ensuremath{\rho}}_{0}{\ensuremath{\sigma}}^{x}){\ensuremath{\sigma}}^{x}, \mathrm{tr}({\ensuremath{\rho}}_{0}{\ensuremath{\sigma}}^{y}){\ensuremath{\sigma}}^{y}$, and $\mathrm{tr}({\ensuremath{\rho}}_{0}{\ensuremath{\sigma}}^{z}){\ensuremath{\sigma}}^{z}$, where ${\ensuremath{\sigma}}^{x}, {\ensuremath{\sigma}}^{y}$, and ${\ensuremath{\sigma}}^{z}$ are Pauli matrices and ${\ensuremath{\rho}}_{0}$ is the initial density matrix. With symmetric ancillas coupling it simulates linear combinations of $\mathrm{tr}(\ensuremath{\rho}{\ensuremath{\sigma}}^{x}){\ensuremath{\sigma}}^{x}, \mathrm{tr}(\ensuremath{\rho}{\ensuremath{\sigma}}^{y}){\ensuremath{\sigma}}^{y}$, and $\mathrm{tr}(\ensuremath{\rho}{\ensuremath{\sigma}}^{z}){\ensuremath{\sigma}}^{z}$, where $\ensuremath{\rho}$ is the current state. This case can simulate qubit torsion, which has been shown by Abrams and Lloyd [Phys. Rev. Lett. 81, 3992 (1998)] to enable an exponential speedup for state discrimination in an idealized setting. The duality discussed here might also be interesting from a quantum foundation perspective. There has long been interest in whether quantum mechanics might possess some type of small unobserved nonlinearity. If not, what is the principle prohibiting it? The duality implies that there is not a sharp distinction between universes evolving according to linear and nonlinear quantum mechanics: A one-qubit universe prepared in a pure state $|\ensuremath{\varphi}\ensuremath{\rangle}$ at the time of the big bang and symmetrically coupled to ancillas prepared in the same state would appear to evolve nonlinearly for any finite time $t&gt;0$ as long as there are exponentially many ancillas $n\ensuremath{\gg}\mathrm{exp}[O(t)]$.
On the Computability of Primitive Recursive Functions by Feedforward Artificial Neural Networks

We show that, for a primitive recursive function h(x,t), where x is a n-tuple of natural numbers and t is a natural number, there exists a feedforward artificial neural network N(x,t), such that for any n-tuple of natural numbers z and a positive natural number m, the first m+1 terms of the sequence {h(z,t)} are the same as the terms of the tuple (N(z,0),…,N(z,m)).
Compositional Verification of Efficient Masking Countermeasures against Side-Channel Attacks

Masking is one of the most effective countermeasures for securely implementing cryptographic algorithms against power side-channel attacks, the design of which however turns out to be intricate and error-prone. While techniques have been proposed to rigorously verify implementations of cryptographic algorithms, currently they are limited in scalability. To address this issue, compositional approaches have been investigated, but insofar they fail to prove the security of recent efficient implementations. To fill this gap, we propose a novel compositional verification approach. In particular, we introduce two new language-level security notions based on which we propose composition strategies and verification algorithms. Our approach is able to prove efficient implementations, which cannot be done by prior compositional approaches. We implement our approach as a tool CONVINCE and conduct extensive experiments to confirm its efficacy. We also use CONVINCE to further explore the design space of the AES Sbox with least refreshing by replacing its implementation for finite-field multiplication with more efficient counterparts. We automatically prove leakage-freeness of these new versions. As a result, we can effectively reduce 1,600 randomness and 3,200 XOR-operations of the state-of-the-art AES implementation.
Equality Saturation Theory Exploration à la Carte

Rewrite rules are critical in equality saturation, an increasingly popular technique in optimizing compilers, synthesizers, and verifiers. Unfortunately, developing high-quality rulesets is difficult and error-prone. Recent work on automatically inferring rewrite rules does not scale to large terms or grammars, and existing rule inference tools are monolithic and opaque. Equality saturation users therefore struggle to guide inference and incrementally construct rulesets. As a result, most users still manually develop and maintain rulesets. This paper proposes Enumo, a new domain-specific language for programmable theory exploration. Enumo provides a small set of core operators that enable users to strategically guide rule inference and incrementally build rulesets. Short Enumo programs easily replicate results from state-of-the-art tools, but Enumo programs can also scale to infer deeper rules from larger grammars than prior approaches. Its composable operators even facilitate developing new strategies for ruleset inference. We introduce a new fast-forwarding strategy that does not require evaluating terms in the target language, and can thus support domains that were out of scope for prior work. We evaluate Enumo and fast-forwarding across a variety of domains. Compared to state-of-the-art techniques, enumo can synthesize better rulesets over a diverse set of domains, in some cases matching the effects of manually-developed rulesets in systems driven by equality saturation.
Gradual Typing for Effect Handlers

We present a gradually typed language, GrEff, with effects and handlers that supports migration from unchecked to checked effect typing. This serves as a simple model of the integration of an effect typing discipline with an existing effectful typed language that does not track fine-grained effect information. Our language supports a simple module system to model the programming model of gradual migration from unchecked to checked effect typing in the style of Typed Racket. The surface language GrEff is given semantics by elaboration to a core language Core GrEff. We equip Core GrEff with an inequational theory for reasoning about the semantic error ordering and desired program equivalences for programming with effects and handlers. We derive an operational semantics for the language from the equations provable in the theory. We then show that the theory is sound by constructing an operational logical relations model to prove the graduality theorem. This extends prior work on embedding-projection pair models of gradual typing to handle effect typing and subtyping.
SportsTables: A New Corpus for Semantic Type Detection (Extended Version)

Abstract Table corpora such as VizNet or TURL which contain annotated semantic types per column are important to build machine learning models for the task of automatic semantic type detection. However, there is a huge discrepancy between corpora and real-world data lakes since they contain a huge fraction of numerical data which are not present in existing corpora. Hence, in this paper, we introduce a new corpus that contains a much higher proportion of numerical columns than existing corpora. To reflect the distribution in real-world data lakes, our corpus SportsTables has on average approx. 86% numerical columns, posing new challenges to existing semantic type detection models which have mainly targeted non-numerical columns so far. To demonstrate this effect, we show in this extended version paper of [18] the results of an extensive study using four different state-of-the-art approaches for semantic type detection on our new corpus. Overall, the results demonstrate significant performance differences in predicting semantic types for textual and numerical data.
Fast and Efficient Boolean Unification for Hindley-Milner-Style Type and Effect Systems

As type and effect systems become more expressive there is an increasing need for efficient type inference. We consider a polymorphic effect system based on Boolean formulas where inference requires Boolean unification. Since Boolean unification involves semantic equivalence, conventional syntax-driven unification is insufficient. At the same time, existing Boolean unification techniques are ill-suited for type inference. We propose a hybrid algorithm for solving Boolean unification queries based on Boole’s Successive Variable Elimination (SVE) algorithm. The proposed approach builds on several key observations regarding the Boolean unification queries encountered in practice, including: (i) most queries are simple, (ii) most queries involve a few flexible variables, (iii) queries are likely to repeat due similar programming patterns, and (iv) there is a long tail of complex queries. We exploit these observations to implement several strategies for formula minimization, including ones based on tabling and binary decision diagrams. We implement the new hybrid approach in the Flix programming language. Experimental results show that by reducing the overhead of Boolean unification, the compilation throughput increases from 8,580 lines/sec to 15,917 lines/sec corresponding to a 1.8x speed-up. Further, the overhead on type and effect inference time is only 16% which corresponds to an overhead of less than 7% on total compilation time. We study the hybrid approach and demonstrate that each design choice improves performance.
Saggitarius: A DSL for Specifying Grammatical Domains

Common data types like dates, addresses, phone numbers and tables can have multiple textual representations, and many heavily-used languages, such as SQL, come in several dialects. These variations can cause data to be misinterpreted, leading to silent data corruption, failure of data processing systems, or even security vulnerabilities. Saggitarius is a new language and system designed to help programmers reason about the format of data, by describing grammatical domains---that is, sets of context-free grammars that describe the many possible representations of a datatype. We describe the design of Saggitarius via example and provide a relational semantics. We show how Saggitarius may be used to analyze a data set: given example data, it uses an algorithm based on semi-ring parsing and MaxSAT to infer which grammar in a given domain best matches that data. We evaluate the effectiveness of the algorithm on a benchmark suite of 110 example problems, and we demonstrate that our system typically returns a satisfying grammar within a few seconds with only a small number of examples. We also delve deeper into a more extensive case study on using Saggitarius for CSV dialect detection. Despite being general-purpose, we find that Saggitarius offers comparable results to hand-tuned, specialized tools; in the case of CSV, it infers grammars for 84% of benchmarks within 60 seconds, and has comparable accuracy to custom-built dialect detection tools.
Optical transmitter tunable over a 65-nm wavelength range around 1550 nm for quantum key distribution

The ability to create phase-controlled pulses of light with wavelength tunability has applications spanning quantum and classical communications networks. Traditionally, optical transmitters are able to either produce phase-controlled pulses at a fixed wavelength or require a chain of bulky and expensive external modulators to convert wavelength tunable continuous-wave light into optical pulses. One technology of great interest is quantum key distribution (QKD), a technology for generating perfectly random keys at remote nodes to ensure secure communications. Environments such as data centers, where the user needs change regularly, will require adaptability in the deployment of QKD to integrate into classical optical networks. Here we propose and demonstrate an alternative quantum transmitter design consisting of a multimodal Fabry-Perot laser optically injection locked by a wavelength tunable laser. The transmitter is able to produce phase-controlled optical pulses at GHz speeds with a tunable wavelength range of >65nm centered at 1550 nm. With this transmitter, we perform proof-of-principle QKD with secure bit rates of order Mb/s.
Adventure of a Lifetime: Extract Method Refactoring for Rust

We present a design and implementation of the automated "Extract Method" refactoring for Rust programs. Even though Extract Method is one of the most well-studied and widely used in practice automated refactorings, featured in all major IDEs for all popular programming languages, implementing it soundly for Rust is surprisingly non-trivial due to the restrictions of the Rust's ownership and lifetime-based type system. In this work, we provide a systematic decomposition of the Extract Method refactoring for Rust programs into a series of program transformations, each concerned with satisfying a particular aspect of Rust type safety, eventually producing a well-typed Rust program. Our key discovery is the formulation of Extract Method as a composition of naive function hoisting and a series of automated program repair procedures that progressively make the resulting program "more well-typed" by relying on the corresponding repair oracles. Those oracles include a novel static intra-procedural ownership analysis that infers correct sharing annotations for the extracted function's parameters, and the lifetime checker of rustc, Rust's reference compiler. We implemented our approach in a tool called REM---an automated Extract Method refactoring built on top of IntelliJ IDEA plugin for Rust. Our extensive evaluation on a corpus of changes in five popular Rust projects shows that REM (a) can extract a larger class of feature-rich code fragments into semantically correct functions than other existing refactoring tools, (b) can reproduce method extractions performed manually by human developers in the past, and (c) is efficient enough to be used in interactive development.
Quantum-Dot-Based Photonic Reservoir Computing

Abstract Reservoir computing is a novel computational framework based on the characteristic behavior of recurrent neural networks. In particular, a recurrent neural network for reservoir computing is defined as a reservoir, which is implemented as a fixed and nonlinear system. Recently, to overcome the limitation of data throughput between processors and storage devices in conventional computer systems during processing, known as the Von Neumann bottleneck, physical implementations of reservoirs have been actively investigated in various research fields. The author’s group has been currently studying a quantum dot reservoir , which consists of coupled structures of randomly dispersed quantum dots, as a physical reservoir. The quantum dot reservoir is driven by sequential signal inputs using radiation with laser pulses, and the characteristic dynamics of the excited energy in the network are exhibited with the corresponding spatiotemporal fluorescence outputs. We have presented the fundamental physics of a quantum dot reservoir. Subsequently, experimental methods have been introduced to prepare a practical quantum dot reservoir. Next, we have presented the experimental input/output properties of our quantum dot reservoir. Here, we experimentally focused on the relaxation of fluorescence outputs, which indicates the characteristics of optical energy dynamics in the reservoir, and qualitatively discussed the usability of quantum dot reservoirs based on their properties. Finally, we have presented experimental reservoir computing based on spatiotemporal fluorescence outputs from a quantum dot reservoir. We consider that the achievements of quantum dot reservoirs can be effectively utilized for advanced reservoir computing.
Exploring Integrated Device Implementation for FRET-Based Optical Reservoir Computing

Abstract This chapter explores a reservoir computing (RC) device based on fluorescence resonance energy transfer (FRET) between quantum dots (QDs). We propose a compact structure in which optical input/output and quantum dots are adjacently placed without lenses or delay lines. The proposed structure exploits the QD-based optical reservoir as an intermediate layer and adopts memory to enable recurrent inputs. We evaluate the feasibility of the proposed structure by applying tasks that require nonlinearity. Simulation-based experimental results show that the proposed device can perform logistic map, time-series XOR, and NARMA10. A proof-of-concept implementation with a commercial image sensor demonstrates that the proposed structure can solve XOR and MNIST tasks. Also, we discuss the energy advantage over conventional digital circuit implementations.
Revival of Optical Computing

Abstract Optical computing is a general term for high-performance computing technologies that effectively use the physical properties of light. With the rapid development of electronics, its superiority as a high-performance computing technology has diminished; however, there is momentum for research on new optical computing. This study reviews the history of optical computing, clarifies its diversity, and provides suggestions for new developments. Among the methods proposed thus far, those considered useful for utilizing optical technology in information systems are introduced. Subsequently, the significance of optical computing in the modern context is considered and directions for future development is presented.
Nonlinear Dynamics and Computing in Recurrent Neural Networks

Abstract Nonlinearity is a key concept in the design and implementation of photonic neural networks for computing. This chapter introduces the fundamental models and concepts of recurrent neural networks, with a particular focus on their nonlinear dynamics. We review several types of nonlinear dynamics that emerge in symmetrically connected recurrent neural networks, in which the energy function plays a crucial role. In addition, we introduce the concepts of reservoir computing, covering fundamental models and physical reservoir computing. Overall, this chapter provides a foundation for the theoretical aspects in the subsequent chapters of this book, which explore a variety of photonic neural networks with nonlinear spatiotemporal dynamics.
Stuttering for Free

One of the most common tools for proving behavioral refinements between transition systems is the method of simulation proofs, which has been explored extensively over the past several decades. Stuttering simulations are an extension of traditional simulations—used, for example, in CompCert—in which either the source or target of the simulation is permitted to “stutter” (stay in place) while the other side steps forward. In the interest of ensuring soundness, however, existing stuttering simulations restrict proofs to only perform a finite number of stuttering steps before making synchronous progress —a step of reasoning in which both sides of the simulation progress forward together. This restriction guarantees that a terminating program cannot be proven to simulate a non-terminating one. In this paper, we observe that the requirement to eventually achieve synchronous progress is burdensome and, what’s more, unnecessary: it is possible to ensure soundness of stuttering simulations while only requiring asynchronous progress (progress on both sides of the simulation that may be achieved with only stuttering steps). Building on this observation, we develop a new simulation technique we call FreeSim (short for “freely-stuttering simulations”), mechanized in Coq, and we demonstrate its effectiveness on a range of interesting case studies. These include a simplification of the meta-theory of CompCert, as well as the DTrees library, which enriches the ITrees (Interaction Trees) library with dual non-determinism.
Bring Your Own Data Structures to Datalog

The restricted logic programming language Datalog has become a popular implementation target for deductive-analytic workloads including social-media analytics and program analysis. Modern Datalog engines compile Datalog rules to joins over explicit representations of relations—often B-trees or hash maps. While these modern engines have enabled high scalability in many application domains, they have a crucial weakness: achieving the desired algorithmic complexity may be impossible due to representation-imposed overhead of the engine’s data structures. In this paper, we present the "Bring Your Own Data Structures" (Byods) approach, in the form of a DSL embedded in Rust. Using Byods, an engineer writes logical rules which are implicitly parametric on the concrete data structure representation; our implementation provides an interface to enable "bringing their own" data structures to represent relations, which harmoniously interact with code generated by our compiler (implemented as Rust procedural macros). We formalize the semantics of Byods as an extension of Datalog’s; our formalization captures the key properties demanded of data structures compatible with Byods, including properties required for incrementalized (semi-naïve) evaluation. We detail many applications of the Byods approach, implementing analyses requiring specialized data structures for transitive and equivalence relations to scale, including an optimized version of the Rust borrow checker Polonius; highly-parallel PageRank made possible by lattices; and a large-scale analysis of LLVM utilizing index-sharing to scale. Our results show that Byods offers both improved algorithmic scalability (reduced time and/or space complexity) and runtimes competitive with state-of-the-art parallelizing Datalog solvers.
Complex-valued matrix–vector multiplication system for a large-scale optical FFT

Recent advancements in optical convolutional neural networks (CNNs) and radar signal processing systems have brought an increasing need for the adoption of optical fast Fourier transform (OFFT). Presently, the fast Fourier transform (FFT) is executed using electronic means within prevailing architectures. However, this electronic approach faces limitations in terms of both speed and power consumption. Concurrently, existing OFFT systems struggle to balance the demands of large-scale processing and high precision simultaneously. In response, we introduce a novel, to the best of our knowledge, solution: a complex-valued matrix-vector system harnessed through wavelength selective switches (WSSs) for the realization of a 24-input optical FFT, achieving a high-accuracy level of 5.4 bits. This study capitalizes on the abundant wavelength resources available to present a feasible solution for an optical FFT system with a large N.