
Graph Representations for Higher-Order Logic and Theorem Proving (2019) - brzozowski
https://arxiv.org/abs/1905.10006
======
westurner
ONNX (and maybe RIF) are worth mentioning.

ONNX: [https://onnx.ai/](https://onnx.ai/) :

> _ONNX is an open format built to represent machine learning models. ONNX
> defines a common set of operators - the building blocks of machine learning
> and deep learning models - and a common file format to enable AI developers
> to use models with a variety of frameworks, tools, runtimes, and compilers_

RIF (~FOL):
[https://en.wikipedia.org/wiki/Rule_Interchange_Format](https://en.wikipedia.org/wiki/Rule_Interchange_Format)

Datalog (not Turing-complete):
[https://en.wikipedia.org/wiki/Datalog](https://en.wikipedia.org/wiki/Datalog)

------
westurner
HOList Benchmark:
[https://sites.google.com/view/holist/home](https://sites.google.com/view/holist/home)

"HOList: An Environment for Machine Learning of Higher-Order Theorem Proving"
(2019) [https://arxiv.org/abs/1904.03241](https://arxiv.org/abs/1904.03241)

> Abstract: _We present an environment, benchmark, and deep learning driven
> automated theorem prover for higher-order logic. Higher-order interactive
> theorem provers enable the formalization of arbitrary mathematical theories
> and thereby present an interesting, open-ended challenge for deep learning.
> We provide an open-source framework based on the HOL Light theorem prover
> that can be used as a reinforcement learning environment. HOL Light comes
> with a broad coverage of basic mathematical theorems on calculus and the
> formal proof of the Kepler conjecture, from which we derive a challenging
> benchmark for automated reasoning. We also present a deep reinforcement
> learning driven automated theorem prover, DeepHOL, with strong initial
> results on this benchmark._

------
thomasahle
I wonder why they don't mention any work based on transformer architectures?
The recent work on solving differential equations based on expressions in
reverse polish notation seemed like a reasonable idea to apply to theorem
proving as well.

Really cool work though!

~~~
Tainnor
Solving differential equations symbolically[^1] is a classic pattern matching
problem though. It takes a lot of practice recognising which equations can be
solved with which method/heuristic, but in the end, the available heuristics
are somewhat limited in number and so it's not unreasonable that an ML model
would perform well here. Notice that you will still need to actually check
your result in some way or the other, because ML models can generate false
positives and you really don't want that in maths; so it's not that you're
_replacing_ rule-based systems, you're just augmenting them with other
approaches (and of course, verifying the solution to a differential equation
is basically a solved problem in symbolic analysis, since taking derivatives
is a simple rule-based procedure[^2]).

I think theorem proving is much different. The space of possible heuristics
you may apply to a proof is basically infinite. It can take a tremendous
amount of creativity and intuition to come up with a complicated and novel
proof. While I can see ML models being of use for simpler proofs or lemmas
within bigger proofs (such as simple epsilon-delta proofs etc.), I have a hard
time imagining that they will really be able to do real proofs anytime soon.

[^1]: I emphasise "symbolically" because it is my understanding that outside
of simple situations and university lectures, most people don't bother with
that, instead solving differential equations numerically.

[^2] There are some subtleties around the fact that, afaik, deciding whether
two expressions are equal is undecidable in the general case because at some
point you will have to compare e.g. coefficients and the equality of real
numbers is undecidable. In practice, you will consider two numbers to be equal
if their difference is below a certain threshold, which could in theory also
yield false positives, but I find it unlikely that this would occur in
practice in the situation of solving an equation.

~~~
riku_iki
I think they can use transformer in the same way for proof path generation: do
pattern matching for complex logical statements to find those where specific
rule can be applied, similarly as it has be done in differential equations
paper.

~~~
Tainnor
How does that help and/or address any of what I wrote?

You can generate possible transformations from one proposition to another one,
yes. But the space of possible transformations is infinite, how does the
system know which ones to try? Moreover, even if you try some local
transformation, how do you know that you have made progress?

A system like that could probably perform well on typical undergraduate
proofs: epsilon-delta, proof that such and such a thing is a norm, etc., but
it's gonna have a hard time with more difficult problems.

------
Findeton
It looks like Graph NNs are going places.

