Knowledge Compilation: Representations and Lower Bounds Paul Beame University of Washington with Jerry Li, Vincent Liew, Sudeepa Roy, Dan Suciu

Representing Boolean Functions Circuits Boolean formulas (tree-like circuits), CNFs, DNFs De Morgan basis (⋀,⋁,¬) Can be negation normalized (all negations at inputs) Decomposable ⋀ gates (DNNF) Decision Diagrams Decision Trees Branching Programs (Decision DAGs) OBDDs (oblivious read-once BPs) FBDDs (read-once BPs) k-OBDDs, read-k BPs, etc. Hybrid and non-syntactic representations d-DNNFs (DNNFs with deterministic ⋁ gates) Decision-DNNFs (FBDDs with decomposable ⋀ nodes) Sentential Decision Diagrams (SDDs) Decomposable Logic Decision Diagrams (DLDDs)

Decomposable ⋀ [Darwiche 2001] ∧ No variables in common between subcircuits

Representing Boolean Functions Circuits Boolean formulas (tree-like circuits), CNFs, DNFs De Morgan basis (⋀,⋁,¬) Can be negation normalized (all negations at inputs) Decomposable ⋀ gates (DNNF) Decision Diagrams Decision Trees Branching Programs (Decision DAGs) OBDDs (oblivious read-once BPs) FBDDs (read-once BPs) k-OBDDs, read-k BPs, etc. Hybrid and non-syntactic representations d-DNNFs (DNNFs with deterministic ⋁ gates) Decision-DNNFs (FBDDs with decomposable ⋀ nodes) Sentential Decision Diagrams (SDDs) Decomposable Logic Decision Diagrams (DLDDs)

Decision Trees Decision Tree for 𝑷𝒂𝒓𝒊𝒕𝒚(𝒙𝟏, 𝒙𝟐, 𝒙𝟑, 𝒙𝟒) 𝒙 𝟏 𝟎 𝟏 𝒙 𝟐 𝒙 𝟑 𝒙 𝟑 𝒙 𝟑 𝒙 𝟑 𝟎 𝟏 𝟎 𝟏 𝟎 𝟏 𝟎 𝟏 𝒙 𝟒 𝒙 𝟒 𝒙 𝟒 𝒙 𝟒 𝒙 𝟒 𝒙 𝟒 𝒙 𝟒 𝒙 𝟒 𝟎 𝟏 𝟎 𝟏 𝟎 𝟏 𝟎 𝟏 𝟎 𝟏 𝟎 𝟏 𝟎 𝟏 𝟎 𝟏 1 1 1 1 1 1 1 1 Decision Tree for 𝑷𝒂𝒓𝒊𝒕𝒚(𝒙𝟏, 𝒙𝟐, 𝒙𝟑, 𝒙𝟒)

Decision DAGs (Branching Programs/BDDs) 𝒙 𝟏 𝟎 𝟏 𝒙 𝟐 𝒙 𝟐 𝟎 𝟏 𝟏 𝟎 𝒙 𝟑 𝒙 𝟑 𝟎 𝟏 𝟏 𝟎 𝒙 𝟒 𝒙 𝟒 𝟎 𝟏 𝟏 𝟎 1 OBDD for 𝑷𝒂𝒓𝒊𝒕𝒚(𝒙𝟏, 𝒙𝟐, 𝒙𝟑, 𝒙𝟒)

Branching programs not allowed for FBDD 𝒙 𝟐 𝒙=(𝟎,𝟏,𝟎,𝟏,…) 𝟎 𝟏 𝒙 𝟑 𝒙 𝟏 𝒙 𝟑 FBDD: Diagram is read-once i.e., every path contains distinct variables 𝟎 𝟏 𝟎 𝟏 𝒙 𝟒 𝒙 𝟏 𝒙 𝟑 𝟎 𝟎 𝟎 𝟏 𝟏 𝟏 𝒙 𝟖 𝒙 𝟐 𝒙 𝟓 𝟎,𝟏 𝟏 𝟎 𝟏 𝟎 1

