---
title: Orthologic with Function Symbols
url: https://www.emergentmind.com/topics/orthologic-with-function-symbols
type: topic
---

# Orthologic with Function Symbols

Searching arXiv for the cited paper and closely related work to ground the article.
Orthologic with function symbols is a proof-theoretic and algorithmic framework for subtyping in type languages that combine intersection, union, and negation with parameterized type constructors of mixed variance. In this setting, types are interpreted as terms of free ortholattices extended by function symbols, and subtyping is identified with the ortholattice order. The framework developed in "Orthologic Type Systems" formalizes monotonic and antimonotonic constructors, gives a sound and complete sequent calculus for subtyping inequalities under assumptions, establishes partial cut elimination, and derives an $O(n^2(1+m))$ decision procedure for provability under $m$ assumptions together with an $O(n^2)$ normalization algorithm to minimal canonical form [2507.10482].

## 1. Orthologic as a basis for subtyping

Orthologic provides the ambient algebraic structure. Its signature contains binary connectives $\land$ and $\lor$, unary orthocomplement $\neg$, and constants $\bot$ and $\top$. Terms are built from variables, constants, these connectives, and, in the extended setting, function symbols. Subtyping is the lattice order: $x \le y$ iff $x = x \land y$, equivalently $y = x \lor y$ under the lattice axioms [2507.10482].

The semantic structures are ortholattices: bounded lattices equipped with an orthocomplement satisfying involution and De Morgan laws. The laws used include commutativity, associativity, idempotence, absorption, bounds, double negation, excluded middle, contradiction, and De Morgan dualities. A central feature is that ortholattices are generally non-distributive: distributivity laws such as $x \land (y \lor z) = (x \land y) \lor (x \land z)$ do not hold in general [2507.10482].

This non-distributive basis is decisive for the type-theoretic interpretation. Intersection types are modeled by $\land$, union types by $\lor$, and negation types by $\neg$. Subtyping $A \le B$ is logical entailment in the ortholattice order. Because distributivity is not assumed, the framework avoids identifications that are valid in Boolean algebras but unsound for many richer type constructors. This places orthologic between purely lattice-theoretic subtyping and fully Boolean approaches, preserving complement-like structure without inheriting the full complexity and normalization blow-up associated with distributive Boolean reasoning [2507.10482].

## 2. Function symbols and variance-sensitive constructors

The extension with function symbols is designed to model type constructors such as records, pairs, functions, and algebraic data types. A function symbol is annotated as $F^{i,j,k}$, where $i$ arguments are invariant, $j$ are monotone (covariant), and $k$ are antimonotone (contravariant). Arguments are grouped as $x_1,\ldots,x_i$ for invariants, $y_1,\ldots,y_j$ for covariants, and $z_1,\ldots,z_k$ for contravariants [2507.10482].

The governing law is monotonicity with variance:
$$
\forall n\in\{1,\ldots,j\},\ y_n\le y'_n
\ \wedge\
\forall m\in\{1,\ldots,k\},\ z'_m\le z_m
\ \Longrightarrow\
F(\vec x,\vec y,\vec z)\ \le\ F(\vec x,\vec y',\vec z').
$$
An equivalent equational form is
$$
F(\vec x,\vec y,\vec z)\ \le\ F\bigl(\vec x,\ \vec y\lor \vec y',\ \vec z\land \vec z'\bigr).
$$
The equivalence of these formulations ensures that ortholattices with function symbols defined by the equational law form a variety [2507.10482].

The intended interpretations follow standard variance patterns. A unary covariant constructor can represent a field wrapper or container-like operation. A binary constructor covariant in both arguments can represent product-like types. A binary constructor contravariant in the first argument and covariant in the second models function space: from $A_2 \le A_1$ and $B_1 \le B_2$, one derives $\mathrm{Arr}(A_1,B_1) \le \mathrm{Arr}(A_2,B_2)$ [2507.10482].

