Tootfinder

From Press Progress
Thank you for signing on to push back against SLAPP (Strategic Lawsuit Against Public Participation) lawsuits that seek to silence dissent and critique of those in power.
This fight for us is personal. We are still at the center of one of the longest and most expensive media trials in Canadian history.
Lawsuits like this are designed to slow down the important work non-profit newsrooms like ours do by tying up our funds in lengthy lawsuits.
We won’…

Defend Canadian Journalism – Donate Form
Support Our Journalism Defence Fund PressProgress is at the centre of what could be one of the biggest, longest and most expensive media trials in recent Canadian history. A former star candidate for Jason Kenney’s United Conservative Party has launched a multimillion-dollar lawsuit against PressProgress and other trusted news organizations. This case has serious implications […]

VirtualSet: Typed Ontology Worlds as an LLM Generation Target for Grounded Queries and Guarded Decisions
Qunhui Zhang
https://arxiv.org/abs/2607.18821 https://arxiv.org/pdf/2607.18821 https://arxiv.org/html/2607.18821
arXiv:2607.18821v1 Announce Type: new
Abstract: Large language models increasingly read and act on enterprise data, but SQL gives a late error signal: hallucinated fields or relations can execute and return plausible wrong answers, while incorrect writes cannot be safely assessed after execution. We present VirtualSet, a live, receiver-typed ontology-world interface and generation target for LLMs. Instead of SQL, the model emits set expressions over entity-edge worlds. Generic Constraint Projection (GCP) checks expressions before execution, while future this preserves concrete receiver types through collection chains, turning invalid fields, edges, receivers, and actions into token-anchored type errors. Type-clean reads use a SQL fast path or bounded stream interpretation, with a parity oracle checking both paths over the exercised operator space. The same substrate supports guarded decisions: actions run first in a simulated world, and world-change events require external approval before actualization. On BIRD, we lift relational schemas into typed worlds and compare VirtualSet with direct SQL while holding the model, evidence, values, zero-shot setting, timeout, glossary, repair/voting, and grader constant where possible. On a frozen 1,072-question split, VirtualSet achieves 67.5% accuracy versus 63.5% for glossary-matched direct SQL with repair and voting ( 4.0 points; McNemar exact p = 0.00117) using deepseek-reasoner. Full-corpus analysis finds no engine mis-computation of a type-clean expression; remaining errors arise from model semantics or gold defects. In a 30-body guard corpus, the write chain intercepts 20/20 hallucinated action bodies with zero false positives. VirtualSet thus remains competitive on SQL's home benchmark while providing pre-execution semantics for guarded decisions.
toXiv_bot_toot

Am starting a series of blog posts on design and implementation of a AI Harness - based on the one from Fisk AI https://choria.io/fisk-ai
Will cover all the bits from what it is (todays post) to cover the loop, tools, memory, context, session history and more.
First post here

EVOLVE: Efficient Learned Volume Compression with Variable-Rate Encoding on a Cross-Domain Database
Kaiyuan Tang, Maizhe Yang, Chaoli Wang
https://arxiv.org/abs/2607.18187 https://arxiv.org/pdf/2607.18187 https://arxiv.org/html/2607.18187
arXiv:2607.18187v1 Announce Type: new
Abstract: Large-scale scientific simulations generate volumetric data at rates that far outpace advances in storage and network bandwidth, making effective lossy compression increasingly critical. However, conventional compressors often struggle to preserve fine structural details at high compression ratios (CRs), and implicit neural representations (INRs) require costly per-volume optimization and produce models with fixed CRs. To respond, we present EVOLVE, an autoencoder (AE)-based volume-compression framework that targets high CRs for offline compression, with three key contributions. First, we construct a large-scale cross-domain database of 6,376 volumes from 21 scientific simulations, curated via perceptual hashing to ensure diversity, enabling the optimized model to extract features that generalize across volumes within the covered scientific simulation domains. Second, we reexamine the design space of AE-based compressors and incorporate several macro- and micro-designs into a vanilla AE to develop EVOLVE, which substantially improves the expressive power and compression capability. Third, we develop a learnable gain mechanism with a three-stage training strategy to enable variable-rate encoding, allowing a single model to support continuous CR adjustment at inference time. Experiments on multiple unseen scientific simulation datasets demonstrate that EVOLVE achieves substantially higher CRs than conventional compressors at comparable reconstruction quality, while delivering compression speeds that are orders of magnitude faster than INR-based methods, highlighting its promise as a strong alternative for compressing scientific data. The code, model weights, and results are available on our project page at https://evolve-vis.github.io.
toXiv_bot_toot