Representing Boolean Functions Circuits Boolean formulas (tree-like circuits), CNFs, DNFs De Morgan basis (⋀,⋁,¬) Can be negation normalized (all negations at inputs) Decomposable ⋀ gates (DNNF) Decision Diagrams Decision Trees Branching Programs (Decision DAGs) OBDDs (oblivious read-once BPs) FBDDs (read-once BPs) k-OBDDs, read-k BPs, etc. Hybrid and non-syntactic representations d-DNNFs (DNNFs with deterministic ⋁ gates) Decision-DNNFs (FBDDs with decomposable ⋀ nodes) Sentential Decision Diagrams (SDDs) Decomposable Logic Decision Diagrams (DLDDs)

d-DNNF decision-DNNF ∨ Deterministic ⋁ ∧ Decomposable ⋀ Subcircuits cannot both evaluate to true decision-DNNF Decomposable ⋀ ∧ No variables in common between subcircuits FBDD Decision Node ⇒ Both 𝒙 𝟏 𝟎 𝟏 ∨ ∧

Decomposable Logic Decision Diagrams (DLDDs) Generalization of decision-DNNFs: not just FBDDs + decomposable ⋀ nodes Also ¬ nodes, decomposable binary ⋁, XOR, etc sub-DAGs for each node are labelled by disjoint sets of variables

Model Counting Model Counting Problem: Given: a Boolean function 𝑭 Compute: #𝑭 = #Models (satisfying assignments) of 𝑭 with weights: Probability Computation Problem Given: 𝑭, and independent Pr 𝒙 , Pr 𝒚 , Pr 𝒛 , … Compute: Pr 𝑭 Problems are #P hard but can be computed in practice for classes of problems on 100-10,000 vars. Model counting of a boolean formula …even for formulas where satisfiability is easy to check

d-DNNF to Sum-Product Network [Darwiche 2001] ⊕ ∨ ∧ ⊗ ⊗

Networks of Sums and Products Directed acyclic graphs Each input node is labeled 𝒙 or 𝒙 for some variable 𝒙 Each internal node is labeled by ⊕ or ⊗. For a given set of probabilities for variables, each node is assigned a value given by: Node labeled 𝒙 has value Pr 𝒙 Node labeled 𝒙 has value 1−Pr 𝒙 ⊕ node sums the values of its children ⊗ node multiplies the values of its children Easily computed in time linear in size of the network

Compilation Desiderata for Compiled form Makes model counting simple Concise Easy to find Syntactic, if possible Canonical, if possible Incrementally constructible, if possible

Representing Boolean Functions Circuits Boolean formulas (tree-like circuits), CNFs, DNFs De Morgan basis (⋀,⋁,¬) Can be negation normalized (all negations at inputs) Decomposable ⋀ gates (DNNF) Decision Diagrams Decision Trees Branching Programs (Decision DAGs) OBDDs (oblivious read-once BPs) FBDDs (read-once BPs) k-OBDDs, read-k BPs, etc. Hybrid and non-syntactic representations d-DNNFs (DNNFs with deterministic ⋁ gates) Decision-DNNFs (FBDDs with decomposable ⋀ nodes) Sentential Decision Diagrams (SDDs) Decomposable Logic Decision Diagrams (DLDDs) All these yield sum-product networks for weighted model counting of same size as the representation Follows from result for d-DNNFs since they are the most general

Representing Boolean Functions Circuits Boolean formulas (tree-like circuits), CNFs, DNFs De Morgan basis (⋀,⋁,¬) Can be negation normalized (all negations at inputs) Decomposable ⋀ gates (DNNF) Decision Diagrams Decision Trees Branching Programs (Decision DAGs) OBDDs (oblivious read-once BPs) FBDDs (read-once BPs) k-OBDDs, read-k BPs, etc. Hybrid and non-syntactic representations d-DNNFs (DNNFs with deterministic ⋁ gates) Decision-DNNFs (FBDDs with decomposable ⋀ nodes) Sentential Decision Diagrams (SDDs) Decomposable Logic Decision Diagrams (DLDDs) Syntactic: Consistency of representation can be verified efficiently

