Plato: A Compiler for Web Forms - UIC Computer Sciencehinrichs/talks/plato50.pdf · Plato: A Compiler for Web Forms Tim Hinrichs University of Chicago and University of Illinois at

Plato: A Compiler for Web Forms

Tim HinrichsUniversity of Chicago and University of Illinois at Chicago

Thursday, December 2, 2010

Interactive Web Forms are the Norm

Today’s users expect web forms with two pieces of functionality:

• Implied value computation: given the user’s current information, what other information is obviously intended?

• Error Detection: which user-provided information is erroneous?

Benefits of in-browser implementation:

• Rich user experience

• Reduced load on server and network


Live Demo

• Samples of interactive web forms.


Automated Reasoning and Web Forms

Building a web form can be complicated.

• HTML/CSS for layout, colors, fonts, etc. is easy.

• JavaScript for detecting errors and computing implied values is hard,e.g. feature-oriented programming, configuration management.

Error detection: SAT solving specialized to the web form.

Implied value computation: theorem proving (TP) specialized to the web form.

A version of TP that tolerates inconsistency: paraconsistent TP.


Plato: A Declarative Approach to Web Forms

Declarative approach

• Web programmer uses formal logic to describe acceptable web form data: web form ontology.

• Web programmer invokes a compiler (Plato) on the ontology to construct error-detection and implied-value computation code automatically.

Benefits

• Writing/maintaining an ontology is easier than JavaScript.

• Error-prone specialization of SAT/TP is performed automatically.

• Choice of paraconsistent TP can be left up to experts (compiler writers).


Live Demo 2

• Ontologies for earlier samples.


Outline

• Logical Foundations of Web Forms

• Plato’s Architecture

• Plato’s Compilation Algorithms

• Evaluation

• Related Work and Conclusions


Logical Foundations of Web Forms

Notation:

• F is a set of web form fields, e.g. shipCity, shipState, shipZip, billCity, billState, billZip.

• ∑ is some character set, e.g. Latin-1 or UTF-8.

Definition (Payload): A web form payload is a subset of F x ∑*. Logically, a payload is a set of ground atoms f(v) where f in F and v in ∑*.

Definition (Ontology): A web form ontology is a logical axiomatization of a set of payloads -- the acceptable payloads.

Today, we consider ontologies written in a fragment of first-order logic.


Shipping and Billing Addresses

Payload:

Ontology:

{shipCity(Chicago), shipState(Illinois)}

same ⇔ ∀x.�� shipCity(x) ⇔ billCity(x)

shipState(x) ⇔ billState(x)

�


Logical Foundations of Web Forms 2

• Definition (Consistent): A payload is consistent if it is a subset of an acceptable payload. All other payloads are inconsistent. A payload is minimally inconsistent if it is inconsistent and no subset is inconsistent.

• Definition (Error): There is one error in a payload for every minimally inconsistent payload contained within it.

• Definition (Traditional Implication): Suppose P is a consistent payload for ontology ∆. P implies value v for field f if every consistent superset of P includes f(v).

• Definition (Paraconsistent Implication): Suppose P is an inconsistent payload for ontology ∆. P implies value v for field f if there is some P0 ⊂ P that is consistent and implies f(v).

• Definition (Implied value): Suppose P is the payload comprised of the user-supplied key-value pairs on a web form. The form implies f(v) exactly when P paraconsistently implies f(v).

P |=∆ f(v)

P |=∆E f(v)


Shipping and Billing Addresses 2

• Payload: {shipCity(Chicago), shipState(Illinois),same}

• Error: none

• Implied values:billCity(Chicago)billState(Illinois)

• Consistent/inconsistent

• Add to payload: billCity(San Francisco)

• Error: {shipCity(Chicago), same, billCity(San Francisco)}

• Implied values under <everything>

• Implied values underbillState(Illinois)

|=∆

|=∆E


Monadic First-order Logic

