Index Mathematics Conjectures nbv lettuce Widgets

A gentle introduction to algebraic programs and mathematical machines

Programs as algebraic objects

When we think about programs we typically think about computer programs with user interfaces. Something like Microsoft Windows or an internet browser. Internally these programs are a sequence of operations on boolean variables. Symbolically call it f(x)→x′ where x,x′∈ℤ2k for some k that is the architecture of the machine (e.g. 32 or 64 bit). Now, say that I want to prove to you that I ran a specific program f and it generated a specific output x′. To do this I form a math problem p(f,x,x′)→𝜻 that is only solvable given knowledge of x (the input to the program). If the problem p correctly constrains all dimensions of f, then 𝜻 is an argument that a program was run at a point in time. Crucially, p must be shaped such that a function v(p,f,x′,𝜻)→ℤ2 exists (representing the validity of the argument).1

Thus we have the shape of an abstract computer as a pair of functions, prover pf, and verifier vf which separates the invocation and observation of a function f in time:

pf(ℤqk)→e̸jsuch that∃vf:vf(e̸j)→ℤ2andDom⁡(pf)=Dom⁡(f) andCodom⁡(pf)=Dom⁡(vf)and|Dom⁡(f)|=|Dom⁡(vf)| A theoretical computer running a function f, pf takes a vector of length k as input, and outputs j indistinguishable elements. The computer is conjectured to have existed by the verifier function vf which takes the indistinguishable elements e̸j and outputs 1 if all the constraints of f were fulfilled, and 0 otherwise. The theoretical computer exists if the codomain (output space) of the prover function p is equal to the domain (input space) of the verifier function v, and the cardinality of the domain of f is equal to the cardinality of the domain of v.

This is a very strict definition of a mathematical machine insofar as it precludes the existence of invalid values by counting. In reality most systems have slack either as excess dimensionality which is algebraically restricted to fulfill the axioms above, or probabilistically introduced error terms (or both).

Interestingly this implies that lattice constructions can be converted to indistinguishable obfuscation devices by taking the lattice base randomly, instead of as a public constant. The topological shape of the resulting argument exactly matches all other arguments and the randomized lattice base selects a random p,v pair from a high dimension space with cardinality matching that of the lattice base matrix. If the randomized lattice base is sent as an 𝒪︀(1) dimension seed for a csprng the cost of such a device is computationally negligible for both prover and verifier. This provides low cost hiding for an argument of knowledge (when compared with algebraic ZK shims), at the expense of requiring a shared secret (instead of embedding the hiding entropy in the witness).

This inverts the existential nature of a theoretical computer described above. Given an indistinguishably obfuscated program 𝜻 it can be verified and decoded given a seed 𝜹 which expands from oracle to a lattice base A∈ℤqm×n which is used to verify an argument of knowledge pf,vf. Given that f is a public token function, outputs can be revealed publicly but without the ability to verify validity, or restricted by knowledge of 𝜹.2 The choice of whether outputs were revealed or not is itself known only to the participants of the system, except by inference/relativity.

A program expressed as a rank-one-constraint-system is a high dimension algebraic object, A,B,C∈ℤqm×n such that a valid run of the program w∈ℤqn fulfills AwBw=Cw. Accordingly, the iO shim described above can be implemented as a mask z←$ℤqn applied by the prover as 𝝎=z⋅w, with the verifier function becoming:

(A⋅diag⁡(z−1))𝝎⋅(B⋅diag⁡(z−1))𝝎=(C⋅diag⁡(z−1))𝝎

In this case a client and a server would agree on a function f defined as an R1CS. The client streams 𝝎 to the server which incrementally computes the relation above. This is analogous to a REST API or cryptographic serverless functions. The inherent algebraic nature makes mutating and reasoning about high dimension objects more simple.

A two dimension projection of a rank-one-constraint-system
2-dimensional projection of a program with two inputs and one constraint: f(ℤq2)→ℤ2

This naturally implies things like heteromorphic encryption streamed over an iO device like described above. The more natural model for “the cloud” being theoretical chunks of data that users may write to algebraically. Put differently, a space of data that can only be mutated using a high dimension theoretical tool seeded with a shared secret.

notes

A physical computer argues its existence physically. A human looks at the screen and sees symbols which are consistent with their understanding. This gives rise to mathematical machines: machines that exist and run programs purely symbolically, which are then simulated on digital computers.

  1. ℤ2 is a boolean, e.g. true or false. ↩

  2. There is more nuance to this. Really you’d want to encode the outputs as the distance to the outputs as a point on some shared secret lattice base A′ or similar. ↩