Representing Boolean Functions Circuits Boolean formulas (tree-like circuits), CNFs, DNFs De Morgan basis (⋀,⋁,¬) Can be negation normalized (all negations at inputs) Decomposable ⋀ gates (DNNF) Decision Diagrams Decision Trees Branching Programs (Decision DAGs) OBDDs (oblivious read-once BPs) FBDDs (read-once BPs) k-OBDDs, read-k BPs, etc. Hybrid and non-syntactic representations d-DNNFs (DNNFs with deterministic ⋁ gates) Decision-DNNFs (FBDDs with decomposable ⋀ nodes) Sentential Decision Diagrams (SDDs) Decomposable Logic Decision Diagrams (DLDDs) Canonical: Unique given small side information

Outline Basic Knowledge Representations Connections to exact model counters SAT-solvers vs compiled forms Lower bounds for decision-DNNFs/DLDDs Applications and “lifted vs. grounded” inference Conversion theorem SDDs and lower bounds via communication complexity DNNF lower bounds A stronger general representation

Exact Model Counters for CNF CDP Relsat Cachet SharpSAT c2d Dsharp … [Birnbaum et. al.’99] Search-based/DPLL-based (explore the assignment-space and count the satisfying ones) [Bayardo Jr. et. al. ’97, ’00] [Sang et. al. ’05] [Thurley ’06] [Darwiche ’04] Knowledge Compilation-based (compile F into a “computation-friendly” form) [Muise et. al. ’12] [Survey by Gomes et. al. ’09] Both techniques explicitly or implicitly use DPLL-based algorithms produce FBDD or Decision-DNNF compiled forms [Huang-Darwiche’05, ’07]

Compilation and Search Desiderata for Compiled form Makes model counting simple Concise Easy to find Syntactic, if possible Canonical, if possible Compiled size ≤ Search time Even if construction of compiled form is only implicit Can be exponential gap in terms of # of variables e.g. an UNSAT formula has constant compiled size

Model Counters use Extensions to DPLL Caching Subformulas Cachet, SharpSAT, c2d, Dsharp Component Analysis Relsat, c2d, Cachet , SharpSAT, Dsharp Conflict Directed Clause Learning Traces of DPLL + caching + (clause learning)  FBDD DPLL + caching + components + (clause learning)  Decision-DNNF Based on the extensions we get different forms

DPLL Algorithms for Model Counting F: (xy)  (xuw)  (xuwz) 5/8 Assume uniform distribution for simplicity x 1 // basic DPLL: Function Pr(F): if F = false then return 0 if F = true then return 1 select a variable x, return ½ Pr(FX=0) + ½ Pr(FX=1) uwz 7/8 y(uw) 3/8 z y 1 1 uw ¾ uw ¾ 1 u u 1 1 1 ½ w 1 1 ½ w Uniform distribution divided by two Say that the computation can be done similarly w 1 w 1 1 1 1 1 1 1

DPLL Algorithms for Model Counting F: (xy)  (xuw)  (xuwz) 5/8 x 1 uwz 7/8 3/8 y(uw) z Decision-Node y The trace is a Decision-Tree for F 1 1 uw ¾ uw ¾ 1 u u 1 1 1 ½ w 1 1 ½ w Uniform distribution divided by two Say that the computation can be done similarly w 1 w 1 1 1 1 1 1 1

F: (xy)  (xuw)  (xuwz) Caching F: (xy)  (xuw)  (xuwz) x 1 // basic DPLL: Function Pr(F): if F = false then return 0 if F = true then return 1 select a variable x, return ½ Pr(FX=0) + ½ Pr(FX=1) uwz y(uw) z y 1 1 uw uw u u 1 1 1 // DPLL with caching: Cache F and Pr(F); look it up before computing w w BIG SAVINGS Two vars Trace is a dag, keep the same header, properties of FBDDs DAG, every var tested once, deicision node Every variable is tested at most once on any path w 1 w 1 1 1 1 1

F: (xy)  (xuw)  (xuwz) Caching & FBDDs F: (xy)  (xuw)  (xuwz) x 1 uwz y(uw) The trace is an FBDD for F z y 1 1 uw u 1 1 w BIG SAVINGS Two vars Trace is a dag, keep the same header, properties of FBDDs DAG, every var tested once, deicision node Every variable is tested at most once on any path w 1 1 1