BART Online Open-Source Sequence Toolbox for Computational MRI
Daniel Mackner, Philip Schaten, Markus Huemer, Viktoria Buchegger, Moritz Blumenthal, Xiaoqing Wang, Martin Uecker
https://arxiv.org/abs/2607.19099 https://arxiv.org/pdf/2607.19099 https://arxiv.org/html/2607.19099
arXiv:2607.19099v1 Announce Type: new
Abstract: Purpose In advanced computational MRI techniques, acquisition and reconstruction techniques are jointly designed. For reproducibility, it is therefore important to provide an open implementation of both. At the same time, any use in a clinical environment usually requires a close integration with the MRI scanner. Ensuring long-time reproducibility and maintenance then poses additional challenges. In this work, we aim to provide a fully integrated open-source framework that can meet these demands.
Methods A software framework to develop pulse sequences is added to the BART toolbox. In addition, a vendor-specific driver sequence is developed that can be used to run the sequence on a clinical MRI scanner enabling online adjustment of all relevant sequence parameters. Using the Pulseq format, the exact same sequence can also be reproduced offline. As proof-of-concept, quantitative MRI methods for T1 and joint water/fat R2*, B0 mapping using radial FLASH and model-based reconstruction are implemented in the proposed framework. Consistency between online and offline acquisition is validated in phantom and in vivo experiments.
Results Quantitative MRI methods consisting of acquisition and reconstruction were successfully implemented in BART. Acquisition parameters and FOV can be adapted online on a clinical MRI system. Quantitative parameter maps from model-based reconstruction agree for online and offline regenerated Pulseq acquisitions.
Conclusion This work enables reproducibility of advanced computational MRI methods within a comprehensive end-to-end open-source framework.
toXiv_bot_toot

Uniform-Loss Automated Market Making for Prediction Markets
Ciamac C. Moallemi, Dan Robinson, Brian Zhu
https://arxiv.org/abs/2607.17428 https://arxiv.org/pdf/2607.17428 https://arxiv.org/html/2607.17428
arXiv:2607.17428v1 Announce Type: new
Abstract: Automated market makers (AMMs) for prediction markets descend from market scoring rules, where a mechanism operator subsidizes a market to aggregate beliefs about uncertain events. The existing literature has focused on bounding the total worst-case loss to the subsidizer, but has not addressed how that loss is distributed across price states or over time. We use the framework of loss-versus-rebalancing (LVR) to study this distribution and introduce \textit{uniform AMMs}, defined by the property that instantaneous LVR is proportional to pool value and independent of the current token price. In a static setting, we show that for a broad class of \textit{win-martingales} -- processes that converge to 0 or 1 at a fixed resolution time -- there exists a pricing function that achieves uniform LVR under that process, and conversely, that any sufficiently regular pricing function induces a win-martingale under which it is uniform. We then extend the framework to dynamic liquidity management, showing that liquidity levels can be adjusted over time to implement a prescribed target expected cumulative loss schedule. This theory is illustrated with canonical examples of win-martingales and pricing functions. Our results can inform AMM designers and liquidity providers on how the inevitable cost of subsidizing price discovery can be shaped and controlled across both price and time.
toXiv_bot_toot

High-Level Synthesis of Efficient Pipelines with Visibility Control
Jungin Rhee, Minseong Jang, Jaewoo Kim, Jeehoon Kang
https://arxiv.org/abs/2607.18765 https://arxiv.org/pdf/2607.18765 https://arxiv.org/html/2607.18765
arXiv:2607.18765v1 Announce Type: new
Abstract: High-level synthesis (HLS) raises the abstraction of hardware design from concurrent register-transfer level (RTL) programs to sequential programs. Among the forms of parallelism HLS exploits, pipelining demands fine-grained control over pipeline structure and hazard resolution to achieve competitive power, performance, and area (PPA). However, existing tools either lack such control or sacrifice sequential semantics to provide it.
We present an HLS tool that embeds fine-grained pipeline control in a sequential programming model, enabling rapid design-space exploration. The tool builds on visibility control, a novel programming abstraction that unifies hazard resolution strategies including stalling, bypassing, speculation, deferred commit, and register renaming. We evaluate on in-order RISC-V cores, histograms, and an AES accelerator. On RISC-V cores, we implement stall, bypass, speculation, and register renaming; on histograms, we implement scheduling strategies that previously required RTL or concurrent programming models. Compiled pipelines outperform HLS tools with sequential semantics and achieve PPA comparable to hand-written RTL.
toXiv_bot_toot

For the 22nd birthday of our free #MMOG #Pardus, we implemented a new NPC, the Cyborg Corebreaker, and new advanced skills. ...we are back after some years of development pause. 😅

ETAS: An Effect-Typed Language for Agent Systems
Huiri Tan, Yikun Wang, Puyang Zhang, Shangyu Li, Jiasi Shen
https://arxiv.org/abs/2607.17780 https://arxiv.org/pdf/2607.17780 https://arxiv.org/html/2607.17780
arXiv:2607.17780v1 Announce Type: new
Abstract: ETAS is a programming language for agent systems that treats model-backed agents, tool calls, prompts, typed memory, human approvals, policies, and execution traces as semantic program elements rather than library conventions. It separates deterministic computation from agentic nondeterminism and externally visible actions while preserving a direct programming style.
We present the core design of ETAS. Its static semantics assigns ordinary types through spec conformance and tracks each computation with two behavioral indices: an escaping effect row and a persistent abstraction of the typed action trace it may request. Specs form a terminating compile-time constraint calculus: type specs provide evidence for polymorphism and resource facts, callable specs constrain function and stage shapes, and trace specs express allow, deny, and temporal constraints. Typing checks requested traces against compiled monitors and emits residual obligations when dynamic resources preclude a complete static proof. The dynamic semantics distinguish requested, handled, denied, and committed events; handlers interpret typed actions without making their requests invisible to authorization or audit.
We formalize a core calculus and state preservation, progress, type/effect soundness, handler trace-transparency, and policy safety. We also implement ETAS in Rust with a command-line interface, typed HIR checks, effect and policy diagnostics, handler checks, and trace-aware execution hooks. ETAS provides a programming-language foundation for reasoning about authorization, nondeterminism, recovery, and audit evidence before and during agent execution.
toXiv_bot_toot