Programmable quantum state discriminators with simple programs

We describe a class of programmable devices that can discriminate between two quantum states. We consider two cases. In the first, both states are unknown. One copy of each of the unknown states is provided as input, or program, for the two program registers, and the data state, which is guaranteed to be prepared in one of the program states, is fed into the data register of the device. This device will then tell us, in an optimal way, which of the templates stored in the program registers the data state matches. In the second case, we know one of the states while the other is unknown. One copy of the unknown state is fed into the single program register, and the data state which is guaranteed to be prepared in either the program state or the known state, is fed into the data register. The device will then tell us, again optimally, whether the data state matches the template or is the known state. We determine two types of optimal devices. The first performs discrimination with minimum error, the second performs optimal unambiguous discrimination. In all cases we first treat the simpler problem of only one copy of the data state and then generalize the treatment to n copies. In comparison to other works we find that providing n > 1 copies of the data state yields higher success probabilities than providing n > 1 copies of the program states.Comment: 17 pages, 5 figure

Improving State Evaluation of Principal Preparation Programs

Intended for state officials involved in the assessment and approval of university and other programs to train future school principals, this report describes five design principles for effective program evaluation. "While states will undoubtedly want and need to develop systems unique to their context, they could benefit from having guideposts to organize what can be complex work," says the report, which was written jointly by representatives from New Leaders, which helps train school leaders and designs leadership policies and practices for school systems, and the University Council for Educational Administration, a consortium of universities that seeks to promote high-quality education leadership preparation and research. The principles, which emerged from a New Leaders/University Council project to develop a model evaluation system and accompanying of tools, are:Structure the review process in a way that is conducive to continuous program improvement.Create appropriate systems to hold programs accountable for effective practices and outcomes.Provide key stakeholders with accurate and useful information.Take a sophisticated and nuanced approach to data collection and use.Adhere to characteristics of high-quality program evaluation.The report also describes how two states, Illinois and Delaware, have approached evaluation, and provides a tool from its model-development work, an assessment that states can use to determine their degree of "readiness" for building a stronger system to evaluate principal preparation programs

The Pre-K Pinch: Early Education and the Middle Class

Reviews evidence on the benefits of pre-K programs and the difficulties families that do not qualify for state programs face in paying for early education. Calls for high-quality, voluntary, state-funded programs for all. Includes state-level analyses

Paid Leave through State Temporary Disability Insurance Programs

A fact sheet that answers specific questions about how state Temporary Disability Programs in CA, HI, NJ, NY, RI and Puerto Rico can provide paid leave for expectant mothers

Building Medical Homes in State Medicaid and CHIP Programs

Presents strategies, best practices, and lessons learned from ten states' efforts to advance the medical home model of comprehensive and coordinated care in Medicaid and Children's Health Insurance Programs in order to improve quality and contain costs

A testability transformation approach for state-based programs

Search based testing approaches are efficient in test data generation; however they are likely to perform poorly when applied to programs with state variables. The problem arises when the target function includes guards that reference some of the program state variables whose values depend on previous function calls. Thus, merely considering the target function to derive test data is not sufficient. This paper introduces a testability transformation approach based on the analysis of control and data flow dependencies to bypass the state variable problem. It achieves this by eliminating state variables from guards and/ or determining which functions to call in order to satisfy guards with state variables. A number of experiments demonstrate the value of the proposed approach

LANDSAT's role in state coastal management programs

There are no author-identified significant results in this report

A Fast Compiler for NetKAT

High-level programming languages play a key role in a growing number of networking platforms, streamlining application development and enabling precise formal reasoning about network behavior. Unfortunately, current compilers only handle "local" programs that specify behavior in terms of hop-by-hop forwarding behavior, or modest extensions such as simple paths. To encode richer "global" behaviors, programmers must add extra state -- something that is tricky to get right and makes programs harder to write and maintain. Making matters worse, existing compilers can take tens of minutes to generate the forwarding state for the network, even on relatively small inputs. This forces programmers to waste time working around performance issues or even revert to using hardware-level APIs. This paper presents a new compiler for the NetKAT language that handles rich features including regular paths and virtual networks, and yet is several orders of magnitude faster than previous compilers. The compiler uses symbolic automata to calculate the extra state needed to implement "global" programs, and an intermediate representation based on binary decision diagrams to dramatically improve performance. We describe the design and implementation of three essential compiler stages: from virtual programs (which specify behavior in terms of virtual topologies) to global programs (which specify network-wide behavior in terms of physical topologies), from global programs to local programs (which specify behavior in terms of single-switch behavior), and from local programs to hardware-level forwarding tables. We present results from experiments on real-world benchmarks that quantify performance in terms of compilation time and forwarding table size