The framework treats constructors under an open-world assumption: no equations are assumed beyond ortholattice laws and variance axioms. This suggests a deliberately weak but robust semantic interface. A plausible implication is that the approach supports a broad class of user-defined constructors without committing to distributive identities or representation-specific algebraic equations.

## 3. Sequent calculus and proof theory

The proof system uses a two-formula sequent calculus in which each occurrence is annotated as left or right. An annotated term is written $S^L$ or $T^R$, and a sequent is an unordered pair of annotated terms. The baseline system includes identity, $\bot$-left and $\top$-right axioms, introduction rules for $\land$, $\lor$, and $\neg$, a structural rule Replace, Cut, and an Axiom rule for background subtyping assumptions [2507.10482].

The connective rules are tuned to the two-formula format. For example, LeftAnd derives $\Gamma,(S\land T)^L$ from $\Gamma,S^L$, whereas RightAnd derives $\Gamma,(S\land T)^R$ from both $\Gamma,S^R$ and $\Gamma,T^R$. Negation switches polarity:
$$
\infer[\mathrm{LeftNot}]{\Gamma,\,(\neg S)^L}{\Gamma,\,S^R}
\qquad
\infer[\mathrm{RightNot}]{\Gamma,\,(\neg S)^R}{\Gamma,\,S^L}.
$$
Replace encodes weakening and contraction in this restricted setting:
$$
\infer[\mathrm{Replace}]{\Gamma,\,\Delta}{\Gamma,\,\Gamma}.
$$
Exchange is implicit because sequents are unordered pairs [2507.10482].

Function symbols are handled by a single variance-aware inference rule. For a constructor $F^{i,j,k}$, one derives
$$
F(\vec S_x,\vec S_y,\vec S_z)^L,\ F(\vec T_x,\vec T_y,\vec T_z)^R
$$
from premises expressing equality on invariant arguments, monotone order on covariant arguments, and reversed order on contravariant arguments. Thus, each invariant $x_i$ requires both $S_{x_i}^L,T_{x_i}^R$ and $T_{x_i}^L,S_{x_i}^R$; each covariant $y_j$ requires $S_{y_j}^L,T_{y_j}^R$; and each contravariant $z_k$ requires $T_{z_k}^L,S_{z_k}^R$ [2507.10482].

This calculus, called SCPlus in the full presentation, is sound and complete for ortholattices with function symbols under finite axiom sets. Its design enforces a strong subterm discipline: all rules except Cut and Axiom satisfy a subterm property. That proof-theoretic economy becomes the basis for both cut elimination and algorithmic decidability [2507.10482].

## 4. Partial cut elimination and the subterm property

A central theorem is partial cut elimination. The cut-free variant CFPlus removes Cut and Axiom and replaces them with AxiomCut:
$$
\infer[\mathrm{AxiomCut}\ (S\le T\ \in A)]{\Gamma,\,\Delta}{\Gamma,\,T^R & T^L,\,\Delta}.
$$
The theorem states that a sequent is provable in SCPlus if and only if it is provable in CFPlus [2507.10482].

The proof proceeds by commuting Cut upward through the proof tree until it can be eliminated or transformed into AxiomCut. This includes commuting Cut past negation rules, Replace, and, crucially, the function-symbol rule. In the latter case, a cut on a term headed by $F$ is distributed to cuts on the corresponding argument premises according to variance, after which the $F$-rule is re-applied. The induction measure decreases through reductions in cut height or cut formula complexity [2507.10482].

The result is partial rather than full. Arbitrary cuts disappear, but cuts induced by assumptions remain. The framework explicitly identifies this as essential: AxiomCut is the only permitted source of non-subformula reasoning. Full elimination of axiom cuts is not available in this two-formula setting [2507.10482].

The proof-theoretic significance is immediate. Once unrestricted Cut is removed, proofs involve only subterms of the goal and of the axiom terms. This subterm property bounds the space of possible sequents and makes exhaustive proof search polynomially manageable. In that sense, partial cut elimination is not merely a metatheorem but the structural hinge connecting semantics, proof theory, and decision procedures.

## 5. Decision procedure under assumptions