F: (xy)  (xuw)  (xuwz) Component Analysis F: (xy)  (xuw)  (xuwz) // basic DPLL: Function Pr(F): if F = false then return 0 if F = true then return 1 select a variable x, return ½ Pr(FX=0) + ½ Pr(FX=1) x 1 uwz y  (uw) z y 1 1 uw // DPLL with component analysis (and caching): if F = G  H where G and H have disjoint sets of variables Pr(F) = Pr(G) × Pr(H) u 1 1 w w 1 1 1

Components & decision-DNNF Decision Node F: (xy)  (xuw)  (xuwz) x AND Node 1 uwz y  (uw) The trace is a decision-DNNF [Huang-Darwiche ’05, ’07] FBDD + Decomposable ⋀ nodes  z 1 y uw y u 1 1 1 w 1 (x v y v z) (x v v v w) (xbar v v v w v z) Syntactic subclass w 1 1 1

Outline Basic Knowledge Representations Connections to exact model counters SAT-solvers vs compiled forms Lower bounds for decision-DNNFs/DLDDs Applications and “lifted vs. grounded” inference Conversion theorem SDDs and lower bounds via communication complexity DNNF lower bounds A stronger general representation

Conversion Theorem [B-Li-Roy-Suciu ICDT 2014, ACM TODS 2017] Any Boolean function represented by a DLDD (or decision-DNNF) 𝓓 with 𝑵 nodes can be represented by an FBDD 𝓕 with at most 𝟐 𝑵 𝐥𝐨𝐠 𝟐 𝑵+𝟏 nodes Moreover, from 𝓓 we can construct 𝓕 in time linear in its size. [Razgon 2016] Conversion is asymptotically optimal for decision-DNNFs, even when nondeterministic FBDDs are allowed

Implications Many previous exponential lower bounds for FBDDs ⇒ exponential lower bounds for DLDDs/decision-DNNFs A 𝟐 𝛀 𝒏 lower bound for FBDDs implies a 𝟐 𝛀 𝒏 lower bound for DLDDs/decision-DNNFs Even applies to simple explicit 2-DNF formulas [Bollig-Wegener 2000] [Wegener 2002] But what about functions we really care about?

Applications of exact model counters Finite model theory: First order formulas over finite domains Bayesian inference Statistical relational models Combinations of logic and probability Probabilistic databases Restrictions of statistical relational models

A class of database examples 𝑯 𝟎 = 𝒊,𝒋 𝑹 𝒊 𝑺 𝒊,𝒋 𝑻 𝒋 𝑯 𝟏 = 𝒊,𝒋 𝑹 𝒊 𝑺 𝒊,𝒋 ∨ 𝒊,𝒋 𝑺 𝒊,𝒋 𝑻 𝒋 𝑯 𝒌 = 𝒊,𝒋 𝑹 𝒊 𝑺 𝒊,𝒋 𝟏 ∨⋯∨ 𝒊,𝒋 𝑺 𝒊,𝒋 ℓ 𝑺 𝒊,𝒋 ℓ+𝟏 ∨⋯∨ 𝒊,𝒋 𝑺 𝒊,𝒋 𝒌 𝑻 𝒋 Dichotomy Theorem [Dalvi, Suciu 12] Model counting a Boolean combination of 𝒉𝒌𝟎,…,𝒉𝒌𝒌 is either #P-hard, e.g. 𝑯𝒌, or Polynomial time computable using “lifted inference” (inclusion- exclusion), e.g. 𝑸 𝑾 =(𝒉𝟑𝟎  𝒉𝟑𝟐) (𝒉𝟑𝟎  𝒉𝟑𝟑) (𝒉𝟑𝟏  𝒉𝟑𝟑) and there is a simple condition to tell which case holds 𝒉𝒌𝟎 𝒉𝒌ℓ 𝒉𝒌𝒌

