Medical Decision Logic

Abstract Background: Inflammatory breast cancer (IBC) is a rare and aggressive form of breast cancer with a distinct clinical presentation and poor prognosis. Diagnostic ambiguity remains a challenge, and recent literature has proposed structured criteria to improve case classification. Methods: We conducted a retrospective chart review of 83 patients diagnosed with IBC and 83 patients with non-inflammatory breast cancer (non-IBC), seen at the University of Texas Southwestern Medical Center as part of the Dallas Metastatic Cancer Study. Each IBC case was evaluated using a structured scoring system adapted from the diagnostic guidelines proposed by Omarini et al. (2022) to assess the degree of conformity to established IBC features. Clinical and pathological characteristics were compared across groups using appropriate statistical tests. Results: Our findings reinforce several established associations in the literature. Compared to non-IBC patients, those with IBC exhibited significantly higher Ki-67 proliferation indices (1.42-fold increase, p<0.0001, Mann-Whitney U test), greater number of metastatic sites (2-fold increase, p<0.0001, Mann-Whitney U test), and higher clinical stage at diagnosis (p = 0.04, Chi-square test). IBC cases were also associated with more aggressive disease biology as they were more likely to be ER negative (p = 0.003, Fisher test) and PR negative (p = 0.0184, Fisher test). Notably, we observed a novel pattern: IBC was significantly associated with specific metastatic sites, particularly the brain (4.5 times more likely in IBC patients, p<0.0001, Chi-square test) and lungs (2.08 times more likely in IBC, p = 0.0028, Chi-square test), suggesting a potentially distinct metastatic tropism. Conclusions: This study supports the diagnostic utility of a structured scoring system for IBC and confirms key clinical and molecular trends observed in prior research. The novel association with specific metastatic sites warrants further investigation and may inform future efforts in IBC classification and management. Citation Format: C. M. Atallah, A. Varner, C. J. Kang, P. Gowda, K. Anderson, D. Tovar, R. Morey, C. Hauer, R. Sridharan, S. Huang, K. Lei, S. M. Reddy, H. L. McArthur, J. Maués, C. Hodgdon, B. Zhang, X. Zhang, B. Lim, I. S. Chan. Evaluating clinical and molecular correlates of Inflammatory Breast Cancer using a scoring system-based chart review [abstract]. In: Proceedings of the San Antonio Breast Cancer Symposium 2025; 2025 Dec 9-12; San Antonio, TX. Philadelphia (PA): AACR; Clin Cancer Res 2026;32(4 Suppl):Abstract nr PS1-09-14.

We describe a new method of synthesizing a formal model for real-time systems from scenarios. Scenarios, formally defined as Timed Event Sequences, together with mode graphs are used to describe behaviors of real-time systems. Given a set of Timed Event Sequences and a mode graph, our synthesis method constructs a minimal, acyclic, timed automaton that models the specified aspects of the system. We formalize criteria that a set of scenarios must satisfy in order to make it feasible to generate such an automaton.

The LogicBlox system aims to reduce the complexity of software development for modern applications which enhance and automate decision-making and enable their users to evolve their capabilities via a ``self-service'' model. Our perspective in this area is informed by over twenty years of experience building dozens of mission-critical enterprise applications that are in use by hundreds of large enterprises across industries such as retail, telecommunications, banking, and government. We designed and built LogicBlox to be the system we wished we had when developing those applications. In this paper, we discuss the design considerations behind the LogicBlox system and give an overview of its implementation, highlighting innovative aspects. These include: LogiQL, a unified and declarative language based on Datalog; the use of purely functional data structures; novel join processing strategies; advanced incremental maintenance and live programming facilities; a novel concurrency control scheme; and built-in support for prescriptive and predictive analytics.

Open Source Software (OSS) components form the basis for many software systems. While the use of OSS components accelerates development, client systems must comply with the license terms of the OSS components that they use. Failure to do so exposes client system distributors to possible litigation from copyright holders. Yet despite the importance of license compliance, tool support for license compliance assessment is lacking. In this paper, we propose an approach to construct and analyze the Concrete Build Dependency Graph (CBDG) of a software system by tracing system calls that occur at build-time. Through a case study of seven open source systems, we show that the constructed CBDGs: (1) accurately classify sources as included in or excluded from deliverables with 88%-100% precision and 98%-100% recall, and (2) can uncover license compliance inconsistencies in real software systems -- two of which prompted code fixes in the CUPS and FFmpeg systems.