The subtyping problem is formulated as follows: given a finite set of axioms
$$
A = \{(a_1 \le b_1), \ldots, (a_m \le b_m)\}
$$
and a target inequality $S \le T$, decide whether $S \le_A T$ holds in all ortholattices with function symbols satisfying $A$ [2507.10482].

The algorithm reduces provability in CFPlus to propositional Horn entailment. First, one constructs the set $\Sigma$ of all sequents over annotated subterms that may appear in proofs, restricting attention to subterms of $S$, $T$, and the axiom terms. Because sequents are pairs of annotated subterms, $|\Sigma| = O(n^2)$, where $n$ is the total size of the input formulas [2507.10482].

For each rule instance whose premises and conclusion lie in $\Sigma$, a Horn clause of the form “conclusion $\leftarrow$ premises” is generated. AxiomCut contributes clauses parameterized by the finite axiom set. The number of clauses is
$$
O(|\Sigma|(9+m)) = O(n^2(1+m)),
$$
since there are at most 9 core rules plus one axiom-cut instance per axiom. The target sequent $S^L,T^R$ is then decided by linear-time unit propagation for Horn clause satisfiability. Because Horn entailment is linear in the clause-set size, the overall complexity is $O(n^2(1+m))$ [2507.10482].

The significance of this reduction is twofold. First, it yields an efficiently decidable subtyping relation for a language including intersection, union, negation, and mixed-variance constructors. Second, the cost depends quadratically on formula size and linearly on the number of assumptions, rather than exhibiting the exponential behavior associated with distributive Boolean normalization. The framework therefore combines relatively expressive connectives with predictable proof search.

A representative example uses the function constructor $\mathrm{Arr}$, contravariant in its first argument and covariant in its second. To show
$$
\mathrm{Arr}(\mathrm{Int},\top) \le \mathrm{Arr}(\top,\top),
$$
the Horn encoding reflects the premises required by the $F$-rule: $\top^L,\mathrm{Int}^R$ for contravariance, relying on $\mathrm{Int}\le\top$, and $\top^L,\top^R$ by identity. Unit propagation then derives the target sequent [2507.10482].

## 6. Normalization and minimal canonical forms

The framework also provides a polynomial-time normalization procedure producing minimal canonical forms. A term $T$ is minimal if there is no equivalent term $T'$ with strictly smaller size. A normalizer $N$ must satisfy three conditions: $N(S)\equiv S$, equivalence implies equality of normal forms, and $N(S)$ is minimal [2507.10482].

Normal forms are characterized inductively. Variables, $\bot$, and $\top$ are normal. So are function applications $F(T_1,\ldots,T_n)$ provided each argument is normal. For finite joins $T_1\lor\cdots\lor T_k$, every $T_i$ must be normal, no $T_i$ may be below another $T_j$, and if any $T_i$ is itself a meet, then no conjunct of that meet may already be below the whole join. Meets are characterized dually [2507.10482].

The algorithm is composed of four passes:
$$
N = \eta \circ \zeta \circ \beta \circ \delta.
$$
The $\delta$ pass pushes negation inward to a pseudo-negation-normal form using De Morgan laws and double-negation elimination, while preserving function applications. For each function symbol $F$, a symbol $\overline{F}$ is introduced that flips variance so that expressions of the form $\neg F(\vec U)$ can be treated uniformly after negation pushing [2507.10482].

The $\zeta$ pass performs local pruning inside joins and meets. In a disjunction, if a disjunct is a meet and some conjunct is already below the entire disjunction, that meet can be replaced by the conjunct, strictly shrinking the term. The $\eta$ pass then performs antichain reduction, removing any disjunct subsumed by another; conjunctions are treated dually [2507.10482].

Finally, the $\beta$ pass collapses evident tautologies and contradictions:
- $\beta(S\lor T)=\top$ if $\delta(\neg S)\le S\lor T$ or $\delta(\neg T)\le S\lor T$;
- $\beta(S\land T)=\bot$ if $\delta(\neg S)\le S\land T$ or $\delta(\neg T)\le S\land T$.