A web form payload is a set of statements in monadic first-order logic. (All relations have at most 1 argument.)

{billCity(Chicago), billState(Illinois)}

Ontology language for today: monadic, function-free, quantifier-free, equality-free, first-order logic (MON for short)

Syntax

• V: a countable set of variablesO: a set of object constants (that includes ∑*)R: a set of propositionsP: a set of relation constants

• term T ::= V | O

• sentence S ::= R | p(T) | S ∧ S | S ∨ S | ¬ S | S ⇒ S | S ⇐ S | S ⇔ S

• free variables are implicitly universally quantified

Semantics: standard first-order semantics.


Computational Complexity of Implication

Theorem: Suppose ∆ is in MON and P is a finite set of ground atoms. The complexity of is as follows.

• ∏2-hard and included in ∏3.

• ∏1-hard and ∑1-hard and included in ∏2 if the number of variables in ∆ is bounded by a constant.

• ∏1-hard if ∆ is in clausal form and contains 1 variable.

• AC0 (included in P) if ∆ is of constant size.

|=∆E


Outline




• Evaluation



Compile Time vs. Run Time

Compiler

User

ontology

acceptablepayload

User acceptablepayload



Compile Time• Compiler used by web programmer once.• Web programmer will wait minutes.

Run Time• Form used by many people.• Each person generates many SAT/TP queries.• People expect real-time results.


Web Form Skeleton

OnChange(field f)

1: F := dependentFields(f)

// Compute errors (some bookkeeping not shown)2: for each field g in F3: if hasvalue(g) then4: if errorg() then paintred(g)

// Compute implied values5: for each field g in F6: if !(hasvalue(g)) then7: V := impliedValuesg()8: setValues(g,V)9: if V ≠ ∅ then paintgreen(g)

Relies on two functions for each form field: errorg and impliedValuesg


Compiler Architecture

Traditional approach: write a SAT solver/a paraconsistent TP in JavaScript.

Drawback: the same ontology analysis is performed repeatedly but with different data.

Plato: construct JavaScript SAT/TP specialized to the ontology.

Benefits: (i) database compilation techniques well-known, (ii) (non-recursive) database queries are sentences in first-order logic.

MONCompiler

DatabaseCompilerontology JavaScript

databasequeries


Web Form Implication Compiler

Definition (Web Form Implication Compiler):

A web form ontology compiler is a function α that maps an ontology and a set of predicates to a set of first-order formulae.

α is a compiler if for any ontology Δ, predicate set F, and predicate f ∈ F, there is a sentence φf (impliedValuesf) in α[Δ,F] such that for any payload P and any object v

On the left, P is treated with the open world assumption. On the right, P is treated with the closed world assumption.

P |=∆E f(v) if and only if |=P φf (v)


Shipping and Billing Addresses 3

φshipCity(x) ≡ same ∧ billCity(x)

φshipState(x) ≡ same ∧ billState(x)

φsame ≡ ∀x.�� shipCity(x) ⇔ billCity(x)


�

Ontology:

Compilationfor fields

{shipCity,shipState,same}:

same ⇔�� shipCity(x) ⇔ billCity(x)


�


Outline




• Evaluation



Overview

implCompile: Algorithm for constructing impliedValuesf for each form field f.

errCompile: Algorithm for constructing errorf for each form field f.

compression: Algorithm to compress ontology before compilation.


Traditional Implication via Database queries

Example 1.

Database queries for implication.

Example 2.

Database queries for implication.

φp(x) ≡⊥φq(x) ≡ p(x)

φr(x) ≡ p(x) ∨ q(x)

φs(x) ≡ p(x) ∨ q(x) ∨ r(x)

p(x) ⇒ q(x)

q(x) ⇒ r(x)

r(x) ⇒ s(x)

p(x) ⇒ q(x) ∨ r(x)

q(x) ⇒ s(x)

r(x) ⇒ s(x)

p q r s pq

rs