Example: 𝑯 𝟏 is hard for FBDDs 𝑯 𝟏 = 𝒊,𝒋 𝑹 𝒊 𝑺 𝒊,𝒋 ∨ 𝒊,𝒋 𝑺 𝒊,𝒋 𝑻 𝒋 Intuition: First term of 𝑯 𝟏 easy if 𝑺 read by rows Second term of 𝑯 𝟏 easy if 𝑺 read by columns Proving hardness is more complicated [B-Li-Roy-Suciu 14] uses “admissible paths” in any FBDD 𝑻 𝟏 𝑻 𝟐 𝑻 𝟑 𝑻 𝟒 𝑹 𝟏 𝑺 𝟏𝟏 𝑺 𝟏𝟐 𝑺 𝟏𝟑 𝑺 𝟏𝟒 𝑹 𝟐 𝑺 𝟐𝟏 𝑺 𝟐𝟐 𝑺 𝟐𝟑 𝑺 𝟐𝟒 𝑹 𝟑 𝑺 𝟑𝟏 𝑺 𝟑𝟐 𝑺 𝟑𝟑 𝑺 𝟑𝟒 𝑹 𝟒 𝑺 𝟒𝟏 𝑺 𝟒𝟐 𝑺 𝟒𝟒

Lower Bounds Theorem [B-Li-Roy-Suciu]: Any Boolean function of 𝒉𝒌𝟎,…,𝒉𝒌𝒌 that depends on all of them requires FBDD size (𝟐 𝒏 −𝟏)/𝒏 Corollary: Any decision-DNNF/DLDD for a Boolean combination of 𝒉𝒌𝟎,…,𝒉𝒌𝒌 that depends on all them requires size 𝟐 𝛀 𝒏 Corollary: SAT-solver based exact model counting requires 𝟐 𝛀 𝒏 time even on probabilistic DB instances that are solvable via 𝒏 𝐎(𝟏) time algorithms using “lifted inference”.

“Lifted” vs “Grounded” Inference Works with propositional groundings of the first-order expressions given by the model “Lifted” inference Works with the first-order formulas and does higher level calculations (e.g. inclusion-exclusion) Folklore sentiment: Lifted inference is strictly stronger than grounded inference These examples give a clear proof

Proof of Conversion Theorem Efficient construction Decision-DNNF FBDD Size 𝑵 Size 𝑵 𝐥𝐨𝐠 𝟐 𝑵+𝟏 and their connection to FBDDs and decision-DNNFs Converse does not hold Another source of complexity from constructing the decision-DNNFs

Decision-DNNF  FBDD Convert decomposable ⋀-nodes to paths between decision-nodes while representing the same function 𝒇

First attempt  G 1 G H H FBDD 1 1 1 Decision-DNNF FBDD G and H do not share variables, so every variable is still tested at most once on any path

But, sub-DAGs may be shared    Conflict! G H G H g ’ h g ’ h H G G over H and H over G both cross out Copy nodes These may have AND-nodes inside them, so might need to do it recursively, exponential blow up 1 1 1 1 Decision-DNNF

Obvious Solution: Replicate Nodes    G G H H g ’ h 1 No conflict  can apply original idea 1 G over H and H over G both cross out Copy nodes These may have AND-nodes inside them, so might need to do it recursively, exponential blow up But, may need recursive replication Can have exponential blowup!

Main Idea: Replicate Smaller Sub-DAG  Edges coming from other nodes in the decision-DNNF Smaller sub-DAG Each ⋀-node creates a private copy of its smaller sub-DAG Remember, disjoint set of variables Define light and heavy edges here Keyproperty: Larger sub-DAG

Light and Heavy Edges  Light Edge Heavy Edge Smaller sub-DAG Larger sub-DAG Each ⋀-node creates a private copy of its smaller sub-DAG Recursively, each node 𝒖 is replicated every time it is in a smaller sub-DAG #Copies of 𝒖 = #sequences of light edges leading to 𝒖 Remember, disjoint set of variables Define light and heavy edges here Keyproperty:

Quasipolynomial Conversion 𝑳 = Max #light edges on any path 𝑳 ≤ log 𝟐 𝑵 since 𝑵 = 𝑵 𝒔𝒎𝒂𝒍𝒍 + 𝑵 𝒃𝒊𝒈 ≥𝟐 𝑵 𝒔𝒎𝒂𝒍𝒍 ≥ … ≥ 𝟐𝑳 #Copies of each node ≤ 𝑵 𝑳 ≤𝑵 𝐥𝐨𝐠 𝟐 𝑵   #Nodes in FBDD ≤ 𝑵 ∙𝑵 𝐥𝐨𝐠 𝟐 𝑵 Remember, disjoint set of variables Define light and heavy edges here Keyproperty: 

