Idea

The syntactic component defines:

  • An alphabet of symbols (propositional variables, connectives, quantifiers)
  • Formation rules for constructing well-formed formulas
  • Structural properties of the language (decidability of well-formedness)

Structure

The syntax is defined relative to a signature containing function symbols and relation symbols with fixed arities.

Alphabet

  • Variable:
  • Logical connectives:
  • Quantifiers:
  • Equality: (typically treated as a logical constant)
  • Auxiliary symbols: parentheses
  • Relation variables: in second- and higher-order systems

Type system

We have base types ( for individuals, for truth values) and an arrow constructor for functions.

In higher-order logic the system is close to the typing system of Simply-Typed Lambda Calculus.

In first-order settings,

And in second order settings

The Signature () and Context ()

To write typing judgments, we need a context which we factor into:

  • : A global signature of constants, which includes function symbols, relation symbols, and logical connectives.
  • : A local context mapping variables to their types (e.g., ).

Because we are currying, logical connectives and quantifiers are just constants in with specific type signatures:

  • Connectives:
  • Equality:
    • (Polymorphic equality for any type )
  • Quantifiers:

Terms

Variables and Constants:

Application: Instead of a function taking a list of terms , it takes one term at a time.

How this works for relations: If , applying to gives . Applying that to gives . This is an atomic formula!

Abstraction: To bind variables, we need use the higher-order abstract syntax approach and turn all variable bindings into a lambda abstraction.

Syntactic Sugar

Traditional syntax can be seen as “syntactic sugar” over these curried applications:

  • is sugar for
  • is sugar for
  • is sugar for

By framing as a function that takes a predicate (a function from ) and returns a , you completely eliminate the need for special binding rules for quantifiers—the lambda abstraction handles all the binding mechanically.

**

Would you like me to show you how standard logical deduction rules (like Modus Ponens or Universal Instantiation) are formalized using this same curried syntax?