φp(x) ≡⊥φq(x) ≡⊥φr(x) ≡⊥φs(x) ≡ p(x) ∨ q(x) ∨ r(x)


Paraconsistent Implication via Database Queries

Example 3.

Database queries for paraconsistent implication.

p(x) ⇒ q(x)

q(x) ⇒ r(x)

r(x) ⇒ s(x)

¬p(a)

p q r s

φp(x) ≡⊥φq(x) ≡ p(x) ∧ consistentp(x)(x)

φr(x) ≡�� p(x) ∧ consistentp(x)(x)

q(x) ∧ consistentq(x)(x)

�

φs(x) ≡

� p(x) ∧ consistentp(x)(x)

q(x) ∧ consistentq(x)(x)r(x) ∧ consistentr(x)(x)


Compilation Algorithm for Implied Values

Name: implCompileInputs: Δ, a web form ontology in MON. F, a set of web form fields (predicates).Outputs: a set of first-order equivalences for computing paraconsistent implications.Summary: (i) Compute definite Horn consequences, (ii) add consistency checks, (iii) apply predicate completion

1: Δ := resolutionClosure[Δ]

2: Γp := ∅ for each predicate p

3: for each clause c in Δ4: for each contrapositive d of c

5: write d as p(x) ⇐ ψ(x,y)

6: if p ∈ F and ¬ does not occur in ψ(x,y)

7: Γp := Γp ∪ {ψ(x,y) ∧ consistentψ(x,y)(x,y)}

8: return φp ≡ ∨ Γp for each predicate p


Example

¬p(x) ∨ q(x) ∨ r(x)

¬p(x) ∨ s(x) ∨ r(x)

¬p(x) ∨ q(x) ∨ s(x)

¬p(x) ∨ s(x)

¬q(x) ∨ s(x)

¬r(x) ∨ s(x)

s(x) ⇐ p(x)

s(x) ⇐ q(x)

s(x) ⇐ r(x)

φp(x) ≡⊥φq(x) ≡⊥φr(x) ≡⊥

φs(x) ≡

� p(x) ∧ consistentp(x)(x)

q(x) ∧ consistentq(x)(x)r(x) ∧ consistentr(x)(x)

1. Resolution Closure 2. Definite Horn Rules

3. Consistency checks and

Predicate completion


Soundness and Completeness

Theorem: implCompile is a web form implication compiler, i.e. for any ontology Δ, predicate set F, and predicate f ∈ F, φf in ImplCompile[Δ,F] ensures that for any payload P and any object v

P |=∆E f(v) if and only if |=P φf (v)


Consistency checks

Definition (consistentψ(x)): Suppose ∆ is the web form ontology. consistentψ(x)

(v) is true if and only if {ψ(v)} U ∆ is consistent.

All of the consistency checks are of the form

where the pis are web form fields.

The consistency check for p1(v1) ∧ ... ∧ pn(vn) is true exactly when the payload {p1(v1), ..., pn(vn)} is error-free.

Since the web form computes errors (before computing implied values), the consistency checks amount to simple subset checks of the errors.

consistentp1(x1)∧···∧pn(xn)(x1, . . . , xn)


Compilation Algorithm for Errors

Name: errCompileInputs: Δ, a web form ontology in MON. F, a set of web form fields (predicates).Outputs: a set of first-order equivalences for computing (non-minimal) errorsSummary: (i) Compute anti-definite Horn consequences, (ii) apply predicate completion

1: Δ := resolutionClosure[Δ]

2: Γp := ∅ for each predicate p

3: for each clause c in Δ4: for each contrapositive d of c

5: write d as ¬p(x) ⇐ ψ(x,y) // Negative literal

6: if p ∈ F and ¬ does not occur in ψ(x,y)

7: Γp := Γp ∪ {ψ(x,y)} // Dropped consistency check

8: return φp ≡ ∨ Γp for each predicate p


Ontology Compression

Before compiling, Plato sometimes compresses the ontology with the hope of reducing the cost of the resolution closure.