We look at generating plans that answer queries over restricted interfaces, making use of information about source integrity constraints, access restrictions, and access costs. Our method can exploit the integrity constraints to find low-cost access plans even when there is no direct access to relations appearing in the query. The key idea of our method is to move from a search for a plan to a search for a proof that a query is answerable, and then \emph{generate a plan from a proof}. Discovery of one proof allows us to find a single plan that answers the query; exploration of several alternative proofs allows us to find low-cost plans. We start by overviewing a correspondence between proofs and restricted-interface plans in the context of arbitrary first-order constraints, based on interpolation. The correspondence clarifies the connection between preservation and interpolation theorems and reformulation problems, while generalizing it in several dimensions. We then provide direct plan-generation algorithms for schemas based on tuple-generating dependencies. Finally, we show how the direct plan-generation approach can be adapted to take into account the cost of plans.

I will present the LogicBlox database and describe business applications that use it. The LogicBlox database marries declarative programming (logic-based specifications) with cloud deployment over large datasets. The database is programmed with a variant of the Datalog programming language. The flexibility of declarative programming allows us to integrate both traditional business application development and "probabilistic" applications: machine-learning or search-based solutions, as required by the domain. Our approach aims to eliminate the distance between prototyping and deployed, high-performance implementations. I will discuss real customer applications and actual deployment instances that elastically adapt to several thousands of machines.

In a recent paper by Hellerstein [15], a tight relationship was conjectured between the number of strata of a Datalog${}^\neg$ program and the number of "coordination stages" required for its distributed computation. Indeed, Ameloot et al. [9] showed that a query can be computed by a coordination-free relational transducer network iff it is monotone, thus answering in the affirmative a variant of Hellerstein's CALM conjecture, based on a particular definition of coordination-free computation. In this paper, we present three additional models for declarative networking. In these variants, relational transducers have limited access to the way data is distributed. This variation allows transducer networks to compute more queries in a coordination-free manner: e.g., a transducer can check whether a ground atom $A$ over the input schema is in the "scope" of the local node, and then send either $A$ or $\neg A$ to other nodes. We show the surprising result that the query given by the well-founded semantics of the unstratifiable win-move program is coordination-free in some of the models we consider. We also show that the original transducer network model [9] and our variants form a strict hierarchy of classes of coordination-free queries. Finally, we identify different syntactic fragments of Datalog${}^{\neg\neg}_{\forall}$, called semi-monotone programs, which can be used as declarative network programming languages, whose distributed computation is guaranteed to be eventually consistent and coordination-free.

We are witnessing an exciting revival of interest in recursive Datalog queries in a variety of emerging application domains such as data integration, information extraction, networking, program analysis, security, and cloud computing. This tutorial briefly reviews the Datalog language and recursive query processing and optimization techniques, then discusses applications of Datalog in three application domains: data integration, declarative networking, and program analysis. Throughout the tutorial, we use LogicBlox, a commercial Datalog engine for enterprise software systems, to allow the audience to walk through code examples presented in the tutorial.

Given a set of Datalog rules, facts, and a query, answers to the query can be inferred bottom-up starting with the facts or top-down starting with the query. The dominant strategies to improve the performance of answering queries are reusing answers to subqueries for top-down methods, and transforming rules based on demand from the query, such as the well-known magic sets transformation, for bottom-up methods. However, the performance of these strategies vary drastically, and the most effective method has remained unknown.

Variance allows the safe integration of parametric and subtype polymorphism. Two flavors of variance, definition-site versus use-site variance, have been studied and have had their merits hotly debated. Definition-site variance (as in Scala and C#) offers simple type-instantiation rules, but causes fractured definitions of naturally invariant classes; Use-site variance (as in Java) offers simplicity in class definitions, yet complex type-instantiation rules that elude most programmers. We present a unifying framework for reasoning about variance. Our framework is quite simple and entirely denotational, that is, it evokes directly the definition of variance with a small core calculus that does not depend on specific type systems. This general framework can have multiple applications to combine the best of both worlds: for instance, it can be used to add use-site variance annotations to the Scala type system. We show one such application in detail: we extend the Java type system with a mechanism that modularly infers the definition-site variance of type parameters, while allowing use-site variance annotations on any type-instantiation. Applying our technique to six Java generic libraries (including the Java core library) shows that 20-58 (depending on the library) of generic definitions are inferred to have single-variance; 8-63% of method signatures can be relaxed through this inference, and up to 91% of existing wildcard annotations are unnecessary and can be elided.