Because all required subtyping checks are confined to subterms of the input and can be discharged by the quadratic proof procedure, the full normalizer runs in $O(n^2)$ time and yields minimal canonical forms [2507.10482].

This normalization discipline is especially important in the presence of negation and non-distributivity. Rather than expanding terms into exponentially large DNF- or CNF-like representations, the algorithm preserves a compact canonical structure compatible with orthologic semantics.

## 7. Type-theoretic reading, examples, and comparative position

The framework is explicitly motivated by type systems with intersection, union, and negation in the presence of subtyping assumptions. Types are terms of free ortholattices with function symbols, and constructors receive variance declarations reflecting their intended subtyping behavior [2507.10482].

Several examples illustrate the interpretation. For records, each field label $s$ can be modeled by a unary covariant constructor $R_s[+]$, and a multi-field record such as $\{ \mathrm{foo}:\mathrm{String}, \mathrm{bar}:\mathrm{Int} \}$ is represented as $R_{\mathrm{foo}}(\mathrm{String}) \land R_{\mathrm{bar}}(\mathrm{Int})$. Width, depth, and permutation subtyping follow from ortholattice laws and constructor monotonicity. For instance,
$$
R_{\mathrm{foo}}(\mathrm{String}) \land R_{\mathrm{bar}}(\mathrm{Int})
\le
R_{\mathrm{foo}}(\mathrm{String}),
$$
and
$$
R_{\mathrm{foo}}(\mathrm{String}) \le R_{\mathrm{foo}}(\top)
$$
by covariance in the field type position [2507.10482].

For function types, a binary constructor $\mathrm{Arr}$ is contravariant in its domain and covariant in its codomain. Thus, from $A_2 \le A_1$ and $B_1 \le B_2$, the calculus derives
$$
\mathrm{Arr}(A_1,B_1) \le \mathrm{Arr}(A_2,B_2).
$$
For product types, a binary covariant constructor $\mathrm{Pair}$ gives the expected monotone behavior in both arguments. Negation types are interpreted ortholattice-theoretically: $\neg T$ means “not $T$,” and De Morgan laws hold. Examples include $\neg\mathrm{Null}$ as a non-null type and $\neg\{\mathrm{bar}:\mathrm{Any}\}$ as the type of records without a bar field [2507.10482].

The framework also records non-derivability that would be forced by distributivity. For example,
$$
(\mathrm{Arr}(\mathrm{Int},\mathrm{Int}) \land \mathrm{Arr}(\mathrm{Bool},\mathrm{Bool}))
\le
\mathrm{Arr}(\mathrm{Int}\lor\mathrm{Bool}, \mathrm{Int}\land\mathrm{Bool})
$$
is not provable in general. This is presented as consistent with practical intersection type systems where such conjunctive function subtyping fails. The point is methodological: the calculus captures monotonicity constraints exactly, without importing distributive principles that become unsound in richer constructor settings [2507.10482].

The comparison with Boolean algebra is explicit. Boolean entailment is coNP-complete, and Boolean normal forms can be exponentially larger. By contrast, orthologic retains involution, De Morgan duality, and complements while admitting quadratic algorithms for decision and normalization. The comparison with systems such as BCD, MLsub, and System F-sub is likewise framed around distributivity and constructor equations: many such systems adopt identities like $(A\to B)\land(C\to D)=(A\lor C)\to(B\land D)$ in restricted syntactic regimes, whereas orthologic with function symbols rejects these as generally unsound and instead supports open-world monotonic constructors with polynomial-time reasoning [2507.10482].

A common misconception is that the presence of negation should force fully Boolean behavior. In this framework, negation is orthocomplementation in an ortholattice, not classical Boolean complementation in a distributive lattice. Another is that proof-theoretic tractability requires eliminating assumptions or restricting constructors to pure covariance. The system shows the opposite: finite background assumptions are retained through AxiomCut, and mixed-variance constructors are incorporated directly, yet provability remains polynomial [2507.10482].

Source: https://www.emergentmind.com/topics/orthologic-with-function-symbols