Original Ontology:

Compressed Ontology:

where t is a new database table:

� p(a) ∧ q(b) ∧ r(c)p(b) ∧ q(d) ∧ r(e)p(d) ∧ q(c) ∧ r(a)

p(x) ∧ q(y) ∧ r(z) ⇒ t(x, y, z)

a b c

b d e

d c aThursday, December 2, 2010

Outline




• Evaluation



Evaluation of Ontology Language

Successes

• Built a handful of web form ontologies by hand.

• Wrote a translator from a language for configuration management problems (Configit) into MON.

Limitations

• String-level constraints, e.g. date field has the format mm/dd/yyyy, or password field must contain at least 6 characters.

• Structural constraints, e.g. each paper author has a first name, last name, and email; there can be arbitrarily many authors.


Evaluation of Compiler

Analytical: size of resolution closure (without compression)

Compiler

• Run-time is polynomial in the size of the resolution closure of the ontology.

• Output complexity is polynomial in the size of the resolution closure.

Code the compiler generates

• Size is polynomial in size of the resolution closure.

• Run-time is a single-exponential factor of the size of the resolution closure.

Empirical: impact of compression on resolution closure


Analytical Evaluation of Compiler

Proposition: The output complexity of the resolution closure for MON is EXPSPACE-hard and included in 2EXPSPACE. When the premises are in clausal form, contain exactly one variable, and include no object constants, the output complexity if EXPSPACE-complete.

Proposition: For any class of MON for which resolution’s output complexity is included in EXPSPACE, Plato produces time-optimal implementations of implied-value computation and error detection, unless P=NP.

Corollary: Plato produces time-optimal implementations for ontologies written in clausal form with one variable and no object constants, unless P=NP.


Empirical Evaluation of Compiler

• Ran resolution on compressed and uncompressed ontologies; 17 finished.

• Ontologies drawn from CLib configuration management problems.

!"!!!!#$

!"!!#$

!"#$

#!$

#!!!$

#!!!!!$

#$ %$ &$ '$ ($ )$ *$ +$ ,$ #!$##$ #%$ #&$ #'$ #($ #)$#*$

!"##$%&"'()*+',-."/#00)-1'

-./$

012345637$

839:4$


Empirical Evaluation of Compiler

• Ran resolution on compressed and uncompressed ontologies; 17 finished.

• Ontologies drawn from CLib configuration management problems.

!"

#"

$!"

$#"

%!"

%#"

$" &" #" '" (" $$" $&" $#" $'"

!"#$%&''(")*+,-"*


Outline




• Evaluation



Related Work

Related work found in: web engineering, computer security, formal methods, programming languages, databases, artificial intelligence, configuration management.

Most work either disallows errors, does not support implication, or utilizes a version of paraconsistent implication that does not reduce to traditional implication without errors (values are only propagated in certain directions).

Exceptions:

• [Kassoff-Genesereth, 2007] used our verison of paraconsistent implication but did not introduce compilation algorithms, complexity results, or compression.

• [Vlaeminck-Vennekens-Denecker, 2009] utilized omni-directional paraconsistent implication, but focused on approximate inference instead of compilation.

• [Hinrichs-Kao-Genesereth, 2009] focused on databases but did not leverage web form environment for consistency checks, include complexity results, or discuss compression.


Future Work

• Expanded ontology language and accompanying compilation.

• Expand to multiple ontologies for describing web forms, e.g. conflict resolution, layout, dynamic behavior.

• For web form front-ends to relational databases, extract web form ontology from database integrity constraints automatically.

• AJAX for checking constraints dependent on data in database that cannot be shipped to client.

• Expand from single web form to series of forms and their interaction with server.


Documents

Plato: A Compiler for Web Forms - UIC Computer Sciencehinrichs/talks/plato50.pdf · Plato: A Compiler for Web Forms Tim Hinrichs University of Chicago and University of Illinois at