Outline Basic Knowledge Representations Connections to exact model counters SAT-solvers vs compiled forms Lower bounds for decision-DNNFs/DLDDs Applications and “lifted vs. grounded” inference Conversion theorem SDDs and lower bounds via communication complexity DNNF lower bounds A stronger general representation

Sentential Decision Diagrams (SDDs) [Darwiche 2011] Special case of d-DNNFs, generalize OBDDs Preserves many nice OBDD properties Determined by a vtree: an ordered binary tree with distinct variables on the leaves yields hierarchical partitioning of the variables SDD: an AND-OR dag based on the vtree AND: splits the variables by the partition in the vtree OR: left children of its ANDs are disjoint (partition) 𝒘 𝒙 𝒚 𝒛 1 2 3 𝒘 𝒙 ¬𝒘 ¬𝒙 𝒚 ¬𝒚 𝒛 OR AND

Communication Complexity Input a ∈𝑨 Input b ∈𝑩 010 f 11 𝑓(𝑎,𝑏) Alice Bob Communication complexity is: 𝐶 𝑨,𝑩 𝑓 = # required message bits between Alice and Bob to compute 𝑓(𝒂,𝒃)

Communication protocols from vtrees What are Alice and Bob’s inputs given vtree 𝑻? Alice’s Variables 𝑨 1/3-2/3 node 1 3 𝑨∪𝑩 < 𝑨 < 2 3 𝑨∪𝑩 𝒖 𝒗 𝑤 𝒙 𝒚 𝒛 𝑩 Bob’s Variables

Communication protocols from SDDs On input 𝒂 to 𝑨, Alice sends Bob the name of an SDD node corresponding to 1/3-2/3 node that is consistent with 𝒂 and she guesses is consistent with Bob’s input 𝒃 to 𝑩. Alice’s Variables 𝒖 𝒗 𝑤 𝒙 𝒚 𝒛 𝑨 Bob’s outputs 1 if node is consistent with 𝒃 and output on value 𝒃 is 1. 𝑩 Bob’s Variables

Communication Complexity and SDDs Lemma: Among all SDD nodes consistent with 𝒂, there is precisely one node consistent with 𝒃 Corollary: Any SDD for 𝒇 of size 𝑺 yields a 𝐥𝐨𝐠 𝟐 𝑺 bit unambiguous nondeterministic protocol for 𝒇 under some 1/3-2/3 partition of its variables. Theorem [B-Liew UAI 2015]: Any SDD for 𝒇 of size 𝑺 yields a ( 𝐥𝐨𝐠 𝟐 𝑺+𝟏)𝟐 bit deterministic protocol for 𝒇 under some 1/3-2/3 partition of its variables Proof: Use result of [Yannakakis 1991] showing that unambiguous protocols of complexity 𝒈 can be simulated by deterministic ones of complexity (𝒈+𝟏)𝟐.

Applications: SDD lower bounds [B-Liew 2015] Fact: Every 𝒉𝒌ℓ under every 1/3-2/3 partition of its variables contains a set disjointness problem of size 𝛀(𝒏) requires communication complexity 𝛀(𝒏) Yields a 𝟐 𝛀 𝒏 lower bound for SDDs for all UCQ queries except those with small OBDD representations. The following DB query has an 𝑶( 𝒏 𝟐 ) size FBDD but requires a 𝟐 𝛀 𝒏 size SDD 𝑸 𝑽 = 𝒊,𝒋 𝑹 𝒊 𝑻 𝒋 ∨ 𝒊,𝒋 𝑹 𝒊 𝑺 𝒊,𝒋 ∨ 𝒊,𝒋 𝑺 𝒊,𝒋 𝑻 𝒋 Results also apply to all “structured d-DNNF” via [Pipatsrisawat-Darwiche 2010]

Representing Boolean Functions Circuits Boolean formulas (tree-like circuits), CNFs, DNFs De Morgan basis (⋀,⋁,¬) Can be negation normalized (all negations at inputs) Decomposable ⋀ gates (DNNF) Decision Diagrams Decision Trees Branching Programs (Decision DAGs) OBDDs (oblivious read-once BPs) FBDDs (read-once BPs) k-OBDDs, read-k BPs, etc. Hybrid and non-syntactic representations d-DNNFs (DNNFs with deterministic ⋁ gates) Decision-DNNFs (FBDDs with decomposable ⋀ nodes) Sentential Decision Diagrams (SDDs) Decomposable Logic Decision Diagrams (DLDDs) Require size 𝟐 𝛀 𝒏 size for simple DB queries

Representing Boolean Functions Circuits Boolean formulas (tree-like circuits), CNFs, DNFs De Morgan basis (⋀,⋁,¬) Can be negation normalized (all negations at inputs) Decomposable ⋀ gates (DNNF) Decision Diagrams Decision Trees Branching Programs (Decision DAGs) OBDDs (oblivious read-once BPs) FBDDs (read-once BPs) k-OBDDs, read-k BPs, etc. Hybrid and non-syntactic representations d-DNNFs (DNNFs with deterministic ⋁ gates) Decision-DNNFs (FBDDs with decomposable ⋀ nodes) Sentential Decision Diagrams (SDDs) Decomposable Logic Decision Diagrams (DLDDs)

Lower Bounds for DNNFs Generalized version of Conversion Theorem: Size 𝑵 DNNF yields size 𝑵 𝐥𝐨𝐠 𝟐 𝑵+𝟏 nondeterministic FBDD. [Razgon 2015, B-Liew 2015] Optimal even for decision-DNNF [Razgon 2015] Corollary: PERM on 𝟎,𝟏 𝒏 𝟐 given by PERM(𝑴)=1 iff 𝑴 is a permutation matrix requires DNNF size 𝟐 𝛀 𝒏 [Bova,Capelli,Mengel,Slivovsky 2016] Wide range of separations and purely exponential lower bounds on DNNFs and d-DNNFs Separations use general communication complexity methods of [Pipatsrisawat-Darwiche 2010]

Outline Basic Knowledge Representations Connections to exact model counters SAT-solvers vs compiled forms Lower bounds for decision-DNNFs/DLDDs Applications and “lifted vs. grounded” inference Conversion theorem SDDs and lower bounds via communication complexity DNNF lower bounds A stronger general representation

Sum-Product-Complement (SPC) Networks Directed acyclic graphs Each input node is labeled 𝒙 or 𝒙 for some variable 𝒙 Each internal node is labeled by ⊕ or ⊗ or unary ⊖. For a given set of probabilities for variables, each node is assigned a value given by: Node labeled 𝒙 has value Pr 𝒙 Node labeled 𝒙 has value 1−Pr 𝒙 ⊕ node sums the values of its children ⊗ node multiplies the values of its children ⊖ node computes 1 – (the value of its child) Easily computed in time linear in size of the network

The ultimate model-counting representation? An SPC network corresponds to a Boolean representation as a De Morgan circuit (⋀,⋁,¬) with: Decomposable ⋀ gates Deterministic ⋁ gates No requirement to normalize negations What to call them? DDDM or d-DDM or D3M circuits? No non-trivial lower bounds are known for such representations! [B, Liew 2015 unpublished] These D3M representations have quasipolynomial size simulations by a special case of read-once parity branching programs.

Nondeterministic Read-Once BPs/FBDDs 𝒙 𝟏 𝟎 𝟏 𝒙 𝟏 ≡ Value is 1 iff there exists a consistent path to the 1-sink node Parity Read-Once BPs ⊕ 𝒙 𝟏 𝒙 𝟏 𝒙 𝟏 𝒙 𝟏 Value is 1 iff there are an odd # of consistent paths to the 1-sink node

Directions and Open Problems Other separations and lower bounds shown by [Bova,Capelli,Mengel,Slivovsky 2016] See tomorrow’s talk by Simone Bova Find algorithms, on par with those that build decision-DNNFs and SDDs, to build the more general D3M representations Prove lower bounds on the size of D3M representations

Thank You