commit 2fa4ecab0be51d650e7fe5f75c73e32f1a07db10
Author: Antoine Amarilli <a3nm@a3nm.net>
Date: Sat, 28 Dec 2024 10:30:24 +0100
create from personal repository
Diffstat:
783 files changed, 9157 insertions(+), 0 deletions(-)
diff --git a/1_or_3_in_3_sat b/1_or_3_in_3_sat
@@ -0,0 +1,9 @@
+# 1_or_3_in_3_sat
+
+Variant of [satisfiability_boolean] where each clause contains exactly 3 literals and you want a valuation such that each clause has 1 or 3 true literals
+
+It is in fact [ptime] because it is [affine]
+
+https://cstheory.stackexchange.com/questions/53268/complexity-of-1-or-3-in-3-sat-odd-3-sat
+
+Up: [schaefers_dichotomy_theorem], [sat_variants]
diff --git a/2horn_clause b/2horn_clause
@@ -0,0 +1,9 @@
+# 2horn clause
+
+[horn_clause] with exactly 2 literals (one positive, one negative)
+
+maybe should be "definite 2horn"
+
+Up: [horn_clause]
+
+See also: [2sat], [horn_2sat]
diff --git a/2sat b/2sat
@@ -0,0 +1,16 @@
+# 2SAT
+
+[satisfiability_boolean] of [2cnf]
+
+Can be solved in [linear_time] via [strongly_connected_component], is [nl_complete]
+
+However:
+
+- The [max_sat] problem of satisfying the largest number of clauses of a [2cnf] is [nptime]-hard ([garey_johnson] LO5)
+- The [sharp_satisfiability] problem of counting the satisfying assignments is [nptime]-hard, even for [monotone2cnf]
+
+Generalization: [max_2sat]
+
+See also: [3sat]
+
+Up: [sat_variants]
diff --git a/3_colorable b/3_colorable
@@ -0,0 +1,7 @@
+# 3 colorable
+
+[graph_undirected] which admits a [3_coloring]
+
+See also: [3_coloring], [graph_bipartite]
+
+Up: [graph_family]
diff --git a/3_coloring b/3_coloring
@@ -0,0 +1,7 @@
+# 3 coloring
+
+[graph_coloring] but for 3 colors
+
+Up: [graph_coloring]
+
+See also: [3_colorable]
diff --git a/3_dimensional_matching b/3_dimensional_matching
@@ -0,0 +1,16 @@
+# 3DM
+
+https://en.wikipedia.org/wiki/3-dimensional_matching
+
+Problem: given 3 sets X, Y, Z of n elements, and triples T subseteq X times Y times Z,
+can you take a subset of T containing exactly once each element of X Y Z?
+
+[3_dimensional_matching_hardness_proof]
+
+Variant: [3_dimensional_matching_numerical]
+
+Generalization: https://en.m.wikipedia.org/wiki/Matching_in_hypergraphs
+
+Up: [computational_problem]
+
+See also: [perfect_matching], [dimension]
diff --git a/3_dimensional_matching_hardness_proof b/3_dimensional_matching_hardness_proof
@@ -0,0 +1,11 @@
+# 3 dimensional matching hardness proof
+
+Shown NP-hard [nptime] in [garey_johnson], reduction from [3sat]:
+- for each variable do a "flower" gadget
+ - http://courses.csail.mit.edu/6.890/fall14/6046-L16.pdf
+ - at the center put elements of X and Y that are local to each variable, alternatively
+ - at the extremities put elements of Z that correspond either to x or barx
+ - for each clause there are two elements of X and Y local to that clause to impose that it is covered, and there are 3 ways to cover that use each "allowed" literal
+ - some additional things: for every excess variable occurrences, a gadget with two specific elements of X and Y and all possible Z to cover exactly one unused variable
+
+Up: [3_dimensional_matching]
diff --git a/3_dimensional_matching_numerical b/3_dimensional_matching_numerical
@@ -0,0 +1,14 @@
+# Numerical 3DM
+
+https://en.wikipedia.org/wiki/Numerical_3-dimensional_matching
+
+NUMERICAL 3-DIMENSIONAL MATCHING: vertices are integers and the eges are all
+triples that sum to the same value S/n where S is the sum of all the X Y Z
+
+[np_complete] by reduction from 3-PARTITION [3_partition] following
+http://courses.csail.mit.edu/6.892/spring19/scribe/lec2.pdf simply by adding
+large values
+
+See also: [3_dimensional_matching], [3_partition]
+
+Up: [computational_problem]
diff --git a/3_partition b/3_partition
@@ -0,0 +1,11 @@
+# 3-PARTITION
+
+Given integers, partition them into triples that have the same value
+
+[strongly_np_complete] (UNARY-3-PARTITION)
+
+Hardness proof: [garey_johnson] page 96
+
+Up: [decision_problem]
+
+See also: [partition_problem], [4_partition], [3_dimensional_matching_numerical]
diff --git a/3cnf b/3cnf
@@ -0,0 +1,7 @@
+# 3CNF
+
+[conjunctive_normal_form] [boolean_formula] with 3 literals per clause
+
+Up: [conjunctive_normal_form]
+
+See also: [2cnf], [3sat]
diff --git a/3sum b/3sum
@@ -0,0 +1,17 @@
+# 3SUM
+
+https://en.wikipedia.org/wiki/3SUM
+
+Does a set of n real numbers contain 3 numbers summing to 0?
+
+Can be done in O(n^2) or O(n^2/log^2 n (log log n)^(O(1))) (even for reals : [chan2018more])
+
+[3sum_hypothesis]: not known to be solvable in O(n^{2-\epsilon})
+
+used for hardness of pattern matching tasks, cf [amir2014hardness]
+
+can be done in time O(N log N) for N the maximal value using [fast_fourier_transform]
+
+Up: [fine_grained_complexity_problems]
+
+See also: [negative_triangle], [ov_conjecture]
diff --git a/3sum_hypothesis b/3sum_hypothesis
@@ -0,0 +1,14 @@
+# 3SUM hypothesis
+
+Hypothesis that you cannot do [3sum] in O(n^{2-\epsilon})
+
+Implies [exact_triangle]
+
+The input numbers can be assumed to be O(n^3) [fischer2023deterministic]
+
+[fischer2024deterministic]: [reductions] from [3sum] can usually be made [reduction_deterministic]
+- connections to [hashing_additive]
+
+Up: [computational_hypothesis] on [3sum]
+
+Aliases: 3sum conjecture
diff --git a/4_partition b/4_partition
@@ -0,0 +1,13 @@
+# 4-PARTITION
+
+Given integers, partition them into quadruples having the same value
+
+[strongly_np_complete] (UNARY-4-PARTITION)
+
+[4_partition_hardness_proof]
+
+See also: [3_partition]
+
+Up: [decision_problem]
+
+See also: [partition_problem]
diff --git a/4_partition_hardness_proof b/4_partition_hardness_proof
@@ -0,0 +1,23 @@
+# 4_partition_hardness_proof
+
+Proof in http://courses.csail.mit.edu/6.890/fall14/6046-L16.pdf
+reduction from [3_dimensional_matching]
+- write numbers in a large [basis]
+- the i-th element xi is coded as (10, i, 0, 0, 1)
+ and many copies of (11, i, 0, 0, 1)
+- the j-th element yj is coded as (10, 0, j, 0, 2)
+ and many copies of (11, 0, j, 0, 2)
+- the k-th element zk is coded as (10, 0, 0, k, 4)
+ and many copies of ( 8, 0, 0, k, 4)
+- a triple (xi, yj, zk) is coded as
+ (10, -i, -j, -k, 8)
+- the target to reach for each 4-tuple is: (40, 0, 0, 0, 15)
+- the basis is large so, starting from least significant digits:
+ - use one value from each type
+ - match each triple with a matching zk
+ - match each triple with a matching yj
+ - match each triple with a matching xi
+ - match a triple with the used elements, or match a triple with unused elements
+ - so each real element (labeled 10) of the xi yj zk must appear in exactly one triple
+
+Up: [4_partition]
diff --git a/ac b/ac
@@ -0,0 +1,16 @@
+# AC
+
+"alternating" circuit class: ACi is the class of [formal_language] recognized by [boolean_circuit] of polynomial number of gates of unbounded [fan_in] and with depth O(log^i n)
+
+- [ac0]: constant depth
+- [ac1]: singly logarithmic depth
+
+This is like [nc] but:
+- with AC the gates have unbounded fan-in
+- with NC they have constant fan-in:
+
+Hence: NCi is included in ACi which is included in NCi+1 for all i
+
+Generalization: class [acc] where we allow [modulo_gate]
+
+Up: [circuit_classes]
diff --git a/ac0 b/ac0
@@ -0,0 +1,9 @@
+# Ac0
+
+[ac] circuit with constant [depth] (and unbounded [fan_in], and polynomial size)
+
+AC0 = [first_order_logic] + arbitrary numerical predicates arbitrary arity
+
+Up: [ac]
+
+See also: [acc0]
diff --git a/academic_paper_list b/academic_paper_list
@@ -0,0 +1,19 @@
+# Academic paper list
+
+- [arenas2020fpras]
+- [arenas2021nfa]
+- [bagan2020trichotomy]
+- [berkholz2020constant]
+- [feldman2006directed]
+- [freydenberger2021splitting]
+- [freydenberger2021theory]
+- [grohe2007complexity]
+- [jha2012tractability]
+- [kosolobov2017detecting]
+- [lanzinger2021tractability]
+- [lutz2022complete]
+- [marx2013tractable]
+- [merkl2023diversity]
+- [tziavelis2022any]
+
+Up: [list_wiki] of [academic_paper]
diff --git a/acc b/acc
@@ -0,0 +1,7 @@
+# Acc
+
+Like [ac] circuits, so polynomial size unbounded [fan_in] and [depth] in O(log^i n), but adds gates that can count modulo a fixed integer
+- contains [parity]
+- [acc0]: constant [depth]
+
+Up: [circuit_classes]
diff --git a/acc0 b/acc0
@@ -0,0 +1,9 @@
+# Acc0
+
+[acc] circuit with constant [depth]
+
+strict superset of [ac0], separated by [parity]
+
+Up: [acc]
+
+See also: [ac0]
diff --git a/access_pattern b/access_pattern
@@ -0,0 +1,6 @@
+# Access patterns
+
+- kara2022conjunctive [incremental_maintenance]
+- zhao2023space: [complexity_space]/[complexity_time] tradeoff
+
+Up: [database_theory]
diff --git a/ackermanns_function b/ackermanns_function
@@ -0,0 +1,10 @@
+# Ackermanns_function
+
+A(1) = 1+1 [addition]
+A(2) = 2x2 = 2+2 [multiplication]
+A(3) = 3^3 = 3×3x3 [exponentiation]
+A(4) = 4 [tetration] 4 = 4^(4^(4^4)) [tetration]
+
+Up: [mathematics]
+
+See also: [inverse_ackermann]
diff --git a/acyclic_free_connex b/acyclic_free_connex
@@ -0,0 +1,11 @@
+# Acyclic free-connex
+
+Subclass of [conjunctive_query_acyclic] which remains acyclic when adding an atom covering the [free_variable]s
+
+Some people don't say "acyclic" and take "free-connex" to mean "acyclic free-connex"
+
+When a query is not acyclic free-connex you can often reduce from [boolean_matrix_multiplication] (if [acyclic]) or [hyperclique]
+
+Up: [conjunctive_query_acyclic]
+
+See also: [enumeration_cqs]
diff --git a/aggregation b/aggregation
@@ -0,0 +1,5 @@
+# Aggregation
+
+See also: [quantile], [median], [mean], [sum]
+
+Up: [database_theory]
diff --git a/agm_bound b/agm_bound
@@ -0,0 +1,20 @@
+# AGM bound
+
+Statement: for Q(X) a [conjunctive_query_full], if every relation contains at most m tuples, then the size of the query result is at most m^{f} for f the [fractional_edge_cover] of Q
+
+Only works with [cardinality_constraint], not with [degree_constraint]
+
+- AGM bound with [projection]: [gottlob2012size]
+
+Lower bound: [agm_lower_bound]
+
+Remark by [mahmoud_abo_khamis]: the reverse of AGM bound is [turan_theorem], largest graph to avoid a pattern
+- remark that if you fix the number of vertices of a graph then if the number of edges is larger than some value then there must be a [triangle]
+ - the bound turns out to be the number of edges in a [graph_bipartite] on this set of vertices
+ - cf [ramsey_theorem] also?
+
+See also: [optimal_joins], [heavy_light]
+
+Up: [computer_science]
+
+Tags: #wikipedia
diff --git a/aho_corasick b/aho_corasick
@@ -0,0 +1,9 @@
+# Aho Corasick
+
+A nice algorithm to build an [automaton] for efficient [pattern_matching] with a dictionary.
+
+Up: [pattern_matching]
+
+See also: [knuth_morris_pratt]
+
+Aliases: Aho-Corasick, Aho-Corasick algorithm, Aho Corasick algorithm
diff --git a/akmal2021majority b/akmal2021majority
@@ -0,0 +1,7 @@
+# Akmal2021majority
+
+about [maj_sat] and [gt_maj_sat]
+
+uses [sunflower_lemma]
+
+Up: [academic_paper]
diff --git a/algebra b/algebra
@@ -0,0 +1,9 @@
+# Algebra
+
+- [algebraic_automata_theory]
+- [algebraic_structure]
+- [matrix]
+- ...
+- [vector_space]
+
+Up: [mathematics]
diff --git a/algebraic_automata_theory b/algebraic_automata_theory
@@ -0,0 +1,14 @@
+# Algebraic automata theory
+
+- [variety] closed under [inverse_morphism], left/right [quotient], [sublanguage],
+ [boolean_set_operation] including [complementation]
+ - [variety_li] li-variety: closure only under inverses of length-increasing [length_increasing_morphism] pin2016dot
+ - connection to notion of +-variety
+ - lm-variety?
+- Eilenberg's variety theorem [eilenbergs_theorem]: varieties of [monoid]
+ correspond to varieties of [regular_language]
+- [reitermans_theorem]: varieties can be defined by [profinite] identities,
+ i.e., varieties on profinite words
+- [greens_relations]
+
+Up: [formal_language_theory], [algebra]
diff --git a/algebraic_structure b/algebraic_structure
@@ -0,0 +1,12 @@
+# Algebraic structure
+
+- [monoid]
+- [semigroup]
+- [group]
+- [semiring]
+- [ring]
+- [field]
+- [ideal]
+- ...
+
+Up: [mathematics]
diff --git a/algorithm_combinatorial b/algorithm_combinatorial
@@ -0,0 +1,9 @@
+# Combinatorial algorithm
+
+Algorithms, e.g., for [matrix_multiplication] which try to exclude [strassens_algorithm], but it looks like there is not formal definition of the concept
+
+Up: [algorithms]
+
+See also: [matrix_multiplication]
+
+Aliases: combinatorial algorithm, combinatorial algorithms
diff --git a/algorithm_randomized b/algorithm_randomized
@@ -0,0 +1,19 @@
+# Randomized algorithms
+
+https://en.wikipedia.org/wiki/Randomized_algorithm
+
+Techniques used for randomized algorithms:
+
+- [concentration_inequality]
+- [median_trick]: repeat an algorithm many times and take the median
+- [monte_carlo_algorithm]
+- [las_vegas_algorithm]
+- [atlantic_city_algorithm]
+
+- [yaos_principle]
+
+Up: [algorithms]
+
+See also: [fpras], [rp], [complexity_random], [randomness]
+
+Aliases: randomized
diff --git a/algorithm_type b/algorithm_type
@@ -0,0 +1,9 @@
+# Algorithm type
+
+- [bruteforce]
+- [backtracking]
+- [greedy_algorithm]
+- [memoization]
+- [dynamic_programming]
+
+Up: [algorithms_list]
diff --git a/algorithms b/algorithms
@@ -0,0 +1,22 @@
+# Algorithms
+
+Notion: [algorithm]
+
+List of algorithms: [algorithms_list]
+
+Type:
+- [algorithm_combinatorial]
+- [algorithm_randomized]
+- [greedy_algorithm]
+
+By date:
+- [algorithms_recent]: a choice of recent algorithms on major [computational_problem]
+
+[machine_model]:
+- [external_memory]
+
+[algorithms_techniques]
+
+See also: [reduction]
+
+Up: [theoretical_computer_science]
diff --git a/algorithms_list b/algorithms_list
@@ -0,0 +1,21 @@
+# Algorithms list
+
+- On [graph]: [graph_algorithm]
+- [sampling]
+- [batch_partial_match]
+- [sorting]
+- [segment_tree]
+- [fenwick_tree]
+- [median]
+ - [median_of_medians]
+- [huffman_algorithm]
+- [sliding_window] algorithms
+- [fast_exponentiation]
+- [selection_algorithm]
+- [tortoise_and_hare_algorithm]
+- [stable_marriage]
+- [binary_search]
+
+- [algorithm_type]
+
+Up: [algorithms]
diff --git a/algorithms_recent b/algorithms_recent
@@ -0,0 +1,8 @@
+# Recent algorithms
+
+There has been recent progress on algorithms on the following problems:
+
+- [network_flow] (2022)
+- [shortest_path] (2022)
+
+Up: [algorithms]
diff --git a/all_edge_triangle b/all_edge_triangle
@@ -0,0 +1,9 @@
+# all edge triangle
+
+Problem of deciding, given an undirected [graph], for each edge, whether it is in a [triangle]
+
+This requires time Omega(n^{2-o(1)}) assuming [3sum_hypothesis]
+
+See also: [st_reachability], [triangle_detection]
+
+Up: [computational_problem] on [graph]
diff --git a/all_pairs_shortest_path b/all_pairs_shortest_path
@@ -0,0 +1,30 @@
+# All pairs shortest path (APSP)
+
+Given a [graph], compute the [distance] between all pairs of nodes
+
+Many works have tried to shave off logs; best algorithm by [ryan_williams]: n^3/exp(sqrt(log n))
+
+Hypothesis [apsp_hypothesis]
+
+The unweighted version amounts to [transitive_closure], which can be solved by [matrix_multiplication]
+- also some algorithms for small weights
+- APSP is [matrix_multiplication] but on [tropical_semiring], see [distance_product]
+
+APSP can be expressed in [datalog] with the right kind of [aggregation], in linear or binary form
+
+Algorithm: [floyd_warshall_algorithm]
+
+Reduction to [distance_product]
+
+[johnsons_algorithm]: in O(mn) we can transform to remove the negative weights
+
+connection between APSP and [distance_product] ([matrix_multiplication] in [semiring_tropical]), like for [reachability_all_pairs]: running times are the same up to log factors
+- and with [negative_triangle]: one is subcubic iff the other is
+
+Approximation: [all_pairs_shortest_path_approximate]
+
+Beware: APSP can also mean "All pairs suffix prefix", cf [gusfield1992efficient], [zuba2024approximate]
+
+Up: [shortest_path], [fine_grained_complexity_problems]
+
+See also: [reachability_all_pairs]
diff --git a/all_pairs_shortest_path_approximate b/all_pairs_shortest_path_approximate
@@ -0,0 +1,17 @@
+# All pairs shortest path approximate
+
+See also roditty2023new
+
+For approximation ratio alpha<2, with directed or undirected graph, reduction from [boolean_matrix_multiplication] (exact?)
+
+for approximation (1+eps), zwick2022?: Otilde(n^omega/eps log W)
+- if the graph is undirected we can shave off the log W
+- if directed we can shave off the log W but at the expense of a worse exponent, and equivalence to "exact MinMaxProduct"?
+
+connection to approximate [distance_product] (equivalence up to log factors)
+
+for an undirected graph, for any k, we can preprocess the graph in O(m n^{1/k}) such that for each pair we obtain in constant time a 2k-1 approximation of the distance
+- and lower bound from [3sum]: under this preprocessing and with n^{o(1)} query time we cannot have <k approx (work involving [amir_abboud])
+- "hardness of approximation in P"?
+
+Up: [approximation] of [all_pairs_shortest_path]
diff --git a/all_pos_neg_sat b/all_pos_neg_sat
@@ -0,0 +1,7 @@
+# ALL-POS-NEG-SAT
+
+[satisfiability_cnf] but in each clause either all [literals] are [positive_literal] or all [literals] are [negative_literal]
+
+[NP_complete] in [lingg2024learning]
+
+Up: [sat_variants]
diff --git a/all_subset_sums b/all_subset_sums
@@ -0,0 +1,11 @@
+# All subset sums
+
+Problem like [subset_sum] but there is no target and you must compute all the sums
+
+according to [bringmann2023top], all [pseudo_polynomial_time] algorithms for [subset_sum] actually solve [all_subset_sums]
+
+can be solved in Otilde(sum of values), for input encoded in unary for instance, see [all_subset_sums_fft]
+
+Up: [subset_sum]
+
+See also: [subset_sum_counting]
diff --git a/all_subset_sums_fft b/all_subset_sums_fft
@@ -0,0 +1,14 @@
+# All subset sums with FFT
+
+[Algorithm] for [all_subset_sums] using [FFT], running in Otilde(sum of the elements).
+
+Useful if the input is coded in [unary] for instance
+
+Source: [koiharis2019faster], Theorem 3.1
+
+Algorithm:
+- split elements into two halves
+- compute recursively all the sums of the halves
+- merge the sums using [FFT]
+
+Up: [algorithm] for [all_subset_sums]
diff --git a/alpha_acyclic b/alpha_acyclic
@@ -0,0 +1,23 @@
+# Alpha acyclic
+
+Condition on [hypergraph]
+
+On [graph_undirected], equivalent to [graph_acyclic]
+
+Equivalent to [running_intersection_property]
+
+Equivalent to having a [join_tree]
+
+Equivalent to being both [hypergraph_conformal] and [hypergraph_chordal]
+
+Equivalent to [querywidth] and [hypertreewidth] and [generalized_hypertreewidth] being 1
+
+Defining paper proving the equivalences: [beeri1983desirability]
+
+Can be checked on [hypergraph_reduced], i.e., hyperedges that are covered by another hyperedge do not matter
+
+Can be tested in [linear_time] using [tarjan1984simple] via [chordal] and [hypergraph_chordal], but non-obvious
+
+Up: [degree_of_acyclicity]
+
+See also: [acyclic_hypergraph_sandwich_problem]
diff --git a/alternating_path b/alternating_path
@@ -0,0 +1,11 @@
+# Alternating path
+
+When considering a [graph] and a [matching], a path that takes matched and unmatched edges alternatively
+
+[augmenting_path] "Augmenting path": alternating path that goes between two unmatched vertices
+
+Occurs in algorithms for [maximum_matching]
+
+
+
+Up: [path]
diff --git a/alternation_hierarchy b/alternation_hierarchy
@@ -0,0 +1,7 @@
+# Alternation hierarchy
+
+Hierarchy of [first_order_logic] on [quantifier_alternation_depth]
+
+Up: [hierarchy] of [first_order_logic]
+
+See also: [automata_alternating], [alternation], [dot_depth]
diff --git a/amplification_technique b/amplification_technique
@@ -0,0 +1,9 @@
+# Amplification technique
+
+can be used to show that [sharp_is] has no [fpras]
+
+cf git/reading-group/notes/non-approximability.txt
+
+[marcelo]: This is a reference for the amplification technique:Alistair Sinclair: Algorithms for random generation and counting - a Markov chain approach. Progress in theoretical computer science, Birkhäuser 1993, ISBN 978-0-8176-3658-6, pp. 1-146
+
+See also: [interpolation_method]
diff --git a/annotation_transducer b/annotation_transducer
@@ -0,0 +1,9 @@
+# Annotation transducer
+
+formalism of [automata]
+- called "annotated automata] in [munoz2023constant]
+- used in [gawrychowski2024revisiting]
+
+Up: [spanner]
+
+See also: [spanner_transducer]
diff --git a/approximate_sampling_to_approximate_counting b/approximate_sampling_to_approximate_counting
@@ -0,0 +1,29 @@
+# Approximate sampling to approximate counting
+
+## For independent set
+
+This file uses the notation of [markov_chain_monte_carlo]. It focuses on the problem of [counting] [independent_set], i.e., computing the probability that a random subset of vertices is an independent set.
+
+### With exact sampling
+
+First assume we can do [sampling] exactly.
+
+The probability that we want to compute is pi(emptyset) = 1/Z, because it gives us Z which is the quantity for which we want to do [counting]
+
+We can write pi(emptyset) as Pr(X1=0) Pr(X2=0|X1=0) ...
+
+So if we can approximate each [marginal_distribution] then we can approximate pi(emptyset)
+
+We can marginalize in the following way: to set a vertex to 0, we just remove the vertex! A kind of [self_reducibility]. Note that removing a vertex does not increase Delta.
+
+Further, we know that the marginals have probability at least 1/(1+lambda), hence sampling (on the graph with removed vertices, seeing in which proportion of the samples we find the vertex of interest) gives an [approximation_additive] which thanks to the lower bound is an [approximation_multiplicative].
+
+### With approximate sampling
+
+I think the same algorithm works if sampling is approximately uniform
+
+## In general
+
+In general (for an arbitrary self-reducible problem): instead of picking the prefix 0 ... 0, choose the prefix with the choice that gives the most outcomes. This ensures that no denominator gets to zero, and also ensures a lower bound of 1/2 (give or take epsilon) on each marginal
+
+Up: [sampling_approximate], [counting_approximate]
diff --git a/approximation b/approximation
@@ -0,0 +1,30 @@
+# Approximation
+
+Two kinds of approximation:
+- [approximation_additive]: section 3.2.1 souihli2012querying [monte_carlo] [hoeffdings_inequality]
+- [approximation_multiplicative]: what follows is about those
+
+Complexity classes [approximation_class]:
+- [FPRAS]
+- [PRAS]
+- etc.
+
+Problems: [approximation_problems]
+
+Reasons not to get it:
+- conditional inapproximability [fpras_vs_npc]: no FPRAS if the [decision_problem] "décision =0" is [np_hard], unless you have [nptime] = [bpp] or [nptime] = [rp]
+- [sharp_is]: no FPRAS to count the [independent_set] of a [graph]
+- no [FPRAS] for [monotone2cnf] (calautti2022query), cf [sharp_satisfiability_fpras]
+- [hardness_of_approximation]
+
+Applications:
+- [sampling_approximate]
+- [counting_approximate]
+
+- [approximation_pqe]
+
+Notion of [reduction]: [approximation_preserving_reduction]
+
+Up: [research_directions]
+
+Aliases: approximate counting
diff --git a/approximation_additive b/approximation_additive
@@ -0,0 +1,10 @@
+# Additive approximation
+
+[approximation] while keeping an additive error bound
+
+- Can be obtained by [monte_carlo] for [pqe]
+- But not for [model_counting]: [chakraborty2019hardness] Theorem 3
+
+See also: [approximation_multiplicative]
+
+Up: [approximation]
diff --git a/approximation_class b/approximation_class
@@ -0,0 +1,11 @@
+# Approximation classes
+
+- FPRAS [fpras]: for all epsilon you have an [algorithm_randomized] running in polynomial time in 1/e and in the input, with a probability delta of failure
+ - variant QPRAS [qpras] with "quasi-polynomial time" [quasipolynomial]
+- PRAS [pras]: same but not polynomial in 1/e
+- without R, a deterministic algorithm (PRAS vs PTAS [ptas], FPRAS vs FPTAS [fptas])
+- APX [apx]: there is an approximation algorithm for a certain fixed epsilon
+
+Up: [complexity_class] of [approximation]
+
+See also: [complexity_random]
diff --git a/approximation_multiplicative b/approximation_multiplicative
@@ -0,0 +1,9 @@
+# Approximation multiplicative
+
+Possible for [sharp_satisfiability] for [disjunctive_normal_form], and many other problems
+
+Another example is arenas2021nfa
+
+See also: [approximation_additive], [fpras]
+
+Up: [approximation]
diff --git a/approximation_problem b/approximation_problem
@@ -0,0 +1,8 @@
+# Approximation algorithm
+
+- [all_pairs_shortest_path_approximate]
+- [sharp_satisfiability_approximate]
+
+See also: [fpras]
+
+Up: [computational_problem] for [approximation]
diff --git a/apsp_hypothesis b/apsp_hypothesis
@@ -0,0 +1,12 @@
+# APSP hypothesis
+
+[hypothesis] that [all_pairs_shortest_path] (also involving negative weights) requires time n^{3-o(1)}
+- implies [exact_triangle]
+- equivalent to [negative_triangle]
+ - you can use [all_pairs_shortest_path] to compute [negative_triangle]
+ - other direction more involved
+- equivalent to [mpp_minimum] (find if the minimum diagonal entry of the min-plus product of three matrices A B C is <0)
+
+The equivalences to [all_pairs_shortest_path] and [mpp_minimum] are from [williams2018subcubic]
+
+Up: [hypothesis] on [all_pairs_shortest_path]
diff --git a/apsp_reduces_to_distance_product b/apsp_reduces_to_distance_product
@@ -0,0 +1,10 @@
+# APSP reduces to distance product
+
+[fine_grained_reduction] from [all_pairs_shortest_path] to computing [distance_product]
+
+Take [adjacency_matrix] of a [graph], do [fast_exponentiation] to get the weight of
+the [shortest_path] of <= n edges
+
+
+
+Up: [reduction] from [all_pair_shortest_path] to [distance_product]
diff --git a/apx b/apx
@@ -0,0 +1,22 @@
+# APX
+
+class of [nptime] [optimization_problem] with [approximation] in polynomial time
+with a ratio bounded by a constant
+- analogue but for [counting_problem]?
+
+Being in this class is weaker than existence of a [ptas], and if P neq NP then there are problems in [apx] that do not have a [ptas]
+
+- [apx]-hard: as hard as problems that can be approximated within constant factor
+- [log_apx]-hard: as hard as problems that can be approximated within a log factor
+- [poly_apx]-hard:
+ - for instance [maximum_independent_set]
+- on a [apx] subsetneq [log_apx] subsetneq [poly_apx]
+ - et ces inclusions sont strictes si P neq NP, reference [escoffier2007structures]
+
+reference: [lee2021classifying]
+
+[apx_counting]
+
+See also: [approximation_algorithm]
+
+Up: [complexity_class]
diff --git a/arboricity b/arboricity
@@ -0,0 +1,13 @@
+# Arboricity
+
+Connection between [arboricity] and [dynamic_data] in lu2021towards
+
+- chiba1985arboricity
+- danisch2018listing
+ - https://papers-gamma.link/paper/32
+ - https://github.com/maxdan94/kmotif
+- ortmann2014triangle algorithm for triangle_listing
+
+bressan2022complexity: optimality of the esults of chiba for [graph_pattern_counting]
+
+Up: [width_measure]
diff --git a/arenas2020fpras b/arenas2020fpras
@@ -0,0 +1,12 @@
+# arenas2020fpras
+
+FPRAS [fpras] to count the number of [tree] of a given size accepted by nondeterministic
+[tree_automaton]
+
+Proof sketch in [arenas2022counting]
+
+Note: it is [sharpp]-hard to exactly count the number of distinct words of length n accepted by an NFA A, given n and A as input
+
+
+
+Up: [academic_paper_list]
diff --git a/arithmetic b/arithmetic
@@ -0,0 +1,11 @@
+# Arithmetic
+
+- [fundamental_theorem_of_arithmetic]
+ - [prime_number_decomposition]
+- [prime_number]
+- [integer_factorization]
+- [presburger_arithmetic]
+
+Up: [mathematics]
+
+See also: [number_theory]
diff --git a/arithmetic_circuit b/arithmetic_circuit
@@ -0,0 +1,34 @@
+# Arithmetic circuit
+
+A [circuit] having plus-gates and times-gates. The inputs to plus-gates have
+weights ([linear_combination]). Generally the function represented should be
+non-negative.
+- allowing negative weights (-> subtraction) can have a superpolynomial impact on conciseness
+ - cf [positive_vs_monotone]
+- "monotone arithmetic circuit": no negative weights
+
+Conditions:
+- [decomposable] aka "syntactic multilinearity"
+ - [structuredness] structured decomposability
+- [deterministic]
+- [smoothness] / [smoothing]
+
+Arithmetic circuits *with positive weights* can be translated to a
+[boolean_circuit] while preserving struural restrictions. Thus, for arithmetic functions whose support is a
+hard boolean function, we can leverage lower bounds on the [boolean_circuit] size
+to get a bound on the arithmetic circuit size
+
+Can use [rank] technique for lower bound, using [communication_complexity]
+- but [arithmetic_rectangle] instead of [combinatorial_rectangle]
+
+closure:
+
+- we can represent the product of two structured circuits as a structured circuit
+if they are structured along the same [vtree]
+- conditioning: we can fix the value of a gate and preserve decomposability etc.
+
+[depth_reduction_arithmetic_circuit]
+
+Up: [circuit]
+
+See also: [circuit_algebraic]
diff --git a/arithmetic_progression b/arithmetic_progression
@@ -0,0 +1,15 @@
+# Arithmetic progression
+
+[roths_theorem]
+- and generalization [szemeredis_theorem]
+
+[open_problem]: https://en.wikipedia.org/wiki/Erd%C5%91s_conjecture_on_arithmetic_progressions
+
+arbitrary long arithmetic progressions in [prime_numbers]:
+ - https://en.wikipedia.org/wiki/Green%E2%80%93Tao_theorem
+
+Up: [sequence]
+
+See also: [salem_spencer_set]
+
+Aliases: arithmetic progressions
diff --git a/arity b/arity
@@ -0,0 +1,8 @@
+# Arity
+
+- [arity_two] vs [higher_arity]
+- [graph] versus [hypergraph]
+- [shredding]: transform arity-n into [arity_two]; name used in
+ [amarilli2015combining]
+
+Up: [logic]
diff --git a/array b/array
@@ -0,0 +1,8 @@
+# Array
+
+- [binary_search]
+- [sorted_array]
+
+Up: [data_structure]
+
+See also: [list]
diff --git a/ascending_chain_condition b/ascending_chain_condition
@@ -0,0 +1,12 @@
+# Ascending chain condition (ACC)
+
+A [partial_order] satisfes the ACC if every [omega_chain] is finite
+(= stabilizes)
+
+The [pareto_product] of two [partial_order] that satisfies ACC also satisfies ACC. The same holds for finite powers.
+
+The ACC ensures that [kleene_sequence] (see [fixpoint]) converges to least fixpoint
+
+ACC implies [omega_complete]
+
+Up: [partial_order]
diff --git a/atom b/atom
@@ -0,0 +1,9 @@
+# Atom
+
+notion of an atom in logic
+
+- [logic_atom] for logics extended with infinite values
+
+See also: [vector_addition_system], [data_word]
+
+Up: [logic]
diff --git a/automata b/automata
@@ -0,0 +1,16 @@
+# Automata
+
+https://en.wikipedia.org/wiki/Finite-state_machine
+
+- [automata_concepts]
+- [automata_types]
+- [state_complexity]
+- [regular_language]
+- [automata_problems]
+- [automata_constructions]
+- [automata_evaluation]
+- [automata_classes]
+
+Up: [theoretical_computer_science], [formal_language_theory]
+
+Aliases: automaton
diff --git a/automata_acyclic b/automata_acyclic
@@ -0,0 +1,9 @@
+# Automata acyclic
+
+[Automaton] whose underlying [directed_graph] is a [DAG].
+
+Recognizes a [finite_language]
+
+Up: [automata_classes], [automata_weakly_acyclic]
+
+Aliases: acyclic automata, acyclic automaton
diff --git a/automata_bideterministic b/automata_bideterministic
@@ -0,0 +1,10 @@
+# Automata bideterministic
+
+[automata] which are [deterministic] and where the [automata_reversal] is also [deterministic]
+- in particular exactly one [initial_state] and [final_state]
+
+Characterization: a [formal_language] is recognized by a bideterministic automaton iff the [minimal_automaton] of the language is reversible and has a unique [final_state] ([pin1992reversible] proposition 2.1)
+
+Generalization: [automata_reversible] [pin1992reversible]
+
+Up: [word_automaton]
diff --git a/automata_complementation b/automata_complementation
@@ -0,0 +1,7 @@
+# Automata complementation
+
+- in [linear_time] for [automata_deterministic]
+- exponential lower bound on [state_complexity] for [automata_nondeterministic]
+- hard also for [word_automaton_unambiguous]
+
+Up: [complementation], [automata]
diff --git a/automata_concepts b/automata_concepts
@@ -0,0 +1,13 @@
+# Automata concepts
+
+- [state]
+ - [initial_state]
+ - [final_state]
+ - [sink_state]
+ - [transient_state]
+- [transition]
+- [alphabet]
+- [run]
+ - [accepting_run]
+
+Up: [automata]
diff --git a/automata_constructions b/automata_constructions
@@ -0,0 +1,12 @@
+# Automata constructions
+
+- [chrobak_normal_form]
+- [powerset_automata] for [automata_determinization]
+- [minimization_automaton]
+- [automata_reversal], does not preserve [automata_determistic]
+- [automata_complementation]
+- [product_automaton], for [automaton_intersection]
+
+Up: [automata]
+
+Aliases: automaton construction, automaton constructions
diff --git a/automata_deterministic b/automata_deterministic
@@ -0,0 +1,8 @@
+# Automata deterministic
+
+[automata] where for each [state] and [letter] there is at most one outgoing [transition]
+- possibly none for [automata_incomplete]
+
+Up: [automata_types], [determinism_language]
+
+Aliases: automaton deterministic, deterministic automaton, deterministic automata, DFA, DFAs
diff --git a/automata_local b/automata_local
@@ -0,0 +1,11 @@
+# Local automata
+
+[Automaton] where for each [letter] all [transitions] with this [letter] lead to the same [state]
+
+The [local_languages] are the [formal_languages] that can be recognized by such automata
+
+Up: [automata_classes]
+
+See also: [automaton_homogeneous], [glushkov_automaton]
+
+Aliases: local automata
diff --git a/automata_nondeterministic b/automata_nondeterministic
@@ -0,0 +1,9 @@
+# Automata nondeterministic (NFA)
+
+There are known upper bounds on the size of the smallest [automata_deterministic] corresponding to an NFA
+
+Up: [nondeterministic], [automata_types]
+
+See also: [epsilon_transition]
+
+Aliases: nondeterministic automaton, nondeterministic automata, NFA, NFAs
diff --git a/automata_problems b/automata_problems
@@ -0,0 +1,15 @@
+# Automata problems
+
+- [synchronizing_word]
+- [separating_automaton]
+- [automaton_emptiness]
+- [automaton_finiteness]
+- [universality_automata]
+- [minimization_automaton]
+- [automaton_inclusion]
+- [automaton_equivalence]
+- [automaton_cofiniteness]
+- [automata_evaluation]
+- [automaton_acceptance]
+
+Up: [automata]
diff --git a/automata_random b/automata_random
@@ -0,0 +1,7 @@
+# Automata random
+
+- [random_dfa]
+
+Up: [automata], [randomness]
+
+See also: [random_graph]
diff --git a/automata_reversible b/automata_reversible
@@ -0,0 +1,15 @@
+# Reversible automata
+
+Described in [pin1992reversible]
+
+[automata_deterministic] and [automata_co_deterministic] (about [automata_reverse])
+
+Extends [automata_bideterministic] by lifting the requirement of having exactly one [initial_state] and exactly one [final_state]
+
+Class of [formal_language] accepted by a reversible automaton
+- is closed under [union]
+- membership given an [automata] can be tested in [ptime] pin1992reversible
+
+See also: [turing_machine_symmetric], [automata_symmetric], [transducer_reversible]
+
+Up: [word_automaton]
diff --git a/automata_self_verifying b/automata_self_verifying
@@ -0,0 +1,7 @@
+# Automata self verifying
+
+- [word_automaton_self_verifying]
+
+Up: [automata_classes]
+
+Aliases: self-verifying automaton, self-verifying automata, self verifying automaton, self verifying automata,
diff --git a/automata_symmetric b/automata_symmetric
@@ -0,0 +1,10 @@
+# Symmetric automata
+
+Studied in [kutrib2022finite] in a [deterministic] and [nondeterministic] setting
+
+- open if class is closed under [reversal]
+- complexity of testing if an input language is of this form is open
+
+See also: [automata_reversible], [turing_machine_symmetric]
+
+Up: [automata]
diff --git a/automata_two_way b/automata_two_way
@@ -0,0 +1,16 @@
+# Automata two way
+
+automata that can read the input in both directions
+
+It is [open_problem] if two-way automata can be determinized in [ptime] and related to open problems in [complexity_theory], cf [kapoutsis2013two]:
+[sakoda_sipser_conjecture]
+
+Can be converted back to [automata_one_way].
+- Elementary construction to get an [automata_nondeterministic] for the complement language in [vardi1989note] with exp(n) blowup
+- Elementary construction to get an [automata_deterministic] for the language in [shepherdson1959reduction] with exp(n^2) blowup
+
+Up: [automata]
+
+See also: [2rpq]
+
+Aliases: two-way automaton, two-way automata
diff --git a/automata_types b/automata_types
@@ -0,0 +1,33 @@
+# Automata types
+
+- [automata_deterministic]
+ - [determinism]
+- [automata_nondeterministic]
+- [automaton_epsilon_transitions]
+- [automata_unambiguous]
+- [automata_bideterministic]
+- [tree_automaton]
+- [word_automaton]
+ - [word_automaton_self_verifying]
+ - [word_automaton_unambiguous]
+ - [unambiguity]
+- [transducer]
+- [automata_alternating]
+- [automata_generalized]
+- [automata_trimmed]
+- [automaton_complete]
+- [automata_incomplete]
+
+## Extensions
+
+- [stack_automata]
+ - [pushdown_automaton]
+- [queue_automata]
+- [counter_automata]: deterministic one-counter automaton
+- [register_automata]
+- [automatic_relation]
+- [vector_addition_system]
+- [automata_weighted]
+- [omega_automata]
+
+Up: [automata]
diff --git a/automata_unary_ufa b/automata_unary_ufa
@@ -0,0 +1,10 @@
+# Automata unary UFAs
+
+bounds in [okhotin2012unambiguous]:
+- on the [state_complexity] of [automata_determinization] (ad hoc function)
+- on the [state_complexity] of [kleene_star] ([quadratic])
+- on the [state_complexity] of [complementation] ([quadratic])
+
+Up: [automata_unary], [word_automaton_unambiguous]
+
+Aliases: unary UFA, unary UFAs
diff --git a/automata_weighted b/automata_weighted
@@ -0,0 +1,17 @@
+# Automata weighted
+
+[automata] with [weight]s on [transition]s and on [final_state]s
+
+associates each [word] to an [integer]
+
+given a [word]:
+- [sum] over possible [run]s
+- [product] over [transition]s and [final_state]s used
+
+can be done in [semiring]
+
+Up: [automata]
+
+See also: [weighted_mso]
+
+Aliases: weighted automaton, weighted automata, automaton_weighted
diff --git a/automatic_relation b/automatic_relation
@@ -0,0 +1,11 @@
+# Automatic relation
+
+Relation on words defined by [automaton]: you read two words with a padding
+symbol, i.e., [automaton_synchronous]
+
+- Paper about this: [barcelo2023separating]
+- [automatic_relation_algebra]
+
+Up: [automata], [relation]
+
+See also: [automatic_structure], [automatic_graph], [sequence_automatic]
diff --git a/automaton_cofiniteness b/automaton_cofiniteness
@@ -0,0 +1,8 @@
+# Automaton cofiniteness
+
+[ptime] on [automata_deterministic] by [complementation] and [automaton_finiteness]
+
+[pspace_complete] on [automata_nondeterministic]:
+- https://cstheory.stackexchange.com/questions/54090/complexity-of-nfa-cofiniteness
+
+Up: [automata_problems]
diff --git a/automaton_emptiness b/automaton_emptiness
@@ -0,0 +1,7 @@
+# Automaton emptiness
+
+[nl_complete] to check [automaton] emptiness
+
+Up: [automata_problems], [language_emptiness]
+
+See also: [automaton_finiteness]
diff --git a/automaton_equivalence b/automaton_equivalence
@@ -0,0 +1,9 @@
+# Automaton equivalence
+
+[pspace_complete] on [automata_nondeterministic]
+
+[ptime] on [automata_deterministic] via [product_construction]
+
+Up: [automata_problems]
+
+See also: [language_equivalence], [automaton_inclusion]
diff --git a/automaton_homogeneous b/automaton_homogeneous
@@ -0,0 +1,9 @@
+# Automaton homogeneous
+
+[Automaton] where for every [state] q all [transitions] leading to q labeled with the same letter
+
+See also: [automata_local], [glushkov_automaton]
+
+Up: [automata_classes]
+
+Aliases: homogeneous automaton, homogeneous automata
diff --git a/automaton_inclusion b/automaton_inclusion
@@ -0,0 +1,9 @@
+# Automaton inclusion
+
+[pspace_complete] for [automata_nondeterministic]
+
+[ptime] for [automata_deterministic]
+
+Up: [automata_problems]
+
+See also: [automaton_equivalence], [language_inclusion]
diff --git a/automaton_intersection b/automaton_intersection
@@ -0,0 +1,10 @@
+# Automaton intersection
+
+can be done with [product_construction]
+
+[computational_complexity] bounds on [automaton_emptiness] of intersection of constant number of [DFAs]: [oliveira2018intersection]
+- connections to [3SUM] and [triangle_detection]
+
+Up: [automaton_constructions], [intersection]
+
+See also: [regular_expression_conjunction]
diff --git a/background_rebuilding b/background_rebuilding
@@ -0,0 +1,10 @@
+# Background rebuilding
+
+Technique for [incremental_maintenance]
+
+- Can be used for [maximum_matching_approximation]
+
+Video by [thatchaphol_saranurak] at [simons_institute]
+https://simons.berkeley.edu/talks/thatchaphol-saranurak-university-michigan-2023-08-28
+
+Up: [incremental_maintenance]
diff --git a/backreferences b/backreferences
@@ -0,0 +1,9 @@
+# Backreferences
+
+a way to refer back to something captured in a [regular_expression] (extended with captures)
+
+Up: [regular_expression]
+
+See also: [refl_spanner], [spanner], [capture_variable]
+
+Aliases: back reference, back references, back-reference, back-references
diff --git a/backurs2016which b/backurs2016which
@@ -0,0 +1,5 @@
+# Backurs2016which
+
+uses [strong_exponential_time_hypothesis] and [orthogonal_vectors]
+
+Up: [academic_paper] on [regular_expression_matching]
diff --git a/bag_semantics b/bag_semantics
@@ -0,0 +1,7 @@
+# Bag semantics
+
+when [query] returns results with multiset of occurrences
+
+Up: [database_theory]
+
+See also: [set_semantics], [containment_bag_semantics]
diff --git a/bagan2020trichotomy b/bagan2020trichotomy
@@ -0,0 +1,18 @@
+# bagan2020trichotomy
+
+Article showing [simple_path_trichotomy]
+
+## Intuition of criterion
+
+"term" = (w+eps) or (A^{\geq k} + eps)
+ with w a fixed word, and A some subalphabet
+"sequence": concatenation of terms, with fixed words before and after
+
+tractable class: disjunction of sequences
+
+tractability is not obvious! intuitively we can "shorten" thanks to the +epsilon
+
+equivalent reformulation: "closed under skipping"
+=> [algebraic_automata_theory] characterization? cf [martens2023trichotomy] in the case of [trail_trichotomy]
+
+Up: [academic_paper_list]
diff --git a/balancing b/balancing
@@ -0,0 +1,13 @@
+# Balancing
+
+Limiting the [height] of a representation
+
+- balancing [tree_decomposition]: [balancing_tree_decomposition]
+- balancing [straight_line_program]
+- [tree_balancing]
+- [depth_reduction] of [arithmetic_circuit]: [depth_reduction_arithmetic_circuit]
+- [dymond1988input] for [VPAs]
+
+Up: [theoretical_computer_science]
+
+See also: [hypergraph_balanced]
diff --git a/balancing_tree_decomposition b/balancing_tree_decomposition
@@ -0,0 +1,7 @@
+# Balancing tree decompositions
+
+[bodlaender1998parallel], used in [amarilli2018enumeration]
+
+Up: [balancing], [tree_decomposition]
+
+See also: [tree_decomposition_updating]
diff --git a/batch_partial_match b/batch_partial_match
@@ -0,0 +1,16 @@
+# Batch partial match
+
+Input:
+- a database of n vectors of {0,1}^d
+- n queries of the same form but with stars (wildcards)
+Output: for each query you want to know if a vector of the database matches
+
+Naive algorithms:
+- try all pairs: O(n^2 d)
+- preprocess all possible queries: O(2^d n)
+
+[batch_partial_match_hypothesis]
+
+Up: [fine_grained_complexity]
+
+See also: [batch_updates]
diff --git a/batch_partial_match_hypothesis b/batch_partial_match_hypothesis
@@ -0,0 +1,7 @@
+# Batch partial match hypothesis
+
+The [batch_partial_match] problem cannot be solved in O(n^{2-epsilon})
+
+Actually equivalent to [ov_conjecture]
+
+Up: [computational_hypothesis] on [batch_partial_match]
diff --git a/batch_update_technique b/batch_update_technique
@@ -0,0 +1,15 @@
+# Batch update technique
+
+Design an algo that takes a batch of [update], amortize it with [background_rebuilding], and use it to design an efficient algorithm
+- This is a "one-batch algorithm", sometimes you can do a k-batch algorithm and do nesting to get a better complexity
+
+Video by [thatchaphol_saranurak] at [simons_institute]
+https://simons.berkeley.edu/talks/thatchaphol-saranurak-university-michigan-2023-08-28
+
+## Application: Graph connectedness under edge deletion
+
+Can be used for [network_reliability] (undirected graph connectedness) under [edge_deletion]
+
+batch update algorithm: take a [spanning_tree] and represent the other edges like points in 2d following a [tree_traversal] and do [2d_range_reporting]
+
+Up: [batch_updates], [incremental_maintenance]
diff --git a/batch_updates b/batch_updates
@@ -0,0 +1,6 @@
+# Batch updates
+
+- [batch_updates_support]: supporting batch updates as an [update] operation on [dynamic_data]
+- [batch_update_technique]: using as a technique to design algorithms
+
+Up: [incremental_maintenance]
diff --git a/batch_updates_support b/batch_updates_support
@@ -0,0 +1,7 @@
+# Batch updates support
+
+The problem on [dynamic_data] to handle "batch updates" that can change several different elements in one operation, e.g., [search_and_replace]
+
+- [datta2024query] in [dynamic_complexity]
+
+Up: [batch_updates]
diff --git a/bayes_network b/bayes_network
@@ -0,0 +1,9 @@
+# Bayes network
+
+Can be "tree-structured Bayes network", or have bounded [treewidth]
+
+"naive Bayes", everything is independent
+
+Up: [probabilistic_graphical_model]
+
+See also: [message_passing], [treewidth]
diff --git a/bdd b/bdd
@@ -0,0 +1,12 @@
+# Binary decision diagram (BDD)
+
+- [obdd]
+- [fbdd]
+- [nbdd]
+
+- [zero_suppressed_semantics]
+- [bdd_complete]
+
+Up: [diagram]
+
+See also: [branching_program], [read_once_branching_program]
diff --git a/berge_graph b/berge_graph
@@ -0,0 +1,7 @@
+# Berge graph
+
+[Undirected_graph] which does not contain an [hole_odd] or an [antihole_odd]
+
+[strong_perfect_graph_theorem]: a graph is a Berge graph iff it is a [perfect_graph]
+
+Up: [graph_family]
diff --git a/bin_packing b/bin_packing
@@ -0,0 +1,11 @@
+# Bin packing
+
+Problem of fitting objects into containers
+
+[strongly_np_complete]
+
+Online version, and version with a limited number of bins opened at any time: see [dufay2022approximation]
+
+Up: [decision_problem], [optimization_problem]
+
+See also: [knapsack], [subset_sum_problem]
diff --git a/blocking_factor b/blocking_factor
@@ -0,0 +1,16 @@
+# Blocking factor
+
+Blocking factor of [language] is [word] which never occurs as [factor] of a [word] of the language
+
+- [blocking_factor_minimal]
+- [blocking_sequence]
+ - [blocking_sequence_minimal]
+
+## Meta-dichotomy
+
+even for [strongly_connected] [NFA], it's [PSPACE_complete]
+ - reduction from [NFA_universality]
+
+See also: [links_seminar_gabriel], [property_testing]
+
+Aliases: blocking factors
diff --git a/bloom_filter b/bloom_filter
@@ -0,0 +1,9 @@
+# Bloom filter
+
+https://en.wikipedia.org/wiki/Bloom_filter
+
+Also [bloom_filter_dual]
+
+Up: [data_structure]
+
+See also: [cache]
diff --git a/bloom_filter_dual b/bloom_filter_dual
@@ -0,0 +1,7 @@
+# Bloom filter dual
+
+https://cstheory.stackexchange.com/questions/6596/a-probabilistic-set-with-no-false-positives
+
+Up: [bloom_filter]
+
+See also: [cache]
diff --git a/bodirsky2024symmetric b/bodirsky2024symmetric
@@ -0,0 +1,9 @@
+# bodirsky2024symmetric
+
+- [datalog_symmetric_linear]
+- [datalog_linear]
+- [datalog_monadic]
+- [datalog_arc_monadic]
+- [datalog_symmetric_linear_arc_monadic]
+
+Up: [academic_paper] on [constraint_satisfaction_problem_datalog]
diff --git a/bonifati2017analytical b/bonifati2017analytical
@@ -0,0 +1,7 @@
+# Bonifati2017analytical
+
+inspired [martens2018evaluation]
+
+Up: [academic_paper] about [sparql_logs] and [regular_expressions_practice]
+
+See also: [sparql]
diff --git a/bool_x b/bool_x
@@ -0,0 +1,9 @@
+# Bool[x]
+
+Like [universal_semiring] but without coefficients
+
+It is a [dioid]
+
+Up: [semiring]
+
+See also: [why_provenance], [boolean_semiring]
diff --git a/boolean b/boolean
@@ -0,0 +1,9 @@
+# Boolean
+
+- [decision_problem]
+- [query_boolean]
+- [formula_boolean]
+- [satisfiability_boolean]
+- [boolean_semiring]
+
+Up: [logic]
diff --git a/boolean_circuit b/boolean_circuit
@@ -0,0 +1,12 @@
+# Boolean circuit
+
+Expresses [boolean_function]
+
+- [circuit_complexity]
+- [circuit_condition]
+
+Similar: https://en.wikipedia.org/wiki/Propositional_directed_acyclic_graph
+
+Up: [circuit]
+
+See also: [boolean_formula], [knowledge_compilation_classes]
diff --git a/boolean_closure b/boolean_closure
@@ -0,0 +1,7 @@
+# Boolean closure
+
+closure under [boolean_operators]
+
+Up: [logic]
+
+See also: [closure_operation]
diff --git a/boolean_formula b/boolean_formula
@@ -0,0 +1,11 @@
+# Boolean formula
+
+representation of [boolean_function]
+
+- [read_once]
+- [conjunctive_normal_form]
+- [disjunctive_normal_form]
+
+Up: [boolean_function]
+
+See also: [boolean_circuit], [knowledge_compilation_classes]
diff --git a/boolean_function b/boolean_function
@@ -0,0 +1,31 @@
+# Boolean function
+
+- [boolean_function_problems]
+- [boolean_function_classes]
+
+Generalizations:
+
+- [quantified_boolean_formula]
+
+Notions:
+
+- [boolean_operator]
+- [prime_implicant]
+- [subfunction]
+- [boolean_valuation]
+ - [satisfying_valuation]
+ - [falsifying_valuation]
+
+Representations:
+
+- [boolean_circuit]
+- [boolean_formula]
+
+Problems:
+
+- [boolean_function_evaluation]
+ - [interactive_boolean_evaluation]
+
+Up: [theoretical_computer_science]
+
+See also: [communication_complexity]
diff --git a/boolean_function_evaluation b/boolean_function_evaluation
@@ -0,0 +1,5 @@
+# Boolean function evaluation
+
+- [interactive_boolean_evaluation]
+
+Up: [boolean_function], [function_evaluation]
diff --git a/boolean_function_problems b/boolean_function_problems
@@ -0,0 +1,9 @@
+# Boolean function problems
+
+- [satisfiability_boolean]
+- [model_counting]
+- [stochastic_boolean_function_evaluation]
+- [maj_sat]
+- [mpe]
+
+Up: [boolean_function]
diff --git a/boolean_hierarchy b/boolean_hierarchy
@@ -0,0 +1,10 @@
+# Boolean hierarchy over NP (BH)
+
+https://complexityzoo.net/Complexity_Zoo:B#bh
+
+- [dp] other name for BH2
+- BH is included in [delta2p]
+
+Up: [complexity_hierarchy]
+
+See also: [polynomial_hierarchy]
diff --git a/boolean_matrix_multiplication b/boolean_matrix_multiplication
@@ -0,0 +1,12 @@
+# BMM
+
+[boolean_matrix_multiplication_hypothesis]
+
+Variants:
+- [combinatorial_boolean_matrix_multiplication]
+- [sparse_boolean_matrix_multiplication]
+ - [fully_sparse_boolean_matrix_multiplication]
+
+Up: [matrix_multiplication] for [boolean_semiring], [fine_grained_complexity_problems]
+
+Aliases: matrix multiplication Boolean
diff --git a/boolean_matrix_multiplication_hypothesis b/boolean_matrix_multiplication_hypothesis
@@ -0,0 +1,11 @@
+# Boolean Matrix Multiplication hypothesis
+
+Hypothesis: two [boolean_matrix] of n by n cannot be multiplied in O(n^2)
+
+Note: not everyone believes this!
+
+Up: [computational_hypothesis] on [boolean_matrix_multiplication]
+
+See also: [combinatorial_boolean_matrix_multiplication_hypothesis], [omm_conjecture]
+
+Aliases: BMM hypothesis, BMM conjecture
diff --git a/boolean_operator b/boolean_operator
@@ -0,0 +1,11 @@
+# Boolean operator
+
+- [conjunction] / [intersection]
+- [disjunction] / [union]
+- [xor]
+- [negation] / [complementation]
+- [setminus]
+
+Up: [boolean_function]
+
+Aliases: boolean operators
diff --git a/boolean_semiring b/boolean_semiring
@@ -0,0 +1,6 @@
+# Boolean semiring
+
+- the two boolean values, [conjunction] and [disjunction]
+- it is a two-element [semiring]
+
+Up: [semiring]
diff --git a/boolean_width b/boolean_width
@@ -0,0 +1,11 @@
+# Boolean width
+
+buixuan2011boolean
+
+Build a binary [tree] on the vertices of the graph in a certain order such that each edge cut of the tree induces a bipartition where the number of neighborhoods (only considering the neighborhoods to vertices of the other side) is bounded
+
+Up to a constant factor, the tree can be assumed to be balanced ([balancing])
+
+See also: [rankwidth], [twin_width]
+
+Up: [width_measure]
diff --git a/bpp b/bpp
@@ -0,0 +1,23 @@
+# BPP
+
+Class BPP: [algorithm_randomized] for [decision_problem] with [two_sided_error] can err in both directions with proba 1/4. The error probability can be made exponentially small by retrying
+
+it is not known if BPP is contained in [nptime]
+
+It is known that if [nptime] subseteq BPP then in fact [nptime] = [rp] : if you have an
+efficient algorithm for a NP problem that errs in both directions, then in fact
+you can remove errors on one side (uses [self_reducibility])
+
+[sipser_lautemann_theorem]: It is known that BPP is in [sigma2_cap_pi2]: https://en.wikipedia.org/wiki/Sipser%E2%80%93Lautemann_theorem
+- as BPP is closed under [complementation] it suffices to show that it is in [sigma2]
+
+Analogue [bpl] BPL with logarithmic space condition
+
+Corresponding notion of [algorithm] running in [ptime]: "[monte_carlo_algorithm] with bounded probability of two-sided error"
+
+Generalization [pp], with [two_sided_error] and there is no constant bound on how the probability differs in the case of a YES instance and of a NO instance https://en.wikipedia.org/wiki/PP_(complexity)
+- cf [isolated_cut_point]
+
+Up: [complexity_random]
+
+See also: [rp], [automaton_monte_carlo_two_sided], [monte_carlo_algorithm]
diff --git a/brooks_theorem b/brooks_theorem
@@ -0,0 +1,6 @@
+# Brooks' theorem
+
+Any [graph] of maximal [degree] d admits [graph_coloring] with d colors except
+if it is a [clique] or for d=2 a [cycle] of odd length
+
+Up: [graph_coloring]
diff --git a/brzozowskis_algorithm b/brzozowskis_algorithm
@@ -0,0 +1,10 @@
+# Brzozowski's algorithm
+
+[Algorithm] for [automaton_minimization].
+
+Take [automaton_mirror] then [determinize] then take [automaton_mirror] then [determinize]
+
+- [complexity_generic] studied in [defeclice2013brzozowski]:
+ - [super_polynomial] on [automata_random]
+
+Up: [minimization_automaton]
diff --git a/buchis_theorem b/buchis_theorem
@@ -0,0 +1,5 @@
+# Büchi's theorem
+
+Equivalence of [monadic_second_order_logic] on [word] and of [regular_language]
+
+Up: [theorem] in [formal_language_theory]
diff --git a/burrows_wheeler_transform b/burrows_wheeler_transform
@@ -0,0 +1,7 @@
+# BWT
+
+[gagie2017wheeler]
+
+Up: [stringology], [compression_string]
+
+See also: [wheeler_nfa]
diff --git a/c2 b/c2
@@ -0,0 +1,12 @@
+# C2
+
+[FO2] with [counting_quantifiers]
+
+Does not enjoy [Craig_interpolation], according to [cate2023craig]
+
+Does not enjoy [finite_model_property]
+- but [satisfiability] is [decidable], cf [pratt2010two]
+
+subclass: [gc2]
+
+Up: [logic]
diff --git a/c2rpq b/c2rpq
@@ -0,0 +1,7 @@
+# C2RPQ
+
+conjunction of [2rpq]
+
+Generalization: [uc2rpq]
+
+Up: [graph_query_languages], [conjunctive_query], [2rpq], [crpq]
diff --git a/canonical_labeling b/canonical_labeling
@@ -0,0 +1,12 @@
+# Canonical labeling
+
+Labeling a [graph] to be able to test [graph_isomorphism] just by equality
+testing of the labels
+
+https://mathoverflow.net/a/11715
+
+also called "graph canonization"
+
+See also: [graph_isomorphism]
+
+Up: [graph]
diff --git a/cerny_conjecture b/cerny_conjecture
@@ -0,0 +1,7 @@
+# Cerny_conjecture
+
+https://en.wikipedia.org/wiki/Synchronizing_word
+
+It is known that an [automata] with a [synchronizing_word] may have no smaller synchronizing word than length (n-1)^2: is there a matching upper bound?
+
+Up: [synchronizing_word]
diff --git a/change_propagation b/change_propagation
@@ -0,0 +1,9 @@
+# Change propagation
+
+[enumeration] of the way the answers to a [query] change after an [update] on [dynamic_data]
+
+There is apparently practical work on the topic, cf [wang2023change]
+
+See also: [semijoin]
+
+Up: [incremental_maintenance_enumeration]
diff --git a/chase b/chase
@@ -0,0 +1,9 @@
+# Chase
+
+Process for [database_dependency] to construct [universal_model]
+
+- [chase_termination]
+ - [gerlach2023general]:
+ - cf "weakly acyclic" and other sufficient conditions for chase termination
+
+Up: [database_theory]
diff --git a/chebyshevs_inequality b/chebyshevs_inequality
@@ -0,0 +1,9 @@
+# Chebyshev's inequality
+
+https://en.wikipedia.org/wiki/Chebyshev%27s_inequality
+
+Pr[|X - EX| \geq epsilon EX] \leq (Var X) epsilon^2 (EX)^2
+
+Up: [concentration_inequality]
+
+See also: [expectation], [variance]
diff --git a/chens_theorem b/chens_theorem
@@ -0,0 +1,5 @@
+# Chens theorem
+
+https://en.wikipedia.org/wiki/Chen%27s_theorem
+
+Up: [number_theory]
diff --git a/chrobak_normal_form b/chrobak_normal_form
@@ -0,0 +1,5 @@
+# Chrobak normal form
+
+see [gawrychowski2011chrobak]
+
+Up: [automata_unary]
diff --git a/circuit b/circuit
@@ -0,0 +1,53 @@
+# Circuit
+
+## Fields
+
+- [knowledge_compilation]
+ - [knowledge_compilation_classes]
+- [circuit_complexity]
+ - [circuit_classes]
+
+## Types
+
+- [boolean_circuit]
+- [arithmetic_circuit]
+- [probabilistic_circuit]
+- [formula]
+
+## Problems
+
+- [enumeration_circuit]
+- [satisfiability]
+
+## Measure [circuit_parameter]
+
+- [depth]
+- [circuit_size]
+- [weft]
+- [fan_in]
+
+## Conditions
+
+[circuit_condition]
+
+## Definitions
+
+- [gate]
+- [wire]
+
+## Research
+
+[chattopadhyay2021lower] for recent research on circuit classes and
+[communication_complexity]
+
+## Operations
+
+- [tseytin_transformation]
+
+## Beware
+
+- [positive_vs_monotone]
+
+Up: [theoretical_computer_science]
+
+See also: [sum_product_network]
diff --git a/circuit_classes b/circuit_classes
@@ -0,0 +1,13 @@
+# Circuit classes
+
+In [circuit_complexity]:
+
+- [nc] NC, in particular [nc0], [nc1]...
+- [ac] AC, [ac0], etc.
+- [tc] TC, [tc0], etc.
+- [acc] ACC, [acc0], etc.
+ - liens avec [solvable_group]
+
+Up: [circuit]
+
+See also: [knowledge_compilation_classes]
diff --git a/circuit_complexity b/circuit_complexity
@@ -0,0 +1,8 @@
+# Circuit complexity
+
+- [circuit_classes]
+- [circuit_complexity_query_evaluation]
+- [circuit_complexity_formal_language]
+- [circuit_parameter]
+
+Up: [circuit]
diff --git a/circuit_complexity_query_evaluation b/circuit_complexity_query_evaluation
@@ -0,0 +1,7 @@
+# Circuit complexity query evaluation
+
+[wang2022query]
+
+Up: [circuit_complexity] of [query_evaluation]
+
+See also: [optimal_joins]
diff --git a/circuit_condition b/circuit_condition
@@ -0,0 +1,11 @@
+# Circuit condition
+
+Conditions that can be posed on [circuit]
+
+- [decomposability]
+- [deterministic]
+- [structuredness] (e.g., [vtree])
+
+Up: [circuit]
+
+See also: [knowledge_compilation_classes]
diff --git a/circuit_lower_bound b/circuit_lower_bound
@@ -0,0 +1,5 @@
+# Circuit lower bound
+
+best known bound on an explicit function: [find2015better], (3+1/86)n - o(n) lower bound on the size of [boolean_circuit] for a [boolean_function]
+
+Up: [circuit_size]
diff --git a/circuit_parameter b/circuit_parameter
@@ -0,0 +1,8 @@
+# Circuit parameter
+
+- [depth]
+- [weft]
+- [fan_in]
+- [circuit_size]
+
+Up: [parameter] of [circuit]
diff --git a/circuit_rank b/circuit_rank
@@ -0,0 +1,7 @@
+# Circuit rank
+
+https://en.wikipedia.org/wiki/Circuit_rank
+
+See also: [feedback_edge_number], [cycle_rank]
+
+Up: [width_measure]
diff --git a/circuit_size b/circuit_size
@@ -0,0 +1,7 @@
+# Circuit size
+
+can be number of [gate]s, or number of [wire]s
+
+- [circuit_lower_bound]
+
+Up: [circuit_complexity]
diff --git a/circular_pattern_matching b/circular_pattern_matching
@@ -0,0 +1,5 @@
+# Circular pattern matching (CPM)
+
+like [pattern_matching] but you can make [circular_rotation] on the pattern to match
+
+Up: [pattern_matching]
diff --git a/classification b/classification
@@ -0,0 +1,9 @@
+# Classification
+
+Classification problem in [machine_learning], e.g., classifying spam, email...
+
+- [vc_dimension]
+- [decision_tree]
+- [random_forest]
+
+Up: [artificial_intelligence]
diff --git a/clique b/clique
@@ -0,0 +1,19 @@
+# Clique
+
+https://en.wikipedia.org/wiki/Clique_(graph_theory)
+
+[graph_complete] as [subgraph] of a [graph]. Cf [clique_problem]
+
+- [clique_listing]
+ - [triangle_listing]
+- [clique_counting]
+
+[zero_clique] / [negative_clique]
+
+clique on [hypergraph]: [hyperclique]
+
+- [planted_clique] "planted clique": problem of distinguishing a [graph] with a hidden clique from a random graph
+
+Up: [graph]
+
+See also: [cliquewidth], [fine_grained_complexity], [treewidth], [graph_minor], [graph_complete], [hyperclique]
diff --git a/clique_listing b/clique_listing
@@ -0,0 +1,9 @@
+# Clique listing
+
+Bound: graph with m edges has at most plus O(m^{k/2}) k-cliques
+
+Special case: [triangle_listing]
+
+Up: [subgraph_listing] of [clique]
+
+See also: [clique_problem], [clique_counting]
diff --git a/clique_problem b/clique_problem
@@ -0,0 +1,16 @@
+# Clique problem
+
+Problem of finding [clique] in input [graph]
+
+Also:
+- subgraph with the largest proportion of edges ([np_hard] for the same reason),
+- [densest_subgraph]: subgraph of maximal density (#edges/#vertices) which is [ptime] and
+reducible to [network_flow]
+
+- [4clique_hypothesis]
+
+Up: [graph_problem] of finding [clique]
+
+See also: [clique_listing], [hyperclique_detection], [hyperclique_conjecture], [cycle_problem]
+
+Aliases: k_clique
diff --git a/cnf_to_decision_dnnf b/cnf_to_decision_dnnf
@@ -0,0 +1,7 @@
+# CNF to decision-DNNF
+
+[oztok2014compiling]
+
+introduces [decision_width] of [conjunctive_normal_form], which amounts to a bound on [primal_treewidth]
+
+Up: [conversion] of [conjunctive_normal_form] to [decision_dnnf]
diff --git a/cograph b/cograph
@@ -0,0 +1,7 @@
+# Cograph
+
+https://en.wikipedia.org/wiki/Cograph
+
+The class of cographs is the class of [graph] defined by starting from the single vertex graph and closing by the [complementation] and [disjoint_union] operations
+
+Up: [graph_family]
diff --git a/color_refinement_query_evaluation b/color_refinement_query_evaluation
@@ -0,0 +1,9 @@
+# Color refinement query evaluation
+
+algorithm in [riveros2024color] which does [query_evaluation] faster with a data structure inspired by color refinement
+
+for [conjunctive_query_acyclic]
+
+Up: [weisfeiler_leman], [query_evaluation]
+
+See also: [yannakakis_algorithm]
diff --git a/combinatorial_boolean_matrix_multiplication b/combinatorial_boolean_matrix_multiplication
@@ -0,0 +1,5 @@
+# Combinatorial Boolean matrix multiplication
+
+[combinatorial_boolean_matrix_multiplication_hypothesis]
+
+Up: [algorithm_combinatorial] for [matrix_multiplication_boolean]
diff --git a/combinatorial_boolean_matrix_multiplication_hypothesis b/combinatorial_boolean_matrix_multiplication_hypothesis
@@ -0,0 +1,9 @@
+# Combinatorial Boolean matrix multiplication hypothesis
+
+[hypothesis]: there are no O(n^{3-epsilon}) time [algorithm_combinatorial] for [boolean_matrix_multiplication] for epsilon>0
+
+Connected to [omv_hypothesis]
+
+Up: [computational_hypothesis] on [combinatorial_boolean_matrix_multiplication]
+
+See also: [boolean_matrix_multiplication_hypothesis], [omm_conjecture]
diff --git a/combinatorics b/combinatorics
@@ -0,0 +1,38 @@
+# Combinatorics
+
+## Subareas
+
+- [enumerative_combinatorics]
+- [extremal_combinatorics]
+- [word_combinatorics]
+
+## Results
+
+- [ramsey_turan_theory]
+ - [ramsey_theorem]
+- [sunflower_lemma]
+- [higmans_lemma]
+- erdos-szekeres theorem on the existence of nonincreasing/nondecreasing [subsequence] of size sqrt(n) in a sequence of length n
+
+## Techniques
+
+- [double_counting]
+
+## Specific problems/objects
+
+- [universal_tree] https://games-automata-play.github.io/blog/universal_trees/
+- [sparse_rulers]
+- [golomb_ruler] / [sidon_set]
+- sequences without [arithmetic_progression]s
+ - [salem_spencer_set]
+- [angel_problem]
+- [german_tank_problem]
+ - frequentist interpretation vs bayesian interpretatino
+- [superpermutation]
+- [social_golfer_problem]
+- [menage_problem]
+- [oberwolfach_problem]
+
+Up: [mathematics]
+
+See also: [discrete_mathematics]
diff --git a/combined_complexity b/combined_complexity
@@ -0,0 +1,9 @@
+# Combined complexity
+
+[complexity] when [database_instance] and [query] given as [input]
+
+foundational paper by [vardi] introducing this: [vardi1982complexity]
+
+Up: [database_theory_complexity]
+
+See also: [parameterized_complexity], [query_complexity], [data_complexity]
diff --git a/common_subsequence b/common_subsequence
@@ -0,0 +1,10 @@
+# Common subsequence
+
+- [longest_common_subsequence]
+ - [longest_parameterized_common_subsequence]
+- [maximal_common_subsequence]
+- [common_subsequence_automaton]
+
+Up: [subsequence]
+
+Aliases: common subsequences
diff --git a/complementation b/complementation
@@ -0,0 +1,8 @@
+# Complementation
+
+- [ddnnf_complementation]
+- [graph_complementation]
+
+Up: [logic], [boolean_operator]
+
+Aliases: complement
diff --git a/complexity b/complexity
@@ -0,0 +1,10 @@
+# Complexity
+
+- [computational_complexity]
+- [circuit_complexity]
+- [state_complexity]
+- [kolmogorov_complexity]
+
+Up: [theoretical_computer_science]
+
+See also: [complexity_as_a_service], [complexity_zoo]
diff --git a/complexity_class b/complexity_class
@@ -0,0 +1,47 @@
+# Complexity class
+
+## Classes
+
+- [complexity_space]
+ - [nlogspace]
+ - [logspace]
+- [complexity_time]
+ - [ptime] / [p_complete]
+ - [linear_time], [linear_time_nearly], [linear_time_almost]
+ - [np_intermediate], cf [ladners_theorem]
+ - [nptime]
+ - [conptime]
+ - [np_cap_conp]
+ - [exptime]
+ - [nexptime]
+ - [spanl]
+ - [pp]
+ - [pspace]
+ - [pspace_complete]
+ - [oplusp] oplusP
+ - [us] US
+
+## [complexity_hierarchy]
+
+- [boolean_hierarchy]
+- [polynomial_hierarchy]
+
+## Variants
+
+- [counting_complexity]
+ - [sharpp]
+- [approximation_class]
+- [complexity_random]
+- [advice]
+ - [p_poly] P/poly
+ - [l_poly] L/poly
+- [optimization_problem]
+ - [NPO]
+
+## Results
+
+- [time_hierarchy_theorem] / [space_hierarchy_theorem]
+- https://mathoverflow.net/questions/40770/how-do-we-know-that-p-linspace-without-knowing-if-one-is-a-subset-of-the-othe/40771#40771
+ - P is different from SPACE(n)
+
+Up: [computational_complexity]
diff --git a/complexity_random b/complexity_random
@@ -0,0 +1,13 @@
+# Randomized complexity class
+
+- [rl]: randomized [logspace]
+- [rp]
+- [bpp]
+- [zpp]
+ - [logspace] version [zplp]
+
+No notion of [complete] problem for these classes (?)
+
+Up: [complexity_class] with [randomness]
+
+See also: [fpras], [approximation_class]
diff --git a/complexity_rectangular b/complexity_rectangular
@@ -0,0 +1,5 @@
+# Complexity rectangular
+
+used in [day2022subsequence] to mean O(nm) when there are two inputs n and m
+
+Up: [computational_complexity]
diff --git a/complexity_space b/complexity_space
@@ -0,0 +1,7 @@
+# Complexity_space
+
+- [savitchs_theorem]: we can simulate [nondeterministic] machine with quadratic blowup in space
+
+Up: [complexity]
+
+See also: [complexity_time]
diff --git a/compression b/compression
@@ -0,0 +1,10 @@
+# Compression
+
+- [rnn_compression]
+- [compression_algorithm]
+- [compression_audio]
+- [compression_string]
+- [algorithms_on_compressed_data]
+- [compression_natural_language]
+
+Up: [computer_science]
diff --git a/compression_algorithm b/compression_algorithm
@@ -0,0 +1,12 @@
+# Compression algorithm
+
+- [lz77]
+- [lz4] (fast)
+- [bwt]
+- [7zip]
+- [lzma]
+- [neural_network_compression]
+- [huffman_algorithm]
+- [run_length_encoding]
+
+Up: [computer_science]
diff --git a/compression_string b/compression_string
@@ -0,0 +1,8 @@
+# Compression string
+
+- [straight_line_program]
+- [lempel_ziv]
+- [burrows_wheeler_transform]
+- [substring_complexity]
+
+Up: [compression], [string]
diff --git a/computational_complexity b/computational_complexity
@@ -0,0 +1,58 @@
+# Computational complexity
+
+## Notions
+
+- [complexity_space]
+- [complexity_time]
+
+- [computational_hardness]
+
+- [complexity_class]
+- [complexity_hierarchy]
+
+- [complexity_worst_case]
+- [complexity_average]
+- [complexity_best_case]
+
+- [complexity_generic]
+
+## Specific classes
+
+- [complexity_random]
+- [complexity_class]
+- [logcfl] / [logdcfl]
+- [parameterized_complexity]
+- [approximation_class]
+ - [apx]
+- [counting_complexity]
+ - [sharpp]
+- [complexity_rectangular]
+
+## [database_theory]
+
+- [data_complexity]
+- [combined_complexity]
+
+## Problems
+
+- [satisfiability_boolean]
+
+## Results
+
+- [ladners_theorem]
+- [complexity_zoo]
+
+## Techniques
+
+- [log_shaving]
+
+## Resources
+
+- valeurs possibles sur wikipedia: en.wikipedia.org/wiki/Time_complexity
+- [descriptive_complexity]
+- [lower_bounds]
+- [klees_measure_problem]
+
+Up: [theoretical_computer_science], [complexity]
+
+See also: [computability], [metacomplexity], [chaos_theory], [decidability], [lower_bounds]
diff --git a/computational_geometry b/computational_geometry
@@ -0,0 +1,9 @@
+# Computational geometry
+
+- [packing_problem]
+- Klee's measure problem: find the volume of a union of rectangles / find if they cover the entire space
+ - we can see [satisfiability_boolean] in this way, more specifically the validity problem of a [disjunctive_normal_form] formula
+- [convex_hull]
+- [closest_pair_of_points]
+
+Up: [geometry], [computer_science]
diff --git a/computational_problem b/computational_problem
@@ -0,0 +1,41 @@
+# Problem
+
+## Types
+
+- [decision_problem]
+- [optimization_problem]
+- [approximation_problem]
+- [counting_problem]
+
+## Terminology
+
+- [input]
+- [output]
+- [complexity]
+
+## Subareas
+
+- [fine_grained_complexity_problems]
+
+## Classes of problems
+
+- [reconfiguration_problem]
+- [packing_problem]
+
+## Specific problems
+
+- [clique_problem]
+- [constraint_satisfaction_problem_tractability]
+- [graph_problem]
+- [maximum_matching_problem]
+- [minimum_formula_size_problem]
+- [partition_problem]
+- [smallest_grammar_problem]
+- [warings_problem]
+- [word_problem]
+- [tiling_problem]
+- [domino_problem]
+
+Up: [theoretical_computer_science]
+
+Aliases: computational problems
diff --git a/computer_algebra b/computer_algebra
@@ -0,0 +1,6 @@
+# Computer algebra
+
+- [grobner_basis], seems useful to solve [polynomial_equation]
+- matrixcalculus.org, calculs matriciels (différentiation etc)
+
+Up: [mathematics]
diff --git a/computer_science b/computer_science
@@ -0,0 +1,8 @@
+# Computer science
+
+- [data_structure]
+- [computer_science_fields]
+
+Up: [natural_science] about [computer]
+
+See also: [informatique], [mathematics]
diff --git a/computer_science_fields b/computer_science_fields
@@ -0,0 +1,15 @@
+# Computer science fields
+
+- [computational_social_choice]
+- [security]
+- [satisfiability]
+- [scheduling]
+- [optimization]
+- [bioinformatics]
+- [nlp]
+- [theoretical_computer_science]
+- [machine_learning] / [artificial_intelligence]
+- [graph_theory]
+- [compression_algorithm]
+
+Up: [computer_science]
diff --git a/concatenation b/concatenation
@@ -0,0 +1,9 @@
+# Concatenation
+
+Operation on [word]
+
+It is [associativity]
+
+See also: [theory_of_concatenation], [concatenation_hierarchy]
+
+Up: [formal_language_operator]
diff --git a/concentration_inequality b/concentration_inequality
@@ -0,0 +1,8 @@
+# Concentration inequality
+
+- [chebyshevs_inequality]
+- [chernoff_bounds]
+- [markovs_inequality]
+- [hoeffdings_inequality]
+
+Up: [inequality_mathematics], [probabilities]
diff --git a/confidence_interval b/confidence_interval
@@ -0,0 +1,8 @@
+# Confidence interval
+
+- [central_limit_theorem]
+- [concentration_inequaliy]
+ - [chebyschevs_inequality]
+ - [hoeffdings_inequality]
+
+Up: [probabilities]
diff --git a/congruence_relation b/congruence_relation
@@ -0,0 +1,7 @@
+# Congruence relation
+
+An [equivalence_relation] preserving an [algebraic_structure], for instance it must be compatible with the group operation when defined over a [group]
+
+See also: [normal_subgroup]
+
+Up: [equivalence_relation]
diff --git a/conjecture b/conjecture
@@ -0,0 +1,26 @@
+# Conjecture
+
+[mathematics_meta] about conjectures :
+ - https://igorpak.wordpress.com/2020/12/10/what-if-they-are-all-wrong/
+
+- [Cerny_conjecture]
+- [Cramer's_conjecture]
+- [exact_triangle_conjecture]
+- [Goldbach_conjecture]
+- [Hadwiger_conjecture]
+- [Lovasz_conjecture]
+- [OV_conjecture]
+ - [K_OV_conjecture]
+ - [OMv_conjecture]
+- [Q9_conjecture]
+- [reconstruction_conjecture]
+- [Ringel's_conjecture]
+- [Sakoda_Sipser_conjecture]
+- [Tuzas_conjecture]
+- [unfair_01_polynomial_conjecture]
+- [unique_games_conjecture]
+- [bunkbed_conjecture]
+
+Up: [mathematics_meta]
+
+See also: [hypothesis]
diff --git a/conjunction b/conjunction
@@ -0,0 +1,8 @@
+# Conjunction
+
+- [conjunctive_query]
+- [conjunctive_normal_form]
+
+Up: [boolean_operator]
+
+See also: [disjunction], [intersection]
diff --git a/conjunctive_context_free_path_query b/conjunctive_context_free_path_query
@@ -0,0 +1,7 @@
+# Conjunctive context free path query (CCFPQ)
+
+- [helling2014conjunctive]
+
+Up: [graph_query_languages]
+
+See also: [crpq], [context_free_grammar]
diff --git a/conjunctive_normal_form b/conjunctive_normal_form
@@ -0,0 +1,35 @@
+# Conjunctive normal form (CNF)
+
+[conjunction] of [clause], each is a [disjunction] of [literal]
+
+- [monotone_cnf]
+- [2cnf]
+ - [monotone2cnf]
+- [3cnf]
+- [kcnf]
+
+lower bound on size of CNF relative to [disjunctive_normal_form]
+
+[variable_clause_difference]
+
+Graphs:
+
+- [primal_graph]
+- [dual_graph]
+- [incidence_graph]
+
+Parameters:
+- [clause_width]
+- [primal_treewidth]
+- [dual_treewidth]
+- [incidence_treewidth]
+
+[conversion]:
+- [cnf_to_dnnf]
+- [cnf_to_decision_dnnf]
+
+See also: [disjunctive_normal_form], [dualization]
+
+Up: [boolean_formula]
+
+Aliases: CNF, CNFs
diff --git a/conjunctive_query b/conjunctive_query
@@ -0,0 +1,20 @@
+# Conjunctive query (CQ)
+
+Examples:
+- [triangle]
+
+Subclasses:
+- [sjfcq] / [self_join]
+- [conjunctive_query_full] / [conjunctive_query_boolean]
+- [conjunctive_query_hierarchical]
+- [conjunctive_query_acyclic]
+- [conjunctive_query_self_join_free]
+
+Generalization:
+- [conjunctive_query_signed]
+
+Up: [query_language]
+
+See also: [conjunction]
+
+Aliases: CQ, CQs
diff --git a/conjunctive_query_acyclic b/conjunctive_query_acyclic
@@ -0,0 +1,19 @@
+# Acyclic CQs
+
+Can be evaluated by [yannakakis_algorithm] following a [join_tree]
+
+- [acyclic_free_connex]
+
+the evaluation problem is in the complexity class [logcfl], and the the complexity is in O(database×query + output)
+
+We can test in linear time if a hypergraph is acyclic and if so build the join tree: [gyo] algorithm
+
+For Boolean queries, even with [self_join], if the query is not acyclic then we can reduce from a hard problem ([triangle_detection] ou [hyperclique_detection])
+
+Special case: [conjunctive_query_hierarchical]
+
+See also: [fagin1983degrees], [guarded_fragment], [alpha_acyclic], [conjunctive_query_cyclic]
+
+Up: [conjunctive_query]
+
+Aliases: acyclic conjunctive query, acyclic conjunctive queries, acyclic CQ, acyclic CQs, CQ acyclic
diff --git a/conjunctive_query_cyclic b/conjunctive_query_cyclic
@@ -0,0 +1,9 @@
+# Conjunctive query cyclic
+
+[CQ] which is not [CQ_acyclic]
+
+See also: [conjunctive_query_acyclic]
+
+Up: [conjunctive_query]
+
+Aliases: cyclic CQs, cyclic CQ
diff --git a/conjunctive_query_diversity b/conjunctive_query_diversity
@@ -0,0 +1,7 @@
+# Conjunctive query diversity
+
+- [merkl2023diversity]
+
+Up: [diversity] of [conjunctive_query]
+
+See also: [conjunctive_query_representativity]
diff --git a/conjunctive_query_optimization b/conjunctive_query_optimization
@@ -0,0 +1,6 @@
+# Conjunctive query optimization
+
+- [acyclic_query]
+- [optimal_joins]
+
+Up: [query_optimization] of [conjunctive_query]
diff --git a/conjunctive_query_representativity b/conjunctive_query_representativity
@@ -0,0 +1,7 @@
+# Conjunctive query representativity
+
+[agarwal2025computing]
+
+Up: [representativity] of [conjunctive_query]
+
+See also: [conjunctive_query_diversity]
diff --git a/conjunctive_query_signed b/conjunctive_query_signed
@@ -0,0 +1,12 @@
+# CQ with negated atoms
+
+a [conjunctive_query] with [negation] on some [atom]s
+
+- [capelli2023direct]
+ - also zhao2023conjunctive
+- [fink2016dichotomies]
+- [enumeration_cqs]: see [segoufin2015constant] which cites [brault2014pertinence]
+
+Up: [conjunctive_query] with [negation]
+
+See also: [hypergraph_signed]
diff --git a/conl b/conl
@@ -0,0 +1,5 @@
+# Co-NL
+
+[complement] of [nlogspace], equal to [logspace] by [immerman_szelepcsenyi_theorem]
+
+Up: [nlogspace]
diff --git a/connectivity b/connectivity
@@ -0,0 +1,14 @@
+# Connectivity
+
+Problem of knowing how many edges/vertices you must remove from a [graph] in order to disconnect it ([connected_component])
+
+- [vertex_connectivity]
+- [edge_connectivity]
+
+- [connectivity_weighted]
+
+- [dynamic_connectivity]
+
+See also: [mengers_theorem], [minimum_cut], [connected_graph]
+
+Up: [graph]
diff --git a/connectivity_weighted b/connectivity_weighted
@@ -0,0 +1,5 @@
+# Connectivity weighted
+
+[connectivity] problems are also tractable on [graph_weighted], since they can be solved by [network_flow] [algorithm]
+
+Up: [connectivity], [weights]
diff --git a/constraint_satisfaction_problem_enumeration b/constraint_satisfaction_problem_enumeration
@@ -0,0 +1,7 @@
+# Constraint satisfaction problem enumeration
+
+[creignou2011enumerating]
+
+Up: [constraint_satisfaction_problem], [enumeration]
+
+See also: [constraint_satisfaction_problem_knowledge_compilation], [schaefers_dichotomy_theorem]
diff --git a/context_free_grammar b/context_free_grammar
@@ -0,0 +1,40 @@
+# Context free grammar
+
+## Concepts
+
+- [nonterminal]
+- [terminal]
+- [production]
+- [axiom]
+- [derivation_tree]
+- [context_free_language]
+
+## Equivalence
+
+[context_free_grammar_pushdown_automaton_equivalence]
+
+## Subclasses
+
+- [context_free_grammar_deterministic]
+- [context_free_grammar_unambiguous]
+- [context_free_grammar_linear]
+- [context_free_grammar_bounded]
+- [inherently_ambiguous]
+
+## Complexities
+
+- [logcfl]
+- [logdcfl]
+
+## Problems
+
+- [context_free_grammar_equivalence]
+- [smallest_grammar_problem]
+
+## Fields
+
+- [parsing]
+
+See also: [regular_language], [chomsky_hierarchy], [context_free_language], [inherently_ambiguous], [graph_grammar], [semilinear_set], [language_power_series]
+
+Up: [formal_language_theory]
diff --git a/context_free_grammar_bounded b/context_free_grammar_bounded
@@ -0,0 +1,7 @@
+# Bounded context-free grammar
+
+[polynomial] [density_function]
+
+Up: [context_free_grammar]
+
+See also: [regular_language_sparse]
diff --git a/context_free_grammar_linear b/context_free_grammar_linear
@@ -0,0 +1,9 @@
+# Context free grammar linear
+
+https://en.wikipedia.org/wiki/Linear_grammar
+
+Testing [language_emptiness] of [intersection] is already [undecidable] by reduction from [post_correspondence_problem]
+
+Up: [context_free_grammar]
+
+Aliases: linear grammar, linear grammars, linear context-free grammar, linear context-free grammars
diff --git a/context_free_grammar_unambiguous b/context_free_grammar_unambiguous
@@ -0,0 +1,9 @@
+# Unambiguous CFG
+
+An unambiguous CFG is a [context_free_grammar] where for every [word] in the language there is exactly one [derivation_tree]
+
+[parsing] for an unambiguous CFG is more efficient
+
+Up: [unambiguity], [context_free_grammar]
+
+See also: [inherently_ambiguous]
diff --git a/context_free_language b/context_free_language
@@ -0,0 +1,9 @@
+# Context free language
+
+[language] accepted by [context_free_grammar]
+
+- [context_free_language_membership]
+
+Up: [language], [context_free_grammar]
+
+Aliases: context-free languages, context free languages, context-free language, CFL
diff --git a/context_free_language_membership b/context_free_language_membership
@@ -0,0 +1,8 @@
+# Context free language membership
+
+- [context_free_language_membership_fine_grained]
+- [parsing]
+ - [CYK]
+ - [Valiant's_parser]
+
+Up: [membership_problem], [context_free_language]
diff --git a/context_free_language_membership_fine_grained b/context_free_language_membership_fine_grained
@@ -0,0 +1,6 @@
+# Context free language membership fine grained
+
+- [koutris2023fine]
+- [istomina2023fine]
+
+Up: [context_free_language_membership], [fine_grained_complexity]
diff --git a/conversion b/conversion
@@ -0,0 +1,13 @@
+# Conversion
+
+## For circuits
+
+[conversion_circuit]
+
+## For other objects
+
+- [conversion_automata]
+
+Up: [knowledge_compilation]
+
+See also: [amarilli2019connecting]
diff --git a/conversion_regular_expression_automata b/conversion_regular_expression_automata
@@ -0,0 +1,6 @@
+# Conversion regular expression automata
+
+- [thompson_automaton]
+- [glushkov_automaton]
+
+Up: [conversion_automata], [regular_expression]
diff --git a/core_semiring b/core_semiring
@@ -0,0 +1,7 @@
+# Core semiring
+
+[semiring] of the elements of the form \bottom+x in a [partially_ordered_pre_semiring]
+
+It is a [semiring] and it is [natural_order].
+
+Up: [partially_ordered_pre_semiring]
diff --git a/counter_automata_definition b/counter_automata_definition
@@ -0,0 +1,16 @@
+# Counter automata definition
+
+from [gelade2009regular]:
+
+- counter variables
+- function that gives initial values to counters
+- function that gives maximal values to counters
+ - beyond these maximal values you ignore what the value is
+- transitions have
+ - a guard: boolean combination of equalities and inequalities on counter values
+ - an update operation: increment counter or reset counter (to its initial value?)
+- final states also have a guard
+
+[counter_automata_deterministic]
+
+Up: [counter_automata]
diff --git a/counter_automata_deterministic b/counter_automata_deterministic
@@ -0,0 +1,5 @@
+# Counter automata deterministic
+
+for every *reachable* configuration (state, counter states), for every letter, there is at most one transition which is applicable (= whose guard is satisfied)
+
+Up: [counter_automata_definition], [automata_deterministic]
diff --git a/counter_automata_trees b/counter_automata_trees
@@ -0,0 +1,5 @@
+# Counter automata trees
+
+- [herrmann2024global] https://arxiv.org/html/2406.15090v1 [one_counter_automata] with one global counter passed in [lexicographic_order]
+
+Up: [counter_automata], [tree_automaton]
diff --git a/counting_cqs b/counting_cqs
@@ -0,0 +1,22 @@
+# Counting CQ results
+
+Given a [conjunctive_query] and a [database_instance], count the number of answers.
+
+Can be studied in [data_complexity], [query_complexity], or [combined_complexity]. Of course in [data_complexity] it is always [ptime].
+
+Results:
+
+- Exact counting is [sharpp_complete] in [query_complexity]
+- For [acyclic_CQs]: [ptime] with counting variant of [Yannakakis's_algorithm]
+- For bounded [generalized_hypertree_width]:
+ - [arenas2021when]: approximate counting [fpras] for bounded [generalized_hypertree_width]generalized_hypertree_width
+ - extended by [vanbremen2023probabilistic]
+ - [self-joins] can be a problem
+
+Related task: [sampling_cqs]
+
+[academic_papers]:
+- [chen2023counting], journal version of [chen2015trichotomy] and [greco2014counting]
+- context explained in https://dbt.zulipchat.com/#narrow/stream/413229-Paper-announcements/topic/Papers.20about.20counting.20CQs
+
+Up: [counting_query_answers] for [conjunctive_query]
diff --git a/counting_problem b/counting_problem
@@ -0,0 +1,18 @@
+# Counting problem
+
+[computational_problem] asking for the [counting] of something
+
+- in [graph]:
+ - [matching_counting]
+ - [triangle_counting]
+ - [maximal_independent_set_counting] Counting [maximal_independent_set]
+- [counting_query_answers]
+ - [counting_cqs]
+- For [satisfiability_boolean]: [sharp_satisfiability]
+- [counting_simple_path]s
+- [sharp_automaton]:
+ - [sharp_nfa], cf [arenas2020efficient]
+ - [sharp_ufa]
+ - [sharp_dfa]
+
+Up: [computational_problem], [counting]
diff --git a/counting_quantifier b/counting_quantifier
@@ -0,0 +1,8 @@
+# Counting quantifier
+
+- [c2]: [fo2] with counting quantifier
+- [c2]+tree, c2+[linear_order]
+
+Up: [logic]
+
+Aliases: counting quantifiers
diff --git a/counting_query_answers b/counting_query_answers
@@ -0,0 +1,9 @@
+# Counting query answers
+
+The [counting_problem] of [counting] the answers to a [query]
+
+- for [conjunctive_query]: [counting_cqs]
+- for [union_of_conjunctive_queries]: [counting_ucqs]
+- [rpq_counting_answers]
+
+Up: [counting_problem]
diff --git a/counting_ucqs b/counting_ucqs
@@ -0,0 +1,7 @@
+# Counting UCQs
+
+[Academic_paper]: [focke2023counting], which reinterprets [chen2016counting]
+
+Up: [counting_query_answers] for [union_of_conjunctive_queries]
+
+See also: [counting_cqs]
diff --git a/courcelle_theorem b/courcelle_theorem
@@ -0,0 +1,15 @@
+# Courcelle theorem
+
+by [courcelle]
+
+Applies to [treelike_data]
+
+Also: bounded [cliquewidth] if we are given a witness of cliquewidth
+
+time f(|phi|, width) times linear in the graph
+
+Up: [theorem] on [monadic_second_order_logic_model_checking], [algorithmic_metatheorem]
+
+Aliases: Courcelle's theorem
+
+See also: [treewidth]
diff --git a/craig_interpolation b/craig_interpolation
@@ -0,0 +1,9 @@
+# Craig interpolation
+
+For every [implication] φ => ψ, there is a formula χ using only the common [relation_symbol]s of φ and ψ such that φ => χ and χ => ψ
+
+[cate2023craig]: [survey_article] on [craig_interpolation] for [guarded_fragment]
+
+Up: [property] of [logical_fragment]
+
+See also: [logical_separability], [beth_definability]
diff --git a/crpq b/crpq
@@ -0,0 +1,14 @@
+# CRPQ
+
+- [c2rpq]
+- [ucrpq]
+- [rpq]
+- [conjunctive_query]
+
+Generalization: [conjunctive_context_free_path_query]
+
+- [crpq_containment]
+
+Up: [graph_query_languages]
+
+Aliases: CRPQs
diff --git a/cycle b/cycle
@@ -0,0 +1,22 @@
+# Cycle
+
+A [simple_path] from one [vertex] to itself (= the path is simple except that the first vertex is equal to the last)
+
+In [undirected_graphs], cycles are typically required to have length at least 3 ([triangle]).
+
+In [directed_graphs], two vertices u and v with an [edge] from u to v and another [edge] from v to u can count as a cycle;
+ - [self_loops] can arguably count as a cycle as well
+
+Variants:
+- [circuit_graph] if the same [vertices] (but not [edges]) can be visited multiple times
+ - like a [trail] compared to a [simple_path]
+- [tour] if the same [vertices] and [edges] can be visited multiple times
+ - like a [walk] compared to a [simple_path]
+
+- [cycle_induced]
+
+Up: [graph_basic_notions]
+
+Aliases: cycles
+
+See also: [2_regular]
diff --git a/cycle_induced b/cycle_induced
@@ -0,0 +1,10 @@
+# Cycle induced
+
+[Cycle] which is an [induced_subgraph], i.e., which does not have a [chord]
+
+- [triangle]
+- [hole]: induced cycle of length at least 4
+
+Up: [cycle]
+
+Aliases: induced cycle
diff --git a/cycle_rank b/cycle_rank
@@ -0,0 +1,7 @@
+# Cycle rank
+
+https://en.wikipedia.org/wiki/Cycle_rank
+
+See also: [feedback_edge_number], [pathwidth_directed], [treewidth_directed], [circuit_rank], [strahler_number], [star_height], [eggans_theorem], [cycle]
+
+Up: [width_measure] for [graph_directed]
diff --git a/data_complexity b/data_complexity
@@ -0,0 +1,9 @@
+# Data complexity
+
+complexity for fixed [query] when [database] given as input
+
+introduced in [vardi1982complexity]
+
+Up: [database_theory_complexity]
+
+See also: [combined_complexity], [query_complexity]
diff --git a/data_structure b/data_structure
@@ -0,0 +1,18 @@
+# Data structure
+
+- [list]
+- [array]
+- [tree] / [forest]
+- [graph]
+- [stack]
+- [queue]
+ - [priority_queue]
+- [van_emde_boas_tree]
+- [binary_search_tree]
+- [heap]
+- [bloom_filter]
+- [brodal_queue]
+
+See also: [sketching], [algorithms]
+
+Up: [computer_science]
diff --git a/database_dependency b/database_dependency
@@ -0,0 +1,31 @@
+# Dependency (databases)
+
+An [implication] in [first_order_logic] with [universal_quantifier]s and with a [conjunction] of [atom] on the left-hand-side
+
+## Terminology
+
+- [dependency_body]
+- [dependency_head]
+
+## Classes
+
+- [tuple_generating_dependency]
+- [equality_generating_dependency]
+ - [functional_dependency]
+
+## Generalization
+
+- [disjunctive_dependency]
+ - [disjunctive_tuple_generating_dependency]: right hand side is [disjunction] of [conjunction] of [atom]s
+
+## Problems
+
+- [entailment]
+ - [entailment_finite]
+ - [entailment_unrestricted]
+ - [finite_controllability]
+- [dependency_expressiveness]
+
+Up: [integrity_constraint]
+
+Aliases: dependencies, dependency, database dependencies
diff --git a/database_repairs b/database_repairs
@@ -0,0 +1,15 @@
+# Database repairs
+
+[amezianelkhalfioui2022consistent]: [consistent_query_answering] plus [counting]
+
+[marconi2024consistent]
+
+with [preference]s: [pardal2024computational]
+
+- [repair_counting]
+
+Up: [database_theory]
+
+See also: [language_repair], [graph_modification]
+
+Aliases: database repair
diff --git a/database_theory b/database_theory
@@ -0,0 +1,14 @@
+# Database theory
+
+- [database_theory_survey]
+- [database_theory_gems]
+- [database_theory_techniques]
+- [database_theory_concepts]
+- [database_theory_complexity]
+
+- [query_language]
+ - [graph_query_languages]
+
+See also: [databases], [database_startups], [description_logics], [finite_model_theory]
+
+Up: [research_fundamental] of [database_research]
diff --git a/database_theory_concepts b/database_theory_concepts
@@ -0,0 +1,15 @@
+# Database theory concepts
+
+- [relational_signature]
+ - [database_relation]
+ - [arity]
+- [instance]
+ - [set_semantics] vs [bag_semantics]
+- [query]
+- [query_evaluation]
+- [combined_complexity] / [data_complexity]
+- [query_containment]
+- [omqa]
+ - [omqa_finite] vs [omqa_unrestricted]
+
+Up: [database_theory]
diff --git a/datalog b/datalog
@@ -0,0 +1,53 @@
+# Datalog
+
+## Notions
+
+- [proof_tree]
+- [datalog_semantics]
+- [Datalog_program]
+- [Datalog_rule]
+- [Intensional_predicate]
+
+## Datalog fragments
+
+- [datalog_monadic]
+- [datalog_linear]
+- [datalog_symmetric_linear]
+- [datalog_stratified_linear]
+- [regular_path_query]
+- [datalog_nonrecursive]
+- [datalog_guarded]
+- [datalog_frontier_guarded]
+
+## Datalog extensions
+
+- [datalog_fuzzy]
+- [datalogpm]
+- [datalog_negation]
+- [datalog_semiring]
+- [datalog_aggregation]
+
+## [Computational_problems]
+
+- [datalog_query_evaluation]
+- [datalog_boundedness]
+
+## Questions
+
+- [datalog_expressiveness]
+
+## Properties
+
+- [homomorphism_closed]
+
+## Also
+
+- [datalog_practice]
+- [constraint_satisfaction_problem_datalog]
+- [incremental_maintenance_datalog]
+- [datalog_grounding]
+- [datalog_rewriting]
+
+Up: [query_language]
+
+See also: [prolog], [answer_set_programming], [transitive_closure], [declarative_programming]
diff --git a/datalog_aggregation b/datalog_aggregation
@@ -0,0 +1,9 @@
+# Datalog aggregation
+
+[Datalog_semantics] problem (like [datalog_negation]): [Datalog_inference] no longer [monotone]
+
+Can be addressed by [stratification], or via the approach of [datalogo]
+
+Up: [datalog], [aggregation]
+
+See also: [datalogo]
diff --git a/datalog_fuzzy b/datalog_fuzzy
@@ -0,0 +1,5 @@
+# Datalog fuzzy
+
+[lanzinger2024fuzzy]
+
+Up: [datalog], [uncertain_data]
diff --git a/datalog_grounding b/datalog_grounding
@@ -0,0 +1,5 @@
+# Datalog grounding
+
+We can transform a [Datalog_program] on a specific [database] into a [propositional_logic] formula by creating [variables] for each possible [fact] of an [intentional_predicate]
+
+Up: [datalog], [grounding]
diff --git a/datalog_linear b/datalog_linear
@@ -0,0 +1,11 @@
+# Datalog linear
+
+[datalog] where each [rule] body contains at most one [intensional_relation] atom
+
+Introduced in [dalmau2005linear]
+
+occurs in [bodirsky2024symmetric]
+
+Up: [datalog]
+
+Aliases: linear Datalog
diff --git a/datalog_monadic b/datalog_monadic
@@ -0,0 +1,7 @@
+# Datalog monadic
+
+[Datalog] where all [intensional_predicates] are [monadic]
+
+Up: [datalog]
+
+Aliases: Monadic Datalog
diff --git a/datalog_negation b/datalog_negation
@@ -0,0 +1,12 @@
+# Datalog negation
+
+Semantics problem: [negation_semantics]
+- because [Datalog_inference] it is no longer [monotone]
+
+Simple solution: [negation_stratified], i.e., adding [negation] only to [datalog_stratified], with negations on predicates of lower [Datalog_stratum]
+
+Recent work on this: [shaikhha2024optimizing]
+
+See also: [fixpoint]
+
+Up: [datalog], [negation]
diff --git a/datalog_query_evaluation b/datalog_query_evaluation
@@ -0,0 +1,24 @@
+# Datalog query evaluation
+
+[datalog_query_evaluation_algorithms]
+
+[computational_complexity]:
+- [exptime_complete] in [combined_complexity], cf [gottlob2012datalog]
+ - already [exptime_hard] with
+ - empty input [database]
+ - one single [datalog_rule]
+ - two-element universe
+- for [datalog_linear]:
+ - [pspace_complete]
+ - already [pspace_hard] with the following, cf [gottlob2023complexity]
+ - empty input [database]
+ - one single [datalog_rule]
+ - two-element universe
+
+An important idea is to run the [CQs] of the [rule_bodies] efficiently: [conjunctive_query_optimization] / [optimal_joins]
+
+[zhang2023enhancing]: [query_evaluation] of [datalog] via [hypertreewidth]
+
+Up: [datalog], [query_evaluation]
+
+See also: [query_optimization]
diff --git a/datalog_semiring b/datalog_semiring
@@ -0,0 +1,13 @@
+# Datalog semiring
+
+A [datalog] program with [semiring]
+
+[datalog_semiring_query_evaluation]
+
+Questions of [convergence]
+
+Formalism: [datalogo]
+
+Up: [datalog]
+
+See also: [yann_ramusat]
diff --git a/datalog_semiring_query_evaluation b/datalog_semiring_query_evaluation
@@ -0,0 +1,6 @@
+# Datalog semiring query evaluation
+
+[computational_complexity]:
+ - cf [zhao2024evaluating]
+
+Up: [datalog_semiring], [query_evaluation]
diff --git a/datalog_stratified_linear b/datalog_stratified_linear
@@ -0,0 +1,7 @@
+# Datalog stratified linear
+
+[Datalog_stratified] but at most one [intensional_predicate] of the current [stratum] in each [rule] body
+
+Expresses [first_order_logic] with [transitive_closure], cf [consens1990graphlog], [graedel1992transitive]
+
+Up: [datalog_stratified]
diff --git a/datalog_symmetric_linear b/datalog_symmetric_linear
@@ -0,0 +1,9 @@
+# Datalog symmetric linear
+
+introduced in [egri2007symmetric]
+
+[datalog_linear] but where we impose that for every rule having an IDB in the body, the symmetric rule also occurs (exchanging the body predicate and the head predicate)
+
+connections to [CSP]
+
+Up: [datalog]
diff --git a/datalogpm b/datalogpm
@@ -0,0 +1,7 @@
+# Datalog^+/-
+
+cf [cali2010datalog]
+
+Fragment: [warded_datalogpm]
+
+See also: [tuple_generating_dependency], [datalog], [georg_gottlob]
diff --git a/ddnnf b/ddnnf
@@ -0,0 +1,9 @@
+# d-DNNF
+
+[deterministic] [decomposable] [nnf]
+
+Up: [knowledge_compilation_classes], [dd]
+
+See also: [dnnf], [decision_dnnf], [uobdd]
+
+Aliases: d-DNNFs
diff --git a/de_bruijn_sequence b/de_bruijn_sequence
@@ -0,0 +1,7 @@
+# De bruijn sequence
+
+like [universal_word] but for [cyclic_word]
+
+See also: [universal_word]
+
+Up: [word_combinatorics]
diff --git a/decision b/decision
@@ -0,0 +1,9 @@
+# Decision
+
+Used in [diagram], also in [decision_dnnf]
+
+other name: "syntactic unambiguity"
+
+Up: [circuit_condition]
+
+See also: [decision_problem]
diff --git a/decision_dnnf b/decision_dnnf
@@ -0,0 +1,8 @@
+# Decision-DNNF
+
+[dnnf] but only with [decision] gates
+
+- special case: [ordered_decision_circuit]
+- special case: [decision_sdnnf]
+
+Up: [dnnf]
diff --git a/decision_problem b/decision_problem
@@ -0,0 +1,9 @@
+# Decision_problem
+
+A [boolean] [computational_problem], i.e., one with a yes/no answer
+
+Up: [computational_problem], [boolean]
+
+See also: [decision], [decidability]
+
+Aliases: decision problems
diff --git a/deficiency b/deficiency
@@ -0,0 +1,11 @@
+# Deficiency
+
+https://en.wikipedia.org/wiki/Deficiency_(graph_theory)
+
+on [graph] and [graph_bipartite]
+
+weighted variant: https://cstheory.stackexchange.com/questions/54787/can-you-compute-in-ptime-a-weighted-version-of-deficiency-on-a-bipartite-graph/54788
+
+Up: [graph]
+
+See also: [project_selection_problem], [matching]
diff --git a/degree b/degree
@@ -0,0 +1,9 @@
+# Degree
+
+Number of [neighbors] of a [vertex]
+
+In [directed_graphs], we can distinguish the [indegree] and [outdegree], respectively the number of [vertices] having a edge to the [vertex], or from the [vertex]
+
+- [maximal_degree]
+
+Up: [graph_basic_notions]
diff --git a/degree_of_acyclicity b/degree_of_acyclicity
@@ -0,0 +1,14 @@
+# Degree of acyclicity
+
+foundational paper: [fagin1983degrees], see also [brault2014hypergraph]
+
+- [alpha_acyclic]
+- [beta_acyclic]
+ - [lanzinger2021tractability]
+- [gamma_acyclic]
+ - cf [delpia2018multilinear]
+- [berge_acyclic]
+
+Up: [hypergraph]
+
+See also: [gyo]
diff --git a/deletion_breakable b/deletion_breakable
@@ -0,0 +1,20 @@
+# Deletion breakable
+
+Discussed in [maehlman2024monadically] and at [stacs_2024_szymon]
+
+A [graph_class] C is deletion breakable if for every radius r, there is a k and an unbounded function U satsifying the following:
+
+- for every [graph] G in the [graph_class], for every subset W of the vertices of G
+- there are two subsets A and B of W that are "large", i.e., have size at least U(|W|)
+- there is a subset of vertices S of size at most k (the [separator])
+- such that the [distance] from A to B is at least r in G when S is removed
+
+Special case: [infinity_deletion_breakable]
+
+Example: on [grid]: for every set W of vertices, there is an r-[independent_set] (you can take the empty set of vertices as a separator)
+
+A [graph_class] is deletion breakable iff it is [nowhere_dense]
+
+Next: notion of [flip], and [infinity_flip_breakable]
+
+Up: [stacs_2024_szymon]
diff --git a/densest_subgraph b/densest_subgraph
@@ -0,0 +1,12 @@
+# Densest subgraph
+
+https://en.wikipedia.org/wiki/Dense_subgraph
+
+Find subgraph of maximal density (#edges/#vertices) of input graph
+
+- Goldberg's algorithm: This is in [ptime] and reducible to [network_flow]
+ - Lien avec [submodularity]/[supermodularity], cf [chekuri2022densest]
+- Also a [greedy_algorithm] (Charikar's algorithm)
+- Efficient algorithms on some graph classes, e.g., [harpeled2024approximating]
+
+Up: [graph]
diff --git a/density_function b/density_function
@@ -0,0 +1,16 @@
+# Density function
+
+function defined on an [automata] and giving the number of words of a given length accepted by that automaton (= cardinality of [slice] of its [formal_language])
+
+possible regimes: exponential, polynomial, etc.
+
+- [language_slender]
+- [language_polynomially_bounded]
+
+[counting_problem] of evaluating it: [sharp_automaton]
+
+testing which lengths can be achieved, on [NFAs]: [potechin2020lengths]
+
+Up: [automata]
+
+See also: [universality_automata], [sharp_automaton], [slice], [degree_of_ambiguity], [growth_rate_analysis]
diff --git a/dependency_implication b/dependency_implication
@@ -0,0 +1,9 @@
+# Dependency implication
+
+decide if set of [dependencies] implies another [dependency]
+
+studied for instance with [functional_dependency], cf [armstrong_axioms]
+
+See also: [open_world_query_answering], [query_containment], [language_inclusion]
+
+Up: [computational_problem], [implication_of_constraints], [dependency]
diff --git a/depth b/depth
@@ -0,0 +1,13 @@
+# Depth
+
+The depth of a [circuit] is the maximal [length] of a [path] from a [variable_gate] to the [output_gate] of the [circuit]
+
+- depth [lower_bounds] on [circuit]:
+ - historical work: [hastad1998shinkage]
+ - recent work: [bathie2024towards]
+
+- [depth_reduction]
+
+Up: [circuit]
+
+See also: [circuit_size], [height]
diff --git a/derivation_tree b/derivation_tree
@@ -0,0 +1,9 @@
+# Derivation tree
+
+A derivation tree is a notion of a [context_free_grammar]
+
+The [yield] of a derivation tree is the sequence of its leaves
+
+The notion of derivation trees also occurs in [datalog]: [derivation_tree_datalog]
+
+Up: [tree] for [context_free_grammar]
diff --git a/description_logics b/description_logics
@@ -0,0 +1,16 @@
+# Description logics
+
+A set of lightweight [logics] with different complexity depending on the features allowed.
+
+[Survey_paper]: [artale2009dllite]
+
+Classes:
+- [DL-Lite]
+
+Topics:
+- [Description_logics_descriptive_complexity]
+- [Provenance_description_logics]
+
+Up: [logic]
+
+See also: [FO2], [Guarded_Fragment]
diff --git a/descriptive_complexity b/descriptive_complexity
@@ -0,0 +1,10 @@
+# Descriptive complexity
+
+Less active nowadays: https://eccc.weizmann.ac.il//report/2011/151/
+
+- Abiteboul, Hull, Vianu theorem https://en.wikipedia.org/wiki/Abiteboul-Vianu_theorem
+- [open_problem]: finding a logic that captures [ptime]
+- [description_logics_descriptive_complexity]
+- [immerman_vardi_theorem] : [first_order] with [least_fixpoint], or [datalog], is [ptime] on ordered structures (cf [order_invariance])
+
+Up: [computational_complexity]
diff --git a/determinism b/determinism
@@ -0,0 +1,6 @@
+# Determinism
+
+- [automata_deterministic]
+- [deterministic] (for [circuit])
+
+Up: [theoretical_computer_science]
diff --git a/diagram b/diagram
@@ -0,0 +1,18 @@
+# Diagram
+
+- [ordered_diagram]
+ - [obdd]
+ - [uobdd]
+ - [nobdd]
+- [fbdd]
+ - [nrobp]
+ - generalization [read_k_branching_program]s
+ - like [k_ambiguous]
+ - cf [jukna1995note]
+- [bdd_subfunction] for [subfunction]
+
+Up: [knowledge_compilation_classes]
+
+See also: [read_once], [decision_tree]
+
+Aliases: decision diagram, decision diagrams
diff --git a/diameter b/diameter
@@ -0,0 +1,9 @@
+# Diameter
+
+Definition : in a [graph], the longest distance of a [shortest_path]
+
+- [incremental_maintenance_diameter]
+
+Up: [graph_radius_diameter]
+
+See also: [girth], [graph_coloring_diameter]
diff --git a/dimension b/dimension
@@ -0,0 +1,7 @@
+# Dimension
+
+- [partial_order_dimension]
+- [vector_space]
+- [vc_dimension]
+
+Up: [mathematics]
diff --git a/dioid b/dioid
@@ -0,0 +1,16 @@
+# Dioid
+
+Semiring where 1 + 1 = 1
+- Implies [idempotence]: x + x = x
+- [natural_order]: x <= y si x + y = y
+
+Also called an "idempotent semiring"
+
+Freely generated dioid over a set of variables, with no coefficients: [bool_x]
+- infinite [omega_chain]: 1 < 1 + z < 1 + z + z^2 < ...
+
+strenghtening: [semiring_absorptive]
+
+Up: [semiring]
+
+See also: [kleene_algebra]
diff --git a/diophantine_equation b/diophantine_equation
@@ -0,0 +1,7 @@
+# Diophantine equation
+
+fun [open_problems]: https://en.m.wikipedia.org/wiki/Euler_brick#Perfect_cuboid
+
+See also: [sum_of_powers]
+
+Up: [mathematics], [equation]
diff --git a/directed_acyclic_graph b/directed_acyclic_graph
@@ -0,0 +1,9 @@
+# Directed acyclic graph (DAG)
+
+[graph_directed] which does not contain [cycle]
+
+- [topological_sorting]
+
+Up: [graph_directed]
+
+Aliases: DAG, DAGs
diff --git a/directed_planar_graph b/directed_planar_graph
@@ -0,0 +1,5 @@
+# Directed planar graph
+
+[Directed_graph] whose underlying [undirected_graph] is [planar]
+
+Up: [planar_graph], [graph_directed]
diff --git a/disjoint_union b/disjoint_union
@@ -0,0 +1,5 @@
+# Disjoint union
+
+The [union] of two [set] that are [disjoint]
+
+Up: [union]
diff --git a/disjunction b/disjunction
@@ -0,0 +1,9 @@
+# Disjunction
+
+- [disjunctive_normal_form]
+- [union_of_conjunctive_queries]
+- [union_trick]
+
+Up: [boolean_operator]
+
+See also: [union], [conjunction]
diff --git a/disjunctive_normal_form b/disjunctive_normal_form
@@ -0,0 +1,18 @@
+# Disjunctive normal form (DNF)
+
+[disjunction] of [term] (not [clause]), each is [conjunctio] of [literal]
+
+- [pp2dnf]
+- [disjunctive_normal_form_orthogonal]
+
+[satisfiability_boolean] for DNF is easy, what is difficult is [validity], i.e., knowing if there exists an assignment which violates the formula
+
+lower bound on size of DNF relative to [conjunctive_normal_form]
+
+- [gdnf]
+
+See also: [conjunctive_normal_form], [karp_luby], [dualization]
+
+Up: [boolean_formula]
+
+Aliases: DNF, DNFs
diff --git a/disjunctive_normal_form_orthogonal b/disjunctive_normal_form_orthogonal
@@ -0,0 +1,14 @@
+# Disjunctive normal form orthogonal
+
+[disjunctive_normal_form] where for any two "terms" they are not mutually satisfiable
+(so it is an [unambiguous] [disjunctive_normal_form])
+
+Could be called "unambiguous DNF"
+
+What is the complement called? it's a [conjunctive_normal_form] where the disjunction of any two clauses is tautological
+
+note that necessarily the clauses (all except at most one) must be big (at least n/2) to satisfy this condition
+
+[disjunctive_normal_form_orthogonal_negation]
+
+Up: [disjunctive_normal_form]
diff --git a/distance b/distance
@@ -0,0 +1,9 @@
+# Distance
+
+- [edit_distance]
+- [permutation_distance]
+- [distance_oracle]
+- [graph_distance]
+- [ultrametric]
+
+Up: [mathematics]
diff --git a/distinguishing_subsequence b/distinguishing_subsequence
@@ -0,0 +1,11 @@
+# Distinguishing subsequence
+
+distinguishing subsequence of a set S of strings is a string T which is a [subsequence] of exactly one string in S
+
+[crochemore2003directed] section 4.5
+
+- [computational_problem]: [shortest_distinguishing_subsequence]
+
+Up: [subsequence]
+
+See also: [common_non_subsequence]
diff --git a/dnnf_to_nfbdd b/dnnf_to_nfbdd
@@ -0,0 +1,5 @@
+# DNNF to NFBDD
+
+in [amarilli2019connecting], attributed to [beame2015new] section 5, but also seems to be done in [razgon2015quasipolynomial] under the name [nrobp]
+
+Up: [conversion] of [dnnf] to [nfbdd]
diff --git a/dominating_set b/dominating_set
@@ -0,0 +1,17 @@
+# Dominating set
+
+https://en.wikipedia.org/wiki/Dominating_set
+
+A subset of vertices of a graph such that every vertex of the graph is either in the set or adjacent to a vertex in the set
+- distinguish [total_dominating_set] (aka "strongly-dominating set"): every vertex in the graph is adjacent to a vertex in the set, including the vertices in the set themselves. Does not always exist (e.g., isolated vertices)
+
+[karthik2019parameterized]: no [fixed_parameter_tractable] [approximation] algorithm for the problem
+- uses [abboud2017distributed]
+
+Generalization: [generalized_dominating_set]
+
+Variant: [independent_dominating_set]
+
+See also: [edge_dominating_set]
+
+Up: [graph_substructure]
diff --git a/drx b/drx
@@ -0,0 +1,7 @@
+# DRX
+
+Generalizes [deterministic_regular_expressions] by adding [backreferences]
+
+Defined in [freydenberger2019deterministic]
+
+Up: [regular_expression_deterministic]
diff --git a/dsdnnf b/dsdnnf
@@ -0,0 +1,7 @@
+# d-SDNNF
+
+[structuredness] [deterministic] [decomposable] [circuit]
+
+not closed under [complementation], cf [vinallsmeeth2024structured] by [harry]
+
+Up: [knowledge_compilation_classes], [ddnnf], [sdnnf]
diff --git a/dual b/dual
@@ -0,0 +1,6 @@
+# Dual
+
+- [flow_cut_duality]
+- [hypergraph_dual]
+
+Up: [mathematics]
diff --git a/dual_graph b/dual_graph
@@ -0,0 +1,11 @@
+# Dual graph
+
+[graph_undirected]:
+- vertices are [clause]s
+- edges connect two clauses that share a variable
+
+if [conjunctive_normal_form] has unbounded [degree] then contains a large [clique]
+
+Up: [graph_undirected] of [conjunctive_normal_form]
+
+See also: [primal_graph], [incidence_graph], [dual_treewidth]
diff --git a/dual_treewidth b/dual_treewidth
@@ -0,0 +1,7 @@
+# Dual treewidth
+
+[treewidth] of [dual_graph] of [conjunctive_normal_form] [boolean_formula]
+
+Up: [conjunctive_normal_form]
+
+See also: [dual_pathwidth]
diff --git a/dynamic_dynamic_programming b/dynamic_dynamic_programming
@@ -0,0 +1,5 @@
+# Dynamic dynamic programming
+
+[stacs_2023], [stefan_neumann]
+
+Up: [talk] about [dynamic_programming]
diff --git a/dynamic_programming b/dynamic_programming
@@ -0,0 +1,11 @@
+# Dynamic programming
+
+- [edit_distance]
+- [longest_increasing_subsequence]
+- [longest_common_subsequence]
+
+- [dynamic_dynamic_programming]
+
+Up: [algorithm_type]
+
+See also: [memoization]
diff --git a/edge b/edge
@@ -0,0 +1,9 @@
+# Edge
+
+A [pair] in [undirected_graphs], an [ordered_pair] in [directed_graphs].
+
+Special kind of edge: [self_loop]
+
+Up: [graph_basic_notions]
+
+Aliases: edges
diff --git a/edge_coloring b/edge_coloring
@@ -0,0 +1,8 @@
+# Edge coloring
+
+- [incremental_maintenance_edge_coloring]
+- [vizings_theorem]
+
+Up: [graph_coloring]
+
+Aliases: edge colored
diff --git a/edge_cover b/edge_cover
@@ -0,0 +1,9 @@
+# Edge cover
+
+Set of edges of a [graph_undirected] such that every vertex is in at least one of the edges
+
+[minimum_edge_cover]
+
+See also: [vertex_cover], [edge_packing], [independent_set], [matching]
+
+Up: [graph]
diff --git a/edge_deletion b/edge_deletion
@@ -0,0 +1,5 @@
+# Edge deletion
+
+[koch2024edge]
+
+Up: [graph_modification]
diff --git a/edge_dominating_set b/edge_dominating_set
@@ -0,0 +1,13 @@
+# Edge dominating set
+
+https://en.wikipedia.org/wiki/Edge_dominating_set
+
+A set of edges such that every edge is either in the set or adjacent to an edge in the set
+
+[dominating_set] of the [line_graph]
+
+Distinguish: [dominating_edge_set]: set of edges whose union is a [dominating_set], may not exist (isolated vertices), connected to [total_dominating_set]
+
+See also: [dominating_set], [maximal_matching]
+
+Up: [graph_substructure]
diff --git a/edit_distance_oracle b/edit_distance_oracle
@@ -0,0 +1,7 @@
+# Edit distance oracle
+
+given two [string]s, index them so that given two [subword] you can quickly compute the edit distance:
+
+- [charalampopoulos2021almost]
+
+Up: [oracle] for [edit_distance_computation]
diff --git a/eggans_theorem b/eggans_theorem
@@ -0,0 +1,8 @@
+# Eggan's theorem
+
+https://en.wikipedia.org/wiki/Star_height#Eggan's_theorem
+https://en.wikipedia.org/wiki/Cycle_rank#Star_height_of_regular_languages
+
+[theorem]: The [star_height] of a [regular_language] L equals the minimum [cycle_rank] among all [automata_nondeterministic] with [epsilon_transition] accepting L.
+
+Up: [theorem], [regular_language]
diff --git a/enumeration b/enumeration
@@ -0,0 +1,24 @@
+# Énumeration
+
+https://en.wikipedia.org/wiki/Enumeration_algorithm
+
+- [enumeration_definition]
+- [enumeration_techniques]
+- [enumeration_tasks]
+- [enumeration_complexity]
+- [enumeration_related_work]
+- [enumeration_open_problems]
+
+## Related problems
+
+- [enumeration_ordered]
+- [tuple_testing]
+- [direct_access]
+
+## Questions
+
+- [enumeration_diversity]
+- [enumeration_ordered]
+- [incremental_maintenance_enumeration]
+
+Up: [research_directions]
diff --git a/enumeration_circuit b/enumeration_circuit
@@ -0,0 +1,13 @@
+# Enumeration on circuits
+
+Enumerating the [satisfying_assignment] of [boolean_circuit]
+
+Harder than [satisfiability_boolean] so [np_hard] on general [boolean_circuit]
+
+[amarilli2017circuit]: [enumeration] for [dsdnnf]
+
+[enumeration_sdnnf]
+
+Up: [enumeration] on [boolean_circuit]
+
+See also: [enumeration_via_circuit]
diff --git a/enumeration_definition b/enumeration_definition
@@ -0,0 +1,7 @@
+# Enumeration definition
+
+Two phases:
+- [preprocessing_phase]
+- [enumeration_phase] where you measure [delay]
+
+Up: [enumeration]
diff --git a/enumeration_diversity b/enumeration_diversity
@@ -0,0 +1,7 @@
+# Enumeration diversity
+
+- [merkl2023diversity]
+
+Up: [diversity], [enumeration]
+
+See also: [conjunctive_query_diversity]
diff --git a/enumeration_graphs b/enumeration_graphs
@@ -0,0 +1,7 @@
+# Enumeration graphs
+
+- [subgraph_enumeration]
+ - [triangle_enumeration]
+ - [clique_enumeration]
+
+Up: [enumeration] on [graph]
diff --git a/enumeration_ordered b/enumeration_ordered
@@ -0,0 +1,9 @@
+# Ordered enumeration
+
+- [enumeration_ordered_cq]
+- [enumeration_ordonnee_mso]
+- [enumeration_ordonnee_chemins]
+
+Up: [enumeration], [order]
+
+Aliases: ordered enumeration, enumeration ranked, ranked enumeration
diff --git a/enumeration_polylog_delay b/enumeration_polylog_delay
@@ -0,0 +1,7 @@
+# Enumeration polylog delay
+
+[enumeration] with [polylog] [delay] and [log_linear] [preprocessing]
+
+Up: [enumeration]
+
+See also: [enumeration_constant_delay]
diff --git a/enumeration_spanner b/enumeration_spanner
@@ -0,0 +1,8 @@
+# Enumeration spanner
+
+- [amarilli2019constant]
+- [enumeration] by [cristian] et al.: [rematch]
+
+Up: [enumeration] for [spanner]
+
+See also: [enumeration_strings]
diff --git a/enumeration_strings b/enumeration_strings
@@ -0,0 +1,22 @@
+# Enumeration on words
+
+- [enumeration_general_purpose]
+- [enumeration_distinct_factors]
+- [enumeration_cfg]
+- [enumeration_compressed]
+- [enumeration_slp]
+- [enumeration_core]
+- [enumeration_rpq]
+- [enumeration_streaming]
+- [enumeration_parallel]
+- [enumeration_spanner]
+
+Generalizations:
+
+- [enumeration_ordered]
+- [incremental_maintenance_language_enumeration]
+- [enumeration_dag]
+
+Up: [enumeration] on [word]
+
+See also: [find_all_occurrences]
diff --git a/enumeration_techniques b/enumeration_techniques
@@ -0,0 +1,9 @@
+# Enumeration techniques
+
+- [union_trick] by [arnaud_durand] and [yann_strozecki]
+ - cf [berkholz2020constantb] Theorem 2.1
+- [proximity_search], enumeration framework (cf [wepa_2022])
+- [enumeration_via_circuit]
+- [cheaters_lemma], in [carmeli2021enumeration] Lemma 7
+
+Up: [enumeration]
diff --git a/enumeration_ucqs_classifying b/enumeration_ucqs_classifying
@@ -0,0 +1,11 @@
+# Enumeration ucqs classifying
+
+[open_question] of determining which [union_of_conjunctive_queries] can have [enumeration] in [linear_preprocessing_constant_delay]
+
+and finding the best exponent for various UCQs ([fine_grained_complexity])
+ - cf works like [kara2019counting] (in the setting of [incremental_maintenance])
+ - cf [bringmann2023tight] which defines [incompatibility_number]
+
+discussed [bringmann2022unbalanced]
+
+Up: [enumeration_ucqs]
diff --git a/enumeration_via_circuit b/enumeration_via_circuit
@@ -0,0 +1,7 @@
+# Enumeration via circuit
+
+The general idea of performing [enumeration] via [circuit] using [knowledge_compilation] and [knowledge_compilation_classes]
+
+- [enumeration_via_circuit_gdr_ifm]
+
+Up: [enumeration] via [circuit]
diff --git a/equation b/equation
@@ -0,0 +1,12 @@
+# Equation
+
+- [word_equation]
+- [semiring_equation]
+- [polynomial_equation]
+- [diophantine_equation]
+
+- [equation_system]
+
+Up: [mathematics]
+
+See also: [disequation], [inequation]
diff --git a/equisatisfiability b/equisatisfiability
@@ -0,0 +1,9 @@
+# Equisatisfiability
+
+https://en.wikipedia.org/wiki/Equisatisfiability
+
+Two [logic_formulas] f and f' are equisatisfiable if f being satisfiable is [equivalent] to f' being satisfiable
+
+Up: [satisfiability]
+
+Aliases: equisatisfiable
diff --git a/equivalence b/equivalence
@@ -0,0 +1,16 @@
+# Equivalence
+
+As [computational_problem]:
+
+- [language_equivalence]
+- [query_equivalence]
+- [automaton_equivalence]
+- [regular_expression_equivalence]
+
+Other:
+
+- [equivalence_relation]
+
+Up: [mathematics]
+
+Aliases: equivalent
diff --git a/even_hole_free_graph b/even_hole_free_graph
@@ -0,0 +1,9 @@
+# Even hole free graph
+
+[graph_undirected] without [hole] of even length
+
+[survey_paper]: [vuskovic2010even]
+
+Up: [undirected_graph], [hole]
+
+See also: [graph_perfect]
diff --git a/exact_matching b/exact_matching
@@ -0,0 +1,8 @@
+# Exact matching
+
+- Input: [graph_bipartite] G with bicolored edges, integer k
+- Output: does G contain a matching with exactly k red edges
+
+[maalouly2022exact]: this is in [rp] and not known to be in [ptime]
+
+Up: [matching]
diff --git a/exact_triangle b/exact_triangle
@@ -0,0 +1,7 @@
+# Exact triangle
+
+Finding a triangle in [graph_weighted] whose edges sum to 0
+
+- [exact_triangle_conjecture]
+
+Up: [3sum], [triangle]
diff --git a/exact_triangle_conjecture b/exact_triangle_conjecture
@@ -0,0 +1,6 @@
+# Exact triangle conjecture
+
+- implied by [3sum_hypothesis]
+- implied by [apsp_hypothesis] <=> [negative_triangle_hypothesis]
+
+Up: [computational_hypothesis] on [exact_triangle]
diff --git a/exponentiation b/exponentiation
@@ -0,0 +1,8 @@
+# Exponentiation
+
+- [graph_exponentiation]
+- [exponentiation_by_squaring]
+
+Up: [mathematics_operation]
+
+See also: [exptime], [semigroup], [multiplication], [power_mathematics], [squaring], [square_root]
diff --git a/external_memory b/external_memory
@@ -0,0 +1,6 @@
+# External memory
+
+Papers looking at the [input_output_complexity] of [algorithms]
+- cf [vitter2008algorithms]
+
+Up: [machine_model]
diff --git a/extremal_graph_theory b/extremal_graph_theory
@@ -0,0 +1,13 @@
+# Extremal graph theory
+
+https://en.wikipedia.org/wiki/Extremal_graph_theory
+
+- [ramsey_turan_theory]
+ - [ramsey_theorem]
+ - [turan_theorem]
+
+- [mantels_theorem]
+
+- [szemeredi_regularity_lemma]
+
+Up: [extremal_combinatorics] on [graph]
diff --git a/factor b/factor
@@ -0,0 +1,11 @@
+# Factor
+
+Definition: [word] u is factor of [word] v if we have v = xuy for some [word]s x and y
+
+- [factor_universal]
+
+Up: [formal_language_theory]
+
+See also: [subword], [prefix], [suffix]
+
+Aliases: factors, infix, infixes
diff --git a/factor_universal b/factor_universal
@@ -0,0 +1,9 @@
+# Factor universal
+
+[automata] where every [word] is a [factor] of an accepted word
+
+Testing if a [automata_deterministic] is factor-universal is in [ptime] via [synchronizing_word], cf [rampersad2009computational] Theorem 5
+
+Testing if a [automata_nondeterministic] is factor-universal is [pspace_hard], cf [rampersad2009computational] Theorem 9
+
+Up: [universality_automata]
diff --git a/fcreg b/fcreg
@@ -0,0 +1,7 @@
+# FC[REG]
+
+[freydenberger2021theory]
+
+[FC] with [regular_language] predicates: variable belongs to [regular_language]
+
+Up: [FC]
diff --git a/feedback_edge_number b/feedback_edge_number
@@ -0,0 +1,9 @@
+# Feedback edge number
+
+minimum number of edges to remove ([feedback_edge_set]) to destroy all cycles
+
+usually posed for [graph_directed]; for [graph_undirected] see [circuit_rank]
+
+See also: [feedback_vertex_set], [feedback_vertex_number], [circuit_rank], [cycle_rank]
+
+Up: [width_measure]
diff --git a/feedback_vertex_set b/feedback_vertex_set
@@ -0,0 +1,11 @@
+# Feedback vertex set
+
+for [graph_undirected] or [graph_directed]
+
+set of [vertices] whose removal turns [graph] into [acyclic_graph]
+
+[computational_problem]: [minimum_feedback_vertex_set] ([np_complete])
+
+Up: [width_measure]
+
+See also: [feedback_arc_set], [erdos_posa], [feedback_edge_number]
diff --git a/final_state b/final_state
@@ -0,0 +1,11 @@
+# Final state
+
+A notion for [states] in an [automaton].
+
+If a [run] ends at a [state] which is a final state then the run is [accepting_run].
+
+Up: [automata_concepts]
+
+Aliases: final states
+
+See also: [nonfinal_state]
diff --git a/fine_grained_complexity_problems b/fine_grained_complexity_problems
@@ -0,0 +1,15 @@
+# Fine grained complexity problems
+
+- [orthogonal_vectors]
+- [omv]
+- [set_disjointness]
+- [3sum]
+- [all_pairs_shortest_path]
+- [boolean_matrix_multiplication]
+ - [sparse_boolean_matrix_multiplication]
+- [vutd]
+- [zero_clique]
+- [triangle_detection] / [sparse_triangle]
+- [hyperclique] / [sparse_hyperclique]
+
+Up: [fine_grained_complexity], [computational_problem]
diff --git a/finite_model_theory b/finite_model_theory
@@ -0,0 +1,5 @@
+# Finite model theory
+
+- [finite_controllability]
+
+Up: [logic], [finite]
diff --git a/first_order_logic_regular_language b/first_order_logic_regular_language
@@ -0,0 +1,11 @@
+# First order logic regular language
+
+On [word], [first_order_logic] corresponds to [star_free_language] and [monoid_aperiodic] by [schutzenbergers_theorem]
+
+connections to [fok]:
+- 3 variables suffice to express all first-order definable languages: [diekert2008survey]
+- [fo2] corresponds to [da]
+ - connections to [unambiguous_polynomial]
+- [fo1] trivial
+
+Up: [first_order_logic], [regular_language]
diff --git a/first_order_model_checking b/first_order_model_checking
@@ -0,0 +1,19 @@
+# First order model checking
+
+## On specific graph classes
+
+[first_order_model_checking_restricted_classes]
+
+## [hypothesis]
+
+[first_order_property_conjecture] on the hardness of FO model checking, cf [gao2018completeness]
+ - it is a weaker version of [strong_exponential_time_hypothesis]
+
+## Bounded variables
+
+- [first_order_model_checking_fok]
+- [first_order_model_checking_fo2]
+
+Up: [model_checking] for [first_order_logic]
+
+See also: [fine_grained_complexity], [clique_problem]
diff --git a/first_order_rewriting b/first_order_rewriting
@@ -0,0 +1,7 @@
+# First order rewriting
+
+- [fok_rewriting]
+
+Up: [query_rewriting], [first_order_logic]
+
+Aliases: first_order_rewritability, first_order_rewritable
diff --git a/fo_tc b/fo_tc
@@ -0,0 +1,7 @@
+# FO+TC
+
+[first_order_logic] with [transitive_closure]
+
+Is equivalent to [datalog_stratified_linear]
+
+Up: [first_order_logic] with [transitive_closure]
diff --git a/formal_language b/formal_language
@@ -0,0 +1,20 @@
+# Formal language
+
+[set] of [word] over an [alphabet]
+
+- [regular_language]
+- [weighted_language]
+- [visibly_pushdown_language]
+- [context_free_language]
+- [formal_language_operator]
+- [slice]: subset of the [word]s of a certain length
+- [density_function]
+- [language_unary]
+
+- [computational_problems]: [formal_language_computational_problems]
+
+Up: [formal_language_theory]
+
+See also: [neutral_letter]
+
+Aliases: formal languages
diff --git a/formal_language_computational_problems b/formal_language_computational_problems
@@ -0,0 +1,9 @@
+# Formal language computational problems
+
+- [membership_problem]
+- [language_inclusion]
+- [language_equivalence]
+
+Up: [formal_language]
+
+Aliases: formal language computational problem
diff --git a/formal_language_theory b/formal_language_theory
@@ -0,0 +1,57 @@
+# Formal language theory
+
+Studies [formal_language]
+
+## Concepts
+
+- [alphabet]
+- [word]
+ - [empty_word]
+- [formal_language]
+- [prefix], [suffix], [subword], [subsequence]
+
+## Operations
+
+- [shuffle]
+
+## Languages
+
+- [regular_language]
+ - [piecewise_testable_language]
+ - [locally_testable_language]
+- [regular_expression]
+- [automata]
+- [transducer]
+ - [tree_automaton]
+ - [tree_walking_automaton]
+- [context_free_grammar]
+ - [pcfg]
+ - [grammar_variants]
+
+## Problems
+
+- [constrained_topological_sort]
+
+## Other notions
+
+- [word_equation]
+- [sliding_window]
+- [atom]
+- [parikh_automaton], [parikh_image]
+- [formal_language_separation]
+- [determinism_language]
+
+## Results
+
+- [higmans_lemma]
+- [krohn_rhodes]
+- [brzozoswki_mccluksey]
+- [language_power_series]: connections between formal languages and [power_series]
+- [pumping_lemma]
+- [ogdens_lemma]
+- [interchange_lemma] https://en.wikipedia.org/wiki/Interchange_lemma
+ - other such results: https://cstheory.stackexchange.com/a/54032
+
+Up: [theoretical_computer_science]
+
+See also: [word_combinatorics]
diff --git a/fotc b/fotc
@@ -0,0 +1,7 @@
+# FO+TC
+
+[first_order_logic] with [transitive_closure] operator
+
+See also: [separation_logic], [fixpoint], [datalog]
+
+Up: [logic]
diff --git a/four_color_theorem b/four_color_theorem
@@ -0,0 +1,8 @@
+# Four color theorem
+
+Variant on graphs embedded in more general [genus]:
+ - https://en.wikipedia.org/wiki/Heawood_conjecture
+
+Generalization: [inoue2024three]
+
+Up: [graph_coloring] of [planar_graph]
diff --git a/fpras_bpp b/fpras_bpp
@@ -0,0 +1,11 @@
+# FPRAS BPP
+
+[theorem]: if a [counting_problem] admits an [fpras], then the corresponding [decision_problem] of testing if the count is >0 is in [bpp]
+- for [satisfiability_boolean] for instance:
+ - if [sharp_satisfiability] admits an [fpras], then [satisfiability_boolean] is in [bpp]
+- this is specific to >0 and does not work, say, for <2^n (problem of relative
+ error)
+
+Proof: with proba 3/4 your [fpras] "works", and "works" here means "returns exactly the correct value"
+
+Up: [result] on [fpras]
diff --git a/friendship_theorem b/friendship_theorem
@@ -0,0 +1,11 @@
+# Friendship theorem
+
+https://en.wikipedia.org/wiki/Friendship_graph#Friendship_theorem
+
+"if in a [graph] any pair of vertices have exactly one common [neighbor] then the graph is a [friendship_graph]"
+
+In [graph_directed]: [choi2023digraph]
+
+Up: [graph_theory]
+
+See also: [handshaking_lemma]
diff --git a/frontier_guarded b/frontier_guarded
@@ -0,0 +1,9 @@
+# Frontier guarded
+
+introduced in [baget2010walking]
+
+Special case:
+
+- [frontier_one]
+
+Up: [guarded_fragment]
diff --git a/function b/function
@@ -0,0 +1,23 @@
+# Function
+
+can be [function_partial]
+
+- [linear_function]
+ - [piecewise_linear] function
+
+- [or_function]
+- [set_function]
+- [hash_function]
+- [boolean_function]
+- [concave_function]
+- [density_function]
+- [ranking_function]
+- [Ackermann's_function]
+
+Notions:
+
+- [function_evaluation]
+
+Up: [mathematics]
+
+See also: [functional_dependency]
diff --git a/function_evaluation b/function_evaluation
@@ -0,0 +1,9 @@
+# Function evaluation
+
+[computational_problem]: Given a [function] f and a value x, compute f(x)
+
+- [boolean_function_evaluation]
+
+Up: [computational_problem], [function]
+
+Aliases: evaluation, evaluates, evaluate
diff --git a/functional_dependency b/functional_dependency
@@ -0,0 +1,25 @@
+# Functional dependency (FD)
+
+## Special cases
+
+- [key]
+- "simple": X -> Y where X and Y are singleton [attribute]s
+ - also called "unary"? [functional_dependency_unary]
+
+## Problems
+
+- [dependency_implication]
+ - [undecidability] for functional dependency and [inclusion_dependency]
+
+## Results
+
+- [armstrong_axioms]
+- [armstrong_relation]
+
+## Variants
+
+- [functional_dependency_approximate]
+
+Up: [equality_generating_dependency]
+
+Aliases: FD, FDs
diff --git a/functional_dependency_approximate b/functional_dependency_approximate
@@ -0,0 +1,8 @@
+# Functional dependency approximate
+
+- Survey with real-world study: parciak2023measuring
+- approximate implication: kenig2019integrity
+
+Tags: #wikipedia
+
+Up: [functional_dependency]
diff --git a/game_theory b/game_theory
@@ -0,0 +1,10 @@
+# Game theory
+
+studies [games]
+
+- [shapley_value]
+- [parity_games] et [pseudopolynomial]-time algorithm
+- [muller_acceptance]
+- [prisoners_dilemma]
+
+Up: [mathematics]
diff --git a/gapped_pattern_matching b/gapped_pattern_matching
@@ -0,0 +1,9 @@
+# Gapped pattern matching
+
+[navarro2016reporting]: find consecutive occurrences of [pattern] in [string] satisfying a certain gap constraint
+
+Generalization in [akram2024sorted]: find occurrences of [pattern] in a specified [infix] of a [string]
+
+[bille2022string]: find the [top_k] closest occurrences in decreasing order ([ranked_enumeration])
+
+Up: [pattern_matching]
diff --git a/gelade2009regular b/gelade2009regular
@@ -0,0 +1,19 @@
+# Gelade2009regular
+
+[regular_expression_repetition] operator
+
+not easy how to define [regular_expression_deterministic] with this operator
+
+[regular_expression_strongly_deterministic] is now useful because it makes it possible to store only one counter configuration
+
+- [counter_automata_definition]
+ - thanks to the threshold function, the entire configuration graph can be materialized
+ - if the automaton is [counter_automata_deterministic] then it is a [DFA]
+- [glushkov_automaton] augmented with counters
+ - if the regexp is [regular_expression_strongly_deterministic] then the [gluskov_automaton] with counters is [counter_automata_deterministic]
+
+also [dynamic_membership] in [bjorklund2015efficient]
+
+Up: [academic_paper] on [regular_expressions_counting]
+
+See also: [wim_martens]
diff --git a/generalized_core_spanner b/generalized_core_spanner
@@ -0,0 +1,7 @@
+# Generalized core spanner
+
+closure of [spanner_core] under [complementation]
+
+expressive power [thompson2023generalized]
+
+Up: [spanner]
diff --git a/geometry b/geometry
@@ -0,0 +1,13 @@
+# Geometry
+
+- [tiling]
+- arrangements of spheres "kissing number"
+- [moving_sofa_problem]
+- [computational_geometry]
+
+- [square]
+- [circle]
+- [rectangle]
+- [symmetry]
+
+Up: [mathematics]
diff --git a/gf2 b/gf2
@@ -0,0 +1,5 @@
+# Gf2
+
+According to [cate2023craig], enjoys [finite_model_property] and [craig_interpolation]
+
+Up: [logic]
diff --git a/goedels_incompleteness_theorem b/goedels_incompleteness_theorem
@@ -0,0 +1,7 @@
+# Goedels incompleteness theorem
+
+http://www.yann-ollivier.org/goedel/goedel.php
+
+Up: [theorem], [logic]
+
+See also: [undecidability]
diff --git a/goldbach_conjecture b/goldbach_conjecture
@@ -0,0 +1,7 @@
+# Goldbach conjecture
+
+- [ternary_goldbach_problem]
+
+See also: [twin_prime_conjecture], [chens_theorem]
+
+Up: [number_theory]
diff --git a/golomb_ruler b/golomb_ruler
@@ -0,0 +1,18 @@
+# Golomb ruler
+
+https://en.wikipedia.org/wiki/Golomb_ruler
+
+set of [natural_numbers] such that no difference (in [absolute_value]) is achieved twice
+
+- order: number of elements of the set
+- length: value of the greatest integer
+- optimal ruler: no ruler of the same order and of smaller length exists (optimally short)
+ - also optimally dense: no rules exists with greater order and same length
+- perfect ruler https://en.wikipedia.org/wiki/Perfect_ruler : every distance below a certain bound is achieved exactly once
+ - optimal perfect ruler: minimal length (largest value)
+ - no perfect golomb ruler for five or more marks exists
+ - cf http://cgm.cs.mcgill.ca/~athens/cs507/Projects/2003/JustinColannino/
+
+Up: [combinatorics]
+
+See also: [sidon_set]
diff --git a/graceful_labeling b/graceful_labeling
@@ -0,0 +1,13 @@
+# Graceful labeling
+
+https://en.wikipedia.org/wiki/Graceful_labeling
+
+- Vertices are labeled with distinct values in {0, ..., m}
+- Thus, each edge has an absolute value difference of at least 1 and at most m
+- A "graceful labeling" is one where each possible difference is achieved exactly once
+
+Special cases:
+
+- [graceful_tree]
+
+Up: [graph_labeling]
diff --git a/graceful_tree b/graceful_tree
@@ -0,0 +1,6 @@
+# Graceful tree
+
+[open_problems]
+https://en.wikipedia.org/wiki/Graceful_labeling
+
+Up: [graceful_labeling] of [tree]
diff --git a/graph_algorithm b/graph_algorithm
@@ -0,0 +1,17 @@
+# Graph algorithm
+
+- [network_flow]
+- [maximum_matching] for [matching]
+ - [maximum_weighted_matching] and [hungarian_algorithm]
+- [shortest_path] ([graph_distance])
+ - [minmax_path]
+- [convex_hull]
+- [spanning_tree]
+ - [kruskals_algorithm], see also [minmax_path]
+- [steiner_tree]
+- [topological_sorting] of [directed_acyclic_graph]
+- [strong_connectivity_augmentation]
+- [transitive_closure]
+- [transitive_orientation]
+
+Up: [algorithms] on [graph]
diff --git a/graph_basic_notions b/graph_basic_notions
@@ -0,0 +1,33 @@
+# Graph basic notions
+
+- [degree]
+- [connected_component]
+ - [connectivity]
+- [strongly_connected]
+ - [strongly_connected_component]
+- [path]
+ - [simple_path]
+ - [trail]
+ - [eulerian_trail]
+ - [walk]
+- [cycle]
+ - [circuit]
+ - [tour]
+ - [hamiltonian_cycle]
+- [vertex_cover]
+- [edge_cover]
+- [articulation_point]
+- [matching]
+- [graph_isomorphism]
+ - [graph_automorphism]
+- [subgraph], [induced_subgraph]
+- [vertex]
+- [edge]
+ - [self_loop]
+- [graph_representation]
+ - [adjacency_matrix]
+ - [adjacency_list]
+
+Up: [graph]
+
+See also: [multigraph]
diff --git a/graph_bipartite b/graph_bipartite
@@ -0,0 +1,11 @@
+# Graph bipartite
+
+Membership can be tested in [linear_time] with [greedy_algorithm]
+
+- [deficiency]
+
+Up: [graph_family]
+
+See also: [hypergraph_balanced], [incidence_structure], [3_colorable]
+
+Aliases: bipartite graph, bipartite graphs
diff --git a/graph_caterpillar b/graph_caterpillar
@@ -0,0 +1,13 @@
+# Caterpillar graph
+
+https://en.wikipedia.org/wiki/Caterpillar_tree
+
+[Undirected_graph] which consists of a [path] with some added [leaves]
+
+[proskurowski1999classes]: caterpillar graphs are exactly the [connected_graphs] with [pathwidth] one
+
+See also: [graph_lobster], [horsetail_graph]
+
+Up: [graph_undirected], [path_excentricity]
+
+Aliases: caterpillar graph, caterpillar tree
diff --git a/graph_coloring b/graph_coloring
@@ -0,0 +1,40 @@
+# Graph coloring
+
+## Special cases
+
+- [bipartite_graph]
+- [3_coloring]
+ - [3_colorable]
+
+## Results
+
+- [grotzschs_theorem]:
+ - [planar_graph] which has no [triangle] is 3-colorable
+- [graph_coloring_greedy]: if a graph has maximal [degree] d then it has a coloring with d+1 colors at most ([greedy_algorithm])
+
+## Conjectures
+
+- [hadwiger_conjecture]
+
+## Variants
+
+- [edge_coloring]
+- [list_coloring]
+- [graph_coloring_counting]
+
+## Complexity
+
+- [np_complete], already for [graph_planar] and 4-regular graphs
+ - [np_complete] to find if it is 3 or 4
+ - knowing if it is 2 is [graph_bipartite] hence [ptime]-testable
+ - 4 colors is always feasible by the [four_color_theorem]
+- [3_coloring] is in [linear_time] by [Brook's_theorem] on [graphs] of maximal [degree] 3
+ - see https://cstheory.stackexchange.com/questions/51368/which-hypergraphs-can-be-simplified-by-alternatively-removing-a-hyperedge-and-an
+
+## References
+
+"Graph Coloring Methods" book: https://graphcoloringmethods.com/
+
+Up: [graph_problem]
+
+See also: [chromatic_number]
diff --git a/graph_coloring_diameter b/graph_coloring_diameter
@@ -0,0 +1,6 @@
+# Graph coloring diameter
+
+Is it [ptime] to solve [3_coloring] on graphs of [diameter] 2?
+- cf [climosova2023coloring]
+
+Up: [open_problem], [diameter], [graph_coloring]
diff --git a/graph_coloring_greedy b/graph_coloring_greedy
@@ -0,0 +1,8 @@
+# Graph coloring greedy
+
+If an [undirected_graph] has [maximal_degree] d then it has a coloring with d+1 colors at most
+- simple [greedy_algorithm]
+
+Up: [graph_coloring], [greedy_algorithm]
+
+See also: [vizings_theorem]
diff --git a/graph_complementation b/graph_complementation
@@ -0,0 +1,5 @@
+# Graph complementation
+
+[Undirected_graph] formed from an other graph G by keeping the same set of [vertices] and taking precisely the [edges] that are not in G
+
+Up: [graph], [complementation]
diff --git a/graph_cube b/graph_cube
@@ -0,0 +1,7 @@
+# Graph cube
+
+[graph_exponentiation] of [graph] by 3
+
+Up: [graph_exponentiation]
+
+See also: [graph_cubic]
diff --git a/graph_database_practical b/graph_database_practical
@@ -0,0 +1,17 @@
+# Graph database practical
+
+Implementations:
+
+- [Neo4j]
+
+Query languages:
+
+- [graph_query_languages]
+
+Models:
+
+- [Property_graph]s: nodes and directed edges which have an ID and takes a value from some property
+
+Up: [graph_database]
+
+See also: [triple_store]
diff --git a/graph_directed b/graph_directed
@@ -0,0 +1,12 @@
+# Graph directed
+
+[graph] where [edge]s are [ordered_pair]s
+
+- [directed_acyclic_graph]
+- [graph_period]
+
+Up: [graph]
+
+See also: [graph_undirected]
+
+Aliases: directed graph, directed graphs
diff --git a/graph_exponentiation b/graph_exponentiation
@@ -0,0 +1,17 @@
+# Graph exponentiation
+
+for an [integer] k and [graph] G, the graph exponentiation of G by k is the graph with same [vertices] with an edge from u to v if there is a path of length at most k from u to v
+- related to [exponentiation] of [adjacency_matrix]
+
+- [graph_cube] for exponentiation by 3
+- [graph_square] for exponentiation by 2
+
+Uses:
+
+- for [hamiltonian_cycle], cf [hamiltonian_cycle_cube]
+- for [graph_coloring]
+ - cf https://cstheory.stackexchange.com/questions/51269/upper-bound-for-distance-two-chromatic-number-in-terms-of-maximum-degree
+
+See also: [Moore_graph]
+
+Up: [graph]
diff --git a/graph_isomorphism b/graph_isomorphism
@@ -0,0 +1,7 @@
+# Graph isomorphism
+
+[graph_isomorphism_problem]
+
+Up: [isomorphism] of [graph]
+
+See also: [graph_homomorphism], [canonical_labeling], [weisfeiler_leman], [graph_automorphism]
diff --git a/graph_labeling b/graph_labeling
@@ -0,0 +1,8 @@
+# Graph labeling
+
+- [abiteboul2005compact] labeling scheme for [ancestor] queries
+- [distance_labeling]: cf [gawrychowski2023better]
+- [graceful_labeling]
+- [canonical_labeling]
+
+Up: [graph]
diff --git a/graph_minor b/graph_minor
@@ -0,0 +1,11 @@
+# Graph minor
+
+- [contraction]
+
+[graph_minor_testing]
+
+Up: [graph]
+
+See also: [robertson_seymour], [topological_minor], [excluded_minor]
+
+Aliases: graph minors
diff --git a/graph_orientation b/graph_orientation
@@ -0,0 +1,7 @@
+# Graph orientation
+
+- [transitive_orientation]
+- [balanced_orientation]
+- [constraint_graph_satisfiability]
+
+Up: [computational_problem] on [graph]
diff --git a/graph_packing b/graph_packing
@@ -0,0 +1,11 @@
+# Graph packing
+
+A [packing_problem] in [graph]s
+
+E.g., [path], [triangle], etc.
+
+- [Tuza's_conjecture]
+
+Up: [computational_problem] on [graph]
+
+See also: [packing_problem], [graph_partition]
diff --git a/graph_partition b/graph_partition
@@ -0,0 +1,11 @@
+# Graph partition
+
+splitting a [graph] into [connected_component]s with prescribed size
+
+[graph_partition_hardness]
+
+Also on edges: [graph_partition_edges]
+
+See also: [graph_packing], [partition_problem], [3_partition]
+
+Up: [computational_problem] on [graph]
diff --git a/graph_pattern_counting b/graph_pattern_counting
@@ -0,0 +1,7 @@
+# Graph pattern counting
+
+Count the number of isomorphic copies of one graph in another graph
+
+Up: [counting_problem]
+
+See also: [triangle_counting]
diff --git a/graph_perfect b/graph_perfect
@@ -0,0 +1,9 @@
+# Graph perfect
+
+[Undirected_graph] G where for every [induced_subgraph] H of G, the [chromatic_number] of H is equal to the size of the [largest_clique] of H
+
+- [strong_perfect_graph_theorem]: a graph is perfect iff it is a [berge_graph]
+
+Up: [graph_family]
+
+Aliases: perfect graph
diff --git a/graph_query_languages b/graph_query_languages
@@ -0,0 +1,36 @@
+# Graph query languages
+
+https://www.gqlstandards.org/
+
+Theoretical languages:
+
+- [Regular_Path_Query] (RPQ)
+- [2RPQ]: two-way
+- [UC2RPQ]: unions of conjunctions of RPQs
+- [nested_regular_expressions] (NRE):
+ - on an [element] you can test if a given path exists
+ - between square brackets
+ - like [xpath]
+- [regular_query]:
+ - binary non-recursive [datalog] with [transitive_closure] of binary predicates
+ - captures [nested_regular_expressions] et [uc2rpq]
+- [Conjunctive_context_free_path_query]
+- [Regular_queries_with_memory]
+- [SPARQL]
+
+Semantics:
+
+- [shortest_path]
+- [simple_path] (no repeated vertices)
+- [trail] (no repeated edges)
+
+Also:
+
+- [graph_query_languages_practical]
+- [graph_query_languages_standards]
+
+Historically: [cruz1987graphical]
+
+Up: [graph_database]
+
+See also: [fixpoint], [self_join]
diff --git a/graph_square b/graph_square
@@ -0,0 +1,7 @@
+# Graph square
+
+[graph_exponentiation] by 2 of [undirected_graph]
+
+Up: [graph_exponentiation]
+
+See also: [radoszewski2011hamiltonian], [graph_cube]
diff --git a/graph_theory b/graph_theory
@@ -0,0 +1,6 @@
+# Graph theory
+
+- [friendship_theorem]
+- [handshaking_lemma]
+
+Up: [theoretical_computer_science] on [graph]
diff --git a/graph_undirected b/graph_undirected
@@ -0,0 +1,9 @@
+# Graph undirected
+
+[graph] where [edge]s are [pair]s
+
+See also: [graph_directed]
+
+Up: [graph]
+
+Aliases: undirected graph, undirected graphs
diff --git a/graph_weighted b/graph_weighted
@@ -0,0 +1,11 @@
+# Graph weighted
+
+graph where [edge]s carry [weight]
+
+can be used for [shortest_path]
+
+[graph_weighted_regimes]
+
+Up: [graph], [weight]
+
+Aliases: weighted graph, weighted graphs
diff --git a/gray_code b/gray_code
@@ -0,0 +1,10 @@
+# Gray code
+
+- [mutze2022combinatorial]: [survey_paper]
+ - avoiding a given [subword], cf [squire1996gray] and references from above survey
+ - cf [minimal_absent_word]
+- older survey: [savage1997survey]
+
+Up: [enumeration]
+
+See also: [middle_levels_conjecture], [torsten]
diff --git a/greedy_algorithm b/greedy_algorithm
@@ -0,0 +1,7 @@
+# Greedy algorithm
+
+Algorithm where you can build an optimal solution step by step by making choices in a specific order, without having to do [backtracking]
+
+See also: [matroid]
+
+Up: [algorithm_type]
diff --git a/green2007provenance b/green2007provenance
@@ -0,0 +1,5 @@
+# green2007provenance
+
+[provenance] for [conjunctive_query] and [union_of_conjunctive_queries] and [datalog] ([provenance_datalog], using [derivation_tree]) via [semiring] and [formal_series]
+
+Up: [academic_paper] on [provenance]
diff --git a/grid_graph b/grid_graph
@@ -0,0 +1,9 @@
+# Grid graph
+
+- [grid_minor]
+- [subdivision] of grid graph
+ - counting in exponential subdivision of grid graphs, cf [makowsky2003tree] proposition 32
+
+Up: [graph_family]
+
+See also: [wall_graph]
diff --git a/grid_minor b/grid_minor
@@ -0,0 +1,15 @@
+# Grid minor extraction
+
+[theorem] about finding [grid_graph] as [graph_minor] of [graph_undirected] of high [treewidth]
+
+relevant [academic_papers]:
+- [lanzinger2022complexity]
+- [chekuri2016polynomial]
+
+used for [hardness] results, e.g., [grohe2007complexity]
+
+Up: [theorem] about [grid_graph]
+
+See also: [grid_minor_directed]
+
+Aliases: grid minor extraction, grid extraction
diff --git a/grid_minor_directed b/grid_minor_directed
@@ -0,0 +1,5 @@
+# Grid minor directed
+
+- [hatzel2024cycles]
+
+Up: [grid_minor]
diff --git a/grotzschs_theorem b/grotzschs_theorem
@@ -0,0 +1,7 @@
+# Grotzsch's theorem
+
+https://en.wikipedia.org/wiki/Gr%C3%B6tzsch%27s_theorem
+
+[Planar_graph] with no [triangle] is always [3_colorable]
+
+Up: [graph_coloring], [theorem]
diff --git a/grounding b/grounding
@@ -0,0 +1,8 @@
+# Grounding
+
+Go from [first_order_logic] to [propositional_logic] on a given [structure]
+by replacing [existential_quantifier] and [universal_quantifier] with [conjunction] and [disjunction] over [domain]
+
+- [datalog_grounding]
+
+Up: [logic]
diff --git a/group_abelian b/group_abelian
@@ -0,0 +1,5 @@
+# Group abelian
+
+[commutative]
+
+Up: [group]
diff --git a/guarded_structure b/guarded_structure
@@ -0,0 +1,10 @@
+# Guarded structure
+
+A guarded [structure] is a [structure] S where either:
+- all [relation]s are empty or
+- there is a [relation] and a [fact] F (called "guard") such that
+ - the [active_domain] of F is the [active_domain] of S
+
+Up: [structure]
+
+See also: [guarded_fragment]
diff --git a/hamiltonian_cycle b/hamiltonian_cycle
@@ -0,0 +1,13 @@
+# Hamiltonian cycle
+
+[np_hard]
+
+[approximation] algorithm: [christofides_heuristic]
+
+- [hamiltonian_cycle_cube] on [graph_cube]
+- [hamiltonian_cycle_square] on [graph_square]
+- [hamiltonian_cycle_multiple] going multiple times over each [vertex]
+
+Up: [problem] on [graph]
+
+See also: [graph_eulerian], [hamiltonian_path]
diff --git a/hamiltonian_cycle_cube b/hamiltonian_cycle_cube
@@ -0,0 +1,5 @@
+# Hamiltonian cycle cube
+
+The [graph_cube] of a [graph] always has a [Hamiltonian_cycle]
+
+Up: [hamiltonian_cycle], [graph_cube]
diff --git a/hamiltonian_cycle_square b/hamiltonian_cycle_square
@@ -0,0 +1,5 @@
+# Hamiltonian cycle square
+
+see [radoszewski2011hamiltonian]
+
+Up: [hamiltonian_cycle], [graph_square]
diff --git a/hamming_weight b/hamming_weight
@@ -0,0 +1,7 @@
+# Hamming weight
+
+Hamming weight of a [vector] of [boolean] is the number of occurrences of 1
+
+See also: [hamming_distance]
+
+Up: [mathematics]
diff --git a/handshaking_lemma b/handshaking_lemma
@@ -0,0 +1,9 @@
+# Handshaking lemma
+
+https://en.wikipedia.org/wiki/Handshaking_lemma
+
+[Lemma] about [degree] and [parity] in [graph_undirected]
+
+Up: [lemma], [graph_theory]
+
+See also: [friendship_theorem]
diff --git a/heimberg2016hanf b/heimberg2016hanf
@@ -0,0 +1,5 @@
+# Heimberg2016hanf
+
+
+
+Up: [academic_paper] about [hanf_normal_form] for [fo_mod]
diff --git a/higmans_lemma b/higmans_lemma
@@ -0,0 +1,9 @@
+# Higman's lemma
+
+[words] on finite [alphabet] are [well_quasi_ordering] by [subsequence] relation
+
+Of course does not work with [subword]
+
+Up: [lemma], [word_combinatorics]
+
+See also: [language_downwards_closed]
diff --git a/hitting_set b/hitting_set
@@ -0,0 +1,15 @@
+# Hitting set
+
+Given a family of sets on a universe, find a smallest subset of elements that
+intersects every set in the family
+
+The [dual] is the [set_cover] problem: find the smallest subset of sets whose
+union is equal to the universe. This duality is explained here
+<https://en.wikipedia.org/wiki/Set_cover_problem#Hitting_set_formulation>.
+Indeed, when considering the set of occurrences of every element for the set cover problem (the new sets), we want to find a subset of elements (the original sets) that intersects every new set (= the original elements), i.e., a subset of the original sets such that every original element is contained in a set of the subset.
+
+In [computational_geometry]: "stabbing" or "piercing" cf [nielsen2000fast]
+
+Up: [computational_problem] on [set]
+
+See also: [small_universe_hitting_set]
diff --git a/hk_queries b/hk_queries
@@ -0,0 +1,7 @@
+# Hk queries
+
+family of queries used in [pqe]
+
+used in [monet2020solving]
+
+Up: [union_of_conjunctive_queries]
diff --git a/hole b/hole
@@ -0,0 +1,12 @@
+# Hole
+
+[Induced_cycle] of length at least 4
+
+- [hole_odd]
+ - [odd_hole_free_graph]
+- [hole_even]
+ - [even_hole_free_graph]
+
+- [antihole]
+
+Up: [cycle_induced]
diff --git a/homomorphism b/homomorphism
@@ -0,0 +1,15 @@
+# Homomorphism
+
+- [homomorphism_closed]
+- [homomorphism_equivalence]
+- [graph_homomorphism]
+- [homomorphism_count]
+
+Variants:
+- [automorphism]
+- [endomorphism]
+- [morphism]
+
+Up: [mathematics]
+
+See also: [core]
diff --git a/homomorphism_closed b/homomorphism_closed
@@ -0,0 +1,8 @@
+# Homomorphism closed
+
+[query] Q closed under [homomorphism]:
+ - if A satisfies Q and A has [homomorphism] to B then B also satisfies Q
+
+[cate2023when]: characterization of which classes are closed under [homomorphism_count]
+
+Up: [closure] under [homomorphism]
diff --git a/hopcrofts_algorithm b/hopcrofts_algorithm
@@ -0,0 +1,15 @@
+# Hopcroft's algorithm
+
+https://fr.wikipedia.org/wiki/Algorithme_de_Hopcroft_de_minimisation_d%27un_automate_fini
+
+Constructs [myhill_nerode_equivalence] by successive refinement from the partition of states into [final_states] and [nonfinal_states];
+- looks like an optimized version of [Moore's_algorithm]
+
+most efficient known algorithm:
+- in O(s n log n)
+ - for n the number of [states] of the [automaton]
+ - and s the [alphabet] size
+
+Up: [minimization_automaton]
+
+See also: [Moore's_algorithm]
diff --git a/horn_2sat b/horn_2sat
@@ -0,0 +1,5 @@
+# Horn 2sat
+
+[satisfiability_boolean] with [2horn_clause]
+
+Up: [horn_sat], [2sat]
diff --git a/horn_sat b/horn_sat
@@ -0,0 +1,13 @@
+# Horn sat
+
+https://en.wikipedia.org/wiki/Horn-satisfiability
+
+[satisfiability_boolean] with [horn_clause]
+
+In [ptime], and [p_complete]
+
+For [pqe]:
+ - already [sharpp_hard] (from [pp2dnf] by negating one of the sides)
+ - even in the case of [horn_2sat]
+
+Up: [sat_variants] with [horn_clause]
diff --git a/horsetail_graph b/horsetail_graph
@@ -0,0 +1,11 @@
+# Horsetail graph
+
+[Undirected_graphs] whose [graph_square] has [Hamiltonian_path]
+
+Studied in [radoszewski2011hamiltonian]
+
+See also: [hamiltonian_cycle_cube], [graph_caterpillar]
+
+Up: [graph_undirected]
+
+Aliases: horsetail graphs, graph horsetail
diff --git a/hunters_and_rabbit_directed b/hunters_and_rabbit_directed
@@ -0,0 +1,5 @@
+# Hunter and rabbits directed
+
+see [benameur2024cops] and [benameur2024complexity]
+
+Up: [hunters_and_rabbit] on [graph_directed]
diff --git a/hypergraph b/hypergraph
@@ -0,0 +1,31 @@
+# Hypergraph
+
+generalizes [graph]
+
+## Basic definitions
+
+- [vertex]
+- [hyperedge]
+- [primal_graph] aka "Gaifman graph"
+
+## Classes
+
+- [hypergraph_uniform]
+- [hypergraph_reduced] "reduced": no incomparable edges
+- [hypergraph_laminar]: cf [delpia2018multilinear]
+- [fagin1983degrees]: degrees of acyclicity
+ - also [degree_of_acyclicity]: [alpha_acyclic], etc.
+ - cyclic hypergraph contains one of:
+ - (k,k-1)-hyperclique: k vertices, each k-1 contains an edge
+ - cf [hypergraph_conformal]
+ - induced k-cycle
+- [hypergraph_balanced]
+ - [koenig_property]
+
+## Problems
+
+- [hyperclique_detection] / [hyperclique_hypothesis]
+
+See also: [generalized_hypertree_width], [conjunctive_query], [relational_instance], [simplicial_complex]
+
+Aliases: hypergraphs
diff --git a/hypergraph_conformal b/hypergraph_conformal
@@ -0,0 +1,7 @@
+# Hypergraph conformal
+
+Every [clique] of the [primal_graph] is contained in a hyperedge
+
+See also: [loomis_whitney], [hypergraph_chordal], [alpha_acyclic]
+
+Up: [hypergraph]
diff --git a/hypergraph_uniform b/hypergraph_uniform
@@ -0,0 +1,7 @@
+# Hypergraph uniform
+
+k-uniform [hypergraph]: all [hyperedge]s have size k
+
+- [graph_undirected] is k-uniform [hypergraph]
+
+Up: [hypergraph]
diff --git a/hypothesis b/hypothesis
@@ -0,0 +1,7 @@
+# Hypothesis
+
+- [computational_hypothesis]
+
+See also: [conjecture]
+
+Up: [mathematics]
diff --git a/ilango2022minimum b/ilango2022minimum
@@ -0,0 +1,5 @@
+# Illango2022minimum
+
+[academic_paper] about [minimum_formula_size_problem]
+
+Up: [academic_paper], [minimum_circuit_size_problem]
diff --git a/immerman_vardi_theorem b/immerman_vardi_theorem
@@ -0,0 +1,9 @@
+# Immerman vardi theorem
+
+https://en.wikipedia.org/wiki/Immerman-Vardi_theorem
+
+[datalog] with [negation] characterizes [ptime] on [ordered_structures]
+
+Up: [datalog]
+
+See also: [abiteboul_vianu_theorem]
diff --git a/implication_of_constraints b/implication_of_constraints
@@ -0,0 +1,5 @@
+# Implication of constraints
+
+- [dependency_implication]
+
+Up: [integrity_constraint], [implication]
diff --git a/incidence_graph b/incidence_graph
@@ -0,0 +1,10 @@
+# Incidence graph
+
+[graph_bipartite]:
+- left vertices are [variable]s
+- right vertices are [clause]s
+- edge connects variable to clause if variable occurs in clause
+
+Up: [graph_bipartite], [conjunctive_normal_form]
+
+See also: [primal_graph], [dual_graph], [incidence_treewidth]
diff --git a/incidence_treewidth b/incidence_treewidth
@@ -0,0 +1,13 @@
+# Incidence treewidth
+
+[treewidth] of [incidence_graph] of [conjunctive_normal_form] [boolean_formula]
+
+more general than [primal_treewidth], by [szeider2003fixed]
+- bounding [primal_treewidth] implies a bound on the [incidence_treewidth]
+ - specifically [incidence_treewidth] is \leq [primal_treewidth] + 1
+ - lemma 4 of [szeider2003fixed]
+- but not vice-versa
+
+Up: [conjunctive_normal_form]
+
+See also: [incidence_pathwidth]
diff --git a/inclusion_dependency_unary b/inclusion_dependency_unary
@@ -0,0 +1,9 @@
+# Inclusion dependency unary (UID)
+
+[inclusion_dependency] that are [frontier_one]
+
+Up: [inclusion_dependency]
+
+Aliases: UID, UIDs, unary ID, unary IDs, unary inclusion dependency
+
+See also: [functional_dependency_unary]
diff --git a/incomplete_data b/incomplete_data
@@ -0,0 +1,7 @@
+# Incomplete data
+
+[certain_answer]: cf [gheerbrant2023querying] / [gheerbrant2024querying]
+
+Up: [database_theory]
+
+See also: [amelie]
diff --git a/incremental_maintenance_pqe b/incremental_maintenance_pqe
@@ -0,0 +1,5 @@
+# Incremental maintenance PQE
+
+[berkholz2021probabilistic]
+
+Up: [query_evaluation_incremental], [pqe]
diff --git a/incremental_maintenance_tuple_testing b/incremental_maintenance_tuple_testing
@@ -0,0 +1,5 @@
+# Incremental maintenance tuple testing
+
+For sufficiently complicated problems, it is not possible in general to have [tuple_testing] in O(1) and [update] support in less than O(log n), via result on [marked_ancestor_problem]
+
+Up: [incremental_maintenance], [tuple_testing]
diff --git a/incremental_time b/incremental_time
@@ -0,0 +1,5 @@
+# Incremental time
+
+Discussed in [capelli2023geometric]
+
+See also: [enumeration]
diff --git a/independent_set b/independent_set
@@ -0,0 +1,32 @@
+# Independent set
+
+An independent set is a subset of vertices such that no two vertices of the subset are adjacent
+
+## Connections
+
+- An independent set is a [clique] of the [complement] of the graph
+- The [complementation] of an independent set is a [vertex_cover]
+ - and the [complementation] of a [maximum_independent_set] is a [minimum_vertex_cover]
+
+## Variants
+
+- [maximum_independent_set]: [np_hard] to find, mais [ptime] in [graph_bipartite] ([maximum_independent_set_bipartite])
+- [maximal_independent_set]: [ptime] to find with [greedy_algorithm]
+- [generalized_dominating_set]
+
+## [counting]
+
+- [sharp_bis] is the problem of counting independent sets on [graph_bipartite]
+ - it is open whether it admits an [fpras]
+- [dyer1999counting]: on general graphs there is no [fpras], cf [sharp_is]
+
+By [duality], counting independent sets exactly is the same as counting [vertex_cover] exactly
+
+## [linear_relaxation]
+
+[fractional_independent_set]
+- like [fractional_edge_cover] vs [edge_cover]
+
+See also: [matching], [vertex_cover]
+
+Up: [graph_substructure]
diff --git a/induced_subgraph b/induced_subgraph
@@ -0,0 +1,7 @@
+# Induced subgraph
+
+[subgraph] defined by taking a subset U of vertices and the edges between the vertices of U
+
+See also: [subgraph], [graph_minor], [induced_subhypergraph], [induced_cycle]
+
+Up: [graph]
diff --git a/infinity_deletion_breakable b/infinity_deletion_breakable
@@ -0,0 +1,13 @@
+# Infinity deletion breakable
+
+Discussed in [maehlman2024monadically] and at [stacs_2024_szymon]
+
+Like [deletion_breakable] but only for r=infinity
+
+Example: on [tree]: k=1, U(n) = n/3
+- for every set W there is a vertex which is a "balanced separator" of W, i.e., removing the vertex, each connected component contains at most 1/3rd of the vertices of W
+- [treewidth]: similar, separators of size t+1 for t the treewidth (still U(n) = n/3)
+
+A [graph_class] C is infinity deletion breakable iff C is [treelike]
+
+Up: [graph_class]
diff --git a/information_extraction_declarative b/information_extraction_declarative
@@ -0,0 +1,5 @@
+# Information extraction declarative
+
+- [spanner]
+
+Up: [information_extraction], [declarative]
diff --git a/integer_factorization_in_np_cap_conp b/integer_factorization_in_np_cap_conp
@@ -0,0 +1,9 @@
+# Integer factorization in NP cap coNP
+
+https://cs.stackexchange.com/questions/52722/why-is-factor-in-co-np
+
+[integer_factorization] in a certain sense (given m and k, does m have a divisor <k) is in [nptime] cap [conp]
+- [nptime] for the divisor
+- [conp] for the [prime_number_decomposition] which can be checked using the fact that [primality_testing] is in [ptime]
+
+Up: [np_cap_conp], [integer_factorization]
diff --git a/integer_linear_programming b/integer_linear_programming
@@ -0,0 +1,18 @@
+# Integer linear programming
+
+[NP_hard] [computational_problem]
+
+Notion of [linear_relaxation] to transform into a [linear_programming] [computational_problem]
+- but the solution of the linear program is usually not optimal for the original problem
+ - cf [integrality_gap]
+ - cf [relaxation]
+
+- [matrix_ilp]
+
+- [two_variable_per_equality] (TVPE) / [two_variable_per_inequality] (TVPI)
+
+Up: [computational_problem], [optimization]
+
+See also: [linear_relaxation]
+
+Aliases: ILP
diff --git a/integrity_constraint b/integrity_constraint
@@ -0,0 +1,11 @@
+# Integrity constraint
+
+- [database_dependency]
+ - [equality_generating_dependency]
+ - [functional_dependency]
+ - [tuple_generating_dependency]
+ - [inclusion_dependency]
+
+See also: [logic]
+
+Up: [databases]
diff --git a/interior_point b/interior_point
@@ -0,0 +1,9 @@
+# Interior point
+
+https://en.wikipedia.org/wiki/Interior-point_method
+
+- start in the center of [polytope] and iterate by taking a path between the center and the exterior
+ - reduce to [linear_system]
+ - uses [hessian]
+
+Up: [linear_programming]
diff --git a/intersection b/intersection
@@ -0,0 +1,8 @@
+# Intersection
+
+- [language_intersection]
+ - [automaton_intersection]
+- [set_intersection]
+- [sorted_list_intersection]
+
+Up: [boolean_operator]
diff --git a/intractability b/intractability
@@ -0,0 +1,10 @@
+# Intractability
+
+https://hardness.mit.edu/
+https://courses.csail.mit.edu/6.892/spring19/lectures/
+http://courses.csail.mit.edu/6.5440/fall23/
+
+- [hardness_of_approximation]
+- [np_complete]
+
+Up: [theoretical_computer_science]
diff --git a/johnsons_algorithm b/johnsons_algorithm
@@ -0,0 +1,21 @@
+# Johnson's algorithm
+
+https://en.wikipedia.org/wiki/Johnson%27s_algorithm
+
+- Uses [bellman_ford] for [single_source_shortest_path] on [super_source], gives
+ function h indicating the length of shortest path from super source to
+ each vertex
+ - abort if [negative_cycle]
+- Then reweigh the edges: edge (u, v) is given weight w(u, v) + h(u) - h(v)
+ - Note: this is >=0, indeed if it were <0 then we get h(u) + w(u, v) < h(v)
+ contradicting [triangle_inequality] or witnessing a [negative_cycle]
+- Then do [dijkstras_algorithm] with the new weights from every vertex
+ - Any path from s to t in the reweighted graph has weight that of the original
+ graph plus h(s)-h(t) ([telescoping_sum])
+ - So the shortest paths returned are correct, up to adjusting them with the
+ value h(s)-h(t)
+
+Time complexity O(n^2 log n + nm), so can be better than [floyd_warshall] for
+[graph_sparse]
+
+Up: [algorithm] for [all_pairs_shortest_path]
diff --git a/k_ambiguous b/k_ambiguous
@@ -0,0 +1,7 @@
+# K ambiguous
+
+like [unambiguity] for [NFA] but every word has at most k accepting runs
+
+Up: [unambiguity]
+
+See also: [degree_of_ambiguity_nfa], [degree_of_ambiguity_cfg]
diff --git a/k_relation b/k_relation
@@ -0,0 +1,12 @@
+# K-relation
+
+A [relation] where the [tuple]s are annotated by a value from a [semiring]
+
+Used in:
+
+- [hannula2024conditional] which uses [atserias2020consistency]
+- [atserias2023consistency]
+
+Up: [relation] with [semiring]
+
+See also: [database_instance]
diff --git a/kendall_tau_distance b/kendall_tau_distance
@@ -0,0 +1,5 @@
+# Kendall tau distance
+
+https://en.wikipedia.org/wiki/Kendall_rank_correlation_coefficient
+
+Up: [permutation_distance]
diff --git a/kleene_sequence b/kleene_sequence
@@ -0,0 +1,8 @@
+# Kleene sequence
+
+Successive applications of a [function] f from the minimal element
+(assumed to exist)
+- all elements are always <= all [fixpoints]
+- converges to [least_fixpoint]
+
+Up: [fixpoint], [sequence]
diff --git a/kleenes_algorithm b/kleenes_algorithm
@@ -0,0 +1,5 @@
+# Kleene's algorithm
+
+https://en.wikipedia.org/wiki/Kleene%27s_algorithm
+
+Up: [conversion_automata]
diff --git a/knowledge_compilation b/knowledge_compilation
@@ -0,0 +1,12 @@
+# Knowledge compilation
+
+Classes of [circuit] ensuring tractability
+
+- [knowledge_compilation_classes]
+- connections to [arithmetic_circuits]
+- [query_compilation]: knowledge compilation on the [provenance] of a query
+- [constraint_satisfaction_problem_knowledge_compilation]
+
+[circuit_bounds_vs_complexity_bounds]
+
+Up: [theoretical_computer_science]
diff --git a/knowledge_compilation_classes b/knowledge_compilation_classes
@@ -0,0 +1,27 @@
+# Knowledge compilation classes
+
+- [decomposable] [dnnf]
+- [sdnnf], with [structuredness]
+- [ddnnf], with [deterministic]
+ - exponentially separated from [dnnf]
+ - [sauerhoff_function]
+ - [ordered_dnnf], in [amarilli2017circuit]
+- [smoothing]
+- [sdd]
+ - exponentially separated from [obdd]
+ - [hidden_weighted_bit_function]
+- [decision_dnnf]
+ - [decision_sdnnf]
+ - [ordered_decision_circuit]
+- [diagram]
+ - [obdd]
+ - [nobdd]
+ - [uobdd]
+ - [fbdd]
+ - [zero_suppressed_semantics]
+
+Up: [knowledge_compilation], [circuit]
+
+See also: [circuit_classes], [circuit_condition]
+
+Aliases: knowledge compilation circuit classes
diff --git a/koenigs_theorem b/koenigs_theorem
@@ -0,0 +1,9 @@
+# König's theorem
+
+In a [graph_bipartite], the [maximum_matching] size and the [minimum_vertex_cover] size are the same.
+
+There is also a weighted version: Egerváry's theorem
+
+Generalization to [hypergraph] if they are [hypergraph_balanced]
+
+Up: [vertex_cover]
diff --git a/l_poly b/l_poly
@@ -0,0 +1,7 @@
+# L/poly
+
+https://en.wikipedia.org/wiki/L/poly
+
+Up: [complexity_class], [logspace], [advice]
+
+See also: [p_poly]
diff --git a/ladners_theorem b/ladners_theorem
@@ -0,0 +1,7 @@
+# Ladner's theorem
+
+If [ptime] \neq [nptime] then there is a problem in [nptime] [setminus] [ptime] which is not [np_complete]
+
+See also: [diagonal_argument], [np_complete], [np_intermediate]
+
+Up: [theorem] about [np_intermediate]
diff --git a/laminar_set_family b/laminar_set_family
@@ -0,0 +1,7 @@
+# Laminar set family
+
+From a set, partition it into disjoint subsets, and then recursively decompose these sets
+
+See also: [conjunctive_query_hierarchical]
+
+Up: [mathematics]
diff --git a/language_equivalence b/language_equivalence
@@ -0,0 +1,15 @@
+# Language equivalence
+
+test if two languages are the same
+
+- on [regular_languages]: [regular_language_equivalence]
+ - [pspace_complete]
+- on [context_free_languages]: [context_free_grammar_equivalence]
+ - [undecidability]
+- on [pattern_languages]: [pattern_language_equivalence]
+
+Up: [formal_language_computational_problem], [equivalence]
+
+See also: [query_equivalence], [language_inclusion], [regular_expression_equivalence], [automaton_equivalence]
+
+Aliases: language equivalent
diff --git a/language_inclusion b/language_inclusion
@@ -0,0 +1,7 @@
+# Language inclusion
+
+- [pattern_language_inclusion]
+
+Up: [formal_language_computational_problems], [inclusion]
+
+See also: [automaton_inclusion]
diff --git a/language_unary b/language_unary
@@ -0,0 +1,9 @@
+# Language unary
+
+language over [unary_alphabet]
+
+Up: [formal_language]
+
+Aliases: unary language
+
+See also: [density_function]
diff --git a/leaf b/leaf
@@ -0,0 +1,9 @@
+# Leaf
+
+[node] of a [tree] that has no [child]
+
+Up: [tree]
+
+See also: [internal_node]
+
+Aliases: leaves
diff --git a/leapfrog_triejoin b/leapfrog_triejoin
@@ -0,0 +1,3 @@
+# Leapfrog triejoin
+
+Up: [algorithm] for [optimal_joins]
diff --git a/learning_dfa b/learning_dfa
@@ -0,0 +1,17 @@
+# Learning DFA
+
+https://cs.stackexchange.com/questions/19687/smallest-dfa-that-accepts-given-strings-and-rejects-other-given-strings
+
+https://cstheory.stackexchange.com/a/1858/
+
+[gold1978complexity]: the following problem is [NP_hard]:
+ - given sets of strings P and N and number k
+ - decide if there exists a [DFA] with at most k [states] that accepts all strings in P and no string in N
+
+Also [angluin1978complexity]
+
+Also [lingg2024learning] on binary alphabets
+
+Up: [machine_learning], [automaton]
+
+Aliases: DFA learning
diff --git a/lemma b/lemma
@@ -0,0 +1,13 @@
+# Lemma
+
+A [result] in [mathematics], often intended to be used as a [tool]
+
+- [graph_removal_lemma]
+- [handshaking_lemma]
+- [Higman's_lemma]
+- [Lovasz_local_lemma]
+- [sparsification_lemma]
+- [Szemeredi_regularity_lemma]
+- [Tarsis_lemma]
+
+Up: [mathematics]
diff --git a/linear_algebra_program b/linear_algebra_program
@@ -0,0 +1,7 @@
+# Linear algebra program
+
+[brijder2019expressive]: MATLANG
+
+connections to [conjunctive_query] in [munozserrano2023enumeration]
+
+Up: [linear_programming], [query_language]
diff --git a/linear_programming b/linear_programming
@@ -0,0 +1,17 @@
+# Linear programming
+
+minimize c^t x st A^t x = b and x >= 0 pointwise
+- [dual] problem: [variable]s y dans R^d, cost b, we want to minimize b^t y
+ - and A y \geq c, defines a [polytope]
+ - so we want to find the point inside the polytope which minimizes the cost
+
+[algorithm]s (cf [aaron_sidford_talk]):
+- [simplex_algorithm], fast in practice but slow in memory
+- [ellipsoid], moderate in both
+- [interior_point] methods, it's the best in practice
+- can be approximated ("first order methods")
+- recent improvements
+
+Up: [optimization]
+
+See also: [integer_linear_programming], [linear_equation], [linear_relaxation], [farkas_lemma], [linear_algebra_program], [linear_system]
diff --git a/list b/list
@@ -0,0 +1,9 @@
+# List
+
+- [doubly_linked_list]
+- [element_distinctness_problem]
+- [sorted_list]
+
+Up: [data_structure]
+
+See also: [array]
diff --git a/locally_testable_language b/locally_testable_language
@@ -0,0 +1,18 @@
+# Locally testable language
+
+A [formal_language] is locally testable if it is k-testable for some k, where a k-testable language is one where membership depends only on the prefix and suffix of length k and the set of infixes of size k
+
+## Subclass
+
+- "strictly locally testable" in [caron2000families]: the locally testable languages are the Boolean combinations of strictly locally testable languages
+
+## Membership problem to the class
+
+Membership is decidable in [ptime] with algebraic characterization, cf [schutzenberger1965monoids], [caron2000families]
+
+## Generalizations
+
+- [locally_threshold_testable_language] where you can count infixes up to some threshold
+- mTT+MOD dans place2013separating, where you can further count [modulo] a certain value
+
+See also: [piecewise_testable_language], [local_language], [suffix_testable_language], [prefix_testable_language]
diff --git a/log_shaving b/log_shaving
@@ -0,0 +1,9 @@
+# Log shaving
+
+removing logs from [computational_complexity]
+
+Up: [computational_complexity]
+
+See also: [incremental_research]
+
+Aliases: shave
diff --git a/logarithm b/logarithm
@@ -0,0 +1,8 @@
+# Logarithm
+
+- [polylogarithmic]
+- [logarithm_iterated]
+
+Up: [mathematics]
+
+See also: [exponential], [logspace], [logarithmic]
diff --git a/logarithm_iterated b/logarithm_iterated
@@ -0,0 +1,7 @@
+# Logarithm iterated
+
+https://en.wikipedia.org/wiki/Iterated_logarithm
+
+Up: [logarithm]
+
+See also: [inverse_ackermann]
diff --git a/logcfl b/logcfl
@@ -0,0 +1,11 @@
+# LOGCFL
+
+Complexity class of problems with [logspace_reduction] to [membership_problem] of a [context_free_grammar]
+
+aka [nlogspace] with a [stack]
+
+Also: [logdcfl] for [deterministic_context_free_grammar]
+
+Up: [complexity_class]
+
+See also: [logcfl_complete]
diff --git a/logic b/logic
@@ -0,0 +1,70 @@
+# Logic
+
+## [logic_fragment]
+
+- [propositional_logic]
+ - [resolution]
+- [modal_logic]
+- [first_order_logic]
+ - [fok]
+ - [fo2]
+- [guarded_fragment]
+ - [gfk]
+ - [gf2]
+ - [gck]
+ - [gc2]
+- [c2]
+- [unary_negation]
+- [guarded_negation]
+- [monadic_second_order_logic]
+- [separator_logic]
+- [description_logics]
+
+## Problems
+
+- [satisfiability]
+- [model_checking]
+
+## Fields
+
+- [finite_model_theory]
+ - [finite_controllability]
+
+## Tools
+
+- [diagonal_argument]
+
+## Results
+
+- [goedels_incompleteness_theorem]
+- [zero_one_law]
+- [feferman_vaught_theorem] about [product]
+
+## Concepts
+
+- [locality]
+ - [first_order_locality]
+- [arity]
+ - [arity_two]
+- [craig_interpolation]
+- [ehrenfeucht_fraisse_game]
+- [fo_interpretation]
+- [quantifier_rank]
+- [conjunction]
+- [disjunction]
+- [implication]
+- [variable]
+- [negation]
+- [zero_one_law]
+- [craig_interpolation]
+- [beth_definability]
+- [logical_separability]
+- [monadic]
+- [logic_formula]
+- [quantifier]
+
+Up: [mathematics], [theoretical_computer_science]
+
+See also: [knowledge_representation], [reasoning], [logic_applications], [expressiveness]
+
+Aliases: logics
diff --git a/logical_separability b/logical_separability
@@ -0,0 +1,7 @@
+# Logical separability
+
+[levesque1998completeness]
+
+Up: [logic]
+
+See also: [craig_interpolation]
diff --git a/logspace b/logspace
@@ -0,0 +1,16 @@
+# L
+
+Class of problems that can be solved with logarithmic space [complexity_space]
+
+Is included in [PTIME]
+
+Variant [polyl]: solved with [polylogarithmic] [complexity_space]
+
+Variant [NL] ([nondeterminism])
+
+Variant [SL]: symmetric logspace, class of problems reducible to undirected [reachability], showed to be equal to [logspace] by [reingold]
+- for [2sat] corresponds to the case where exactly one literal in each clause must hold
+
+Up: [complexity_class]
+
+Aliases: L
diff --git a/logspace_reduction b/logspace_reduction
@@ -0,0 +1,7 @@
+# Logspace reduction
+
+[reduction] in [logspace]
+
+Can be used to show that problems are [nl_complete]
+
+Up: [reduction]
diff --git a/longest_common_substring b/longest_common_substring
@@ -0,0 +1,7 @@
+# Longest common substring
+
+linear time with [suffix_tree]
+
+Up: [stringology], [subword]
+
+See also: [longest_common_subsequence]
diff --git a/longest_increasing_subsequence b/longest_increasing_subsequence
@@ -0,0 +1,7 @@
+# Longest increasing subsequence
+
+https://en.wikipedia.org/wiki/Longest_increasing_subsequence
+
+Up: [subsequence]
+
+See also: [longest_common_subsequence]
diff --git a/longest_parameterized_common_subsequence b/longest_parameterized_common_subsequence
@@ -0,0 +1,7 @@
+# Longest parameterized common subsequence
+
+[longest_common_subsequence] with [parameter]s of various kinds, cf [iliopoulos2007algorithms] for instance
+
+apparently also under [alphabet_bijection], cf [parameterized_matching], in [keller2009longest]
+
+Up: [longest_common_subsequence]
diff --git a/lovasz_conjecture b/lovasz_conjecture
@@ -0,0 +1,11 @@
+# Lovasz conjecture
+
+https://en.m.wikipedia.org/wiki/Lov%C3%A1sz_conjecture
+
+every finite [connected_graph] which is [vertex_transitive] has a [hamiltonian_path]
+
+for the stronger conjecture with [hamiltonian_cycle], 5 known counterexamples
+
+weaker conjecture about [cayley_graph] for [hamiltonian_cycle]
+
+Up: [conjecture]
diff --git a/lower_bounds b/lower_bounds
@@ -0,0 +1,14 @@
+# Lower bounds
+
+Class at [mit] http://courses.csail.mit.edu/6.5440/fall23/
+
+videos and well-down course notes https://courses.csail.mit.edu/6.892/spring19/lectures/
+
+Work in progress [book] "Computational Intractability: A Guide to Algorithmic Lower Bounds" https://hardness.mit.edu/
+- not intended to be [open_access] apparently
+
+Up: [computational_complexity]
+
+See also: [theorem]
+
+Aliases: lower bound
diff --git a/machine_model b/machine_model
@@ -0,0 +1,7 @@
+# Machine model
+
+- [memory_model_external]
+- [ram_model]
+- [cell_probe_model]
+
+Up: [theoretical_computer_science]
diff --git a/makowsky2003tree b/makowsky2003tree
@@ -0,0 +1,5 @@
+# Makowsky2003tree
+
+Proposition 32 shows that there are graphs with high [treewidth], even [subdivision] of [grid_graph], on which [monadic_second_order_logic] evaluation is in [ptime]
+
+Up: [grid_graph]
diff --git a/many_one_reduction b/many_one_reduction
@@ -0,0 +1,11 @@
+# Many-one reduction
+
+[reduction] that transforms an instance of A into an instance of B and answer in the same way
+
+Called "Karp reduction" when it is [ptime_reduction]
+
+- restriction "one-one" when the reduction function is injective ; aussi notion "recursively isomorphic"
+
+Up: [reduction]
+
+See also: [turing_reduction], [weihrauch_reduction]
diff --git a/markovs_inequality b/markovs_inequality
@@ -0,0 +1,9 @@
+# Markov's inequality
+
+https://en.wikipedia.org/wiki/Markov%27s_inequality
+
+For a nonnegative random variable X, the probability that it is at least a>0 is no greater than E[X]/a.
+
+Indeed, when X geq a it contributes at least a to the expectation, and otherwise it contributes at least zero.
+
+Up: [concentration_inequality]
diff --git a/martens2018evaluation b/martens2018evaluation
@@ -0,0 +1,7 @@
+# Martens2018evaluation
+
+introduced [simple_transitive_expressions]
+
+See also: [bonifati2017analytical]
+
+Up: [academic_paper] about [RPQs]
diff --git a/matching b/matching
@@ -0,0 +1,22 @@
+# Matching
+
+Structure in [graph] et [graph_bipartite]: a subset of edges where no two edges share a vertex
+
+- [maximum_matching]
+- [exact_matching]
+- [perfect_matching]
+
+Problems:
+
+- [matching_counting]
+- [maximum_matching_counting]
+
+Algorithms [graph_algorithm]:
+
+- [hungarian_algorithm]
+
+Also the [linear_relaxation]: see [fractional_edge_packing]
+
+See also: [independent_set], [induced_matching], [graph_matching_covered], [deficiency]
+
+Up: [graph_substructure]
diff --git a/matching_width b/matching_width
@@ -0,0 +1,8 @@
+# Matching width
+
+introduced in [razgon2017oblivious], variant of [mm_width]
+
+linearly related to [pathwidth]:
+ - [razgon2017oblivious] shows pw(G)/2 <= mw(G) <= pw(G)+1
+
+Up: [width_measure]
diff --git a/mathematical_foundations_of_automata_theory b/mathematical_foundations_of_automata_theory
@@ -0,0 +1,6 @@
+# Mathematical foundations of automata theory
+
+https://www.irif.fr/~jep/PDF/MPRI/MPRI.pdf
+[course_notes] by [jean_eric_pin]
+
+Up: [course_notes]
diff --git a/mathematics b/mathematics
@@ -0,0 +1,85 @@
+# Maths
+
+## Basic concepts
+
+- [set]
+ - [semilinear_set]
+- [partition]
+ - [equivalence_relation]
+- [order]
+ - [partial_order]
+ - [inequality_mathematics]
+- [algebraic_structure]
+ - [monoid]
+ - [semigroup]
+ - [group]
+ - [semiring]
+ - [ring]
+ - [field]
+ - [homomorphism]
+- [distance]
+- [vector]
+- [number]
+- [formal_series]
+- [polynomial]
+- [lattice]
+- [logarithm]
+- [matrix]
+- [function]
+- [equation]
+ - [equation_system]
+- [sequence]
+- [cartesian_product]
+- [plane_mathematics]
+- [modulo]
+
+## Notions
+
+- [canonicity]
+- [paradox]
+- [transitivity]
+- [idempotent]
+- [dual]
+- [finite]
+- [infinite]
+- [cardinal]
+- [fourier_transform]
+
+## Fields
+
+[mathematics_fields]
+
+## Problems
+
+- [warings_problem]
+- [kissing_number_problem]
+- [moving_sofa_problem]
+- [tiling], cf https://en.m.wikipedia.org/wiki/Heesch%27s_problem
+
+## [theorem]
+
+- [wiles_theorem]
+- [inclusion_exclusion]
+
+## Operations
+
+- [addition]
+- [multiplication]
+- [exponentiation]
+- [tetration]
+- [ackermanns_function]
+
+## [mathematics_meta_terms]
+
+- [open_problem]
+- [theorem]
+- [result]
+- [conjecture]
+- [definition]
+- [lemma]
+
+Up: [formal_science]
+
+See also: [mathematics_meta], [mathematics_technique]
+
+Aliases: mathematical
diff --git a/mathematics_fields b/mathematics_fields
@@ -0,0 +1,20 @@
+# Mathematics fields
+
+classification [msc]
+
+- [topology]
+- [probabilities]
+- [number_theory]
+- [algebra]
+- [analysis]
+- [geometry]
+- [game_theory]
+- [computer_algebra]
+- [combinatorics]
+- [logic]
+- [arithmetic]
+- [randomness]
+- [fourier_analysis]
+- [discrete_mathematics]
+
+Up: [mathematics]
diff --git a/mathematics_operation b/mathematics_operation
@@ -0,0 +1,9 @@
+# Mathematics operation
+
+- [addition]
+- [multiplication]
+- [exponentiation]
+- [tetration]
+- [ackermanns_function]
+
+Up: [mathematics]
diff --git a/matrix b/matrix
@@ -0,0 +1,37 @@
+# Matrix
+
+## Types
+
+- [matrix_square]
+- [matrix_zero]
+- [matrix_boolean]
+- [matrix_identity]
+- [matrix_permutation]
+- [matrix_diagonal]
+- [matrix_triangular]
+- [matrix_invertible]
+- [matrix_vandermonde]
+- [matrix_toeplitz]
+- [matrix_stochastic]
+- [unimodular] matrix: [matrix_square] with [determinant] +1 or -1
+ - equivalently [matrix_invertible] over the integers
+ - [totally_unimodular]: matrix (not necessarily square) where every [matrix_square] [submatrix] (deleting rows and columns) has [determinant] 0 or 1 or -1
+- [strongly_unimodular] matrix
+- [pet_matrix] https://cstheory.stackexchange.com/a/53156 [fertin2015obtaining]
+
+## Operations
+
+- [kronecker_product]
+- [matrix_product]
+
+## Values
+
+- [matrix_rank]
+- [determinant] and [permanent]
+
+## [computational_problem]
+
+- [matrix_multiplication]
+- [matrix_mortality]
+
+Up: [mathematics]
diff --git a/matrix_boolean b/matrix_boolean
@@ -0,0 +1,7 @@
+# Matrix boolean
+
+[matrix] with values 0 and 1
+
+[matrix_multiplication] can then be defined in [boolean_semiring]
+
+Up: [matrix], [boolean]
diff --git a/matrix_ilp b/matrix_ilp
@@ -0,0 +1,12 @@
+# Matrix ILP
+
+An [integer_linear_programming] [computational_problem] associated to a [matrix]
+- i.e., optimize cx subject to Ax \geq b, for A a matrix
+
+Cf [strongly_unimodular] and [totally_unimodular]
+
+Discussed in [crama1986strong], see also [hypergraph_signed]
+
+Up: [integer_linear_programming]
+
+See also: [hypergraph_unimodular]
diff --git a/matrix_square b/matrix_square
@@ -0,0 +1,5 @@
+# Matrix square
+
+[matrix] which has as many rows as columns
+
+Up: [matrix]
diff --git a/matrix_toeplitz b/matrix_toeplitz
@@ -0,0 +1,9 @@
+# Matrix toeplitz
+
+https://en.wikipedia.org/wiki/Toeplitz_matrix
+
+"diagonal-constant matrix"
+
+[Toeplitz_graph]
+
+Up: [matrix]
diff --git a/max_sat b/max_sat
@@ -0,0 +1,14 @@
+# MaxSAT
+
+https://en.wikipedia.org/wiki/Maximum_satisfiability_problem
+
+Find the maximum number of clauses of a [conjunctive_normal_form] formula that
+can be made true
+
+Also exists in a weighted version
+
+Special case: [max_2sat]
+
+Up: [sat_variants]
+
+See also: [satisfiability_weighted]
diff --git a/maximal_common_subsequence b/maximal_common_subsequence
@@ -0,0 +1,13 @@
+# Maximal common subsequence (MCS)
+
+[maximal_common_subsequence] (MCS): common subsequence cannot be extended (inclusion in terms of [substring])
+- formally: it is a common sequence and no supersequence is a common sequence
+- [longest_common_subsequence] is MCS but not necessarily vice-versa
+- [PTIME] to compute MCS for an unbounded number of multiple input strings: [hirota2023fast]
+
+- warning! you can compute greedily a common sequence between 2 strings by extending it to the right
+ - but it is not necessarily an MCS, it may still be possible to extend it by an insertion
+
+Up: [common_subsequence]
+
+See also: [longest_common_subsequence]
diff --git a/maximal_independent_set_counting b/maximal_independent_set_counting
@@ -0,0 +1,7 @@
+# Maximal independent set counting
+
+tractable for [cograph] (P4-free [graph])
+- cf [corneil1981complement]
+- mentioned in [livshits2021counting]
+
+Up: [counting_problem], [maximal_independent_set]
diff --git a/maximum_a_posteriori b/maximum_a_posteriori
@@ -0,0 +1,5 @@
+# MAP
+
+On [ddnnf], tractable : upwards then downwards
+
+See also: [message_passing], [marginal_maximum_a_posteriori]
diff --git a/maximum_cut b/maximum_cut
@@ -0,0 +1,11 @@
+# Maximum cut
+
+https://en.wikipedia.org/wiki/Maximum_cut
+
+[np_complete]
+
+[ptime] on [planar_graph] in connection with [chinese_postman_problem]
+
+See also: [minimum_cut]
+
+Up: [computational_problem] on [graph]
diff --git a/maximum_independent_set_bipartite b/maximum_independent_set_bipartite
@@ -0,0 +1,8 @@
+# Maximum independent set bipartite
+
+finding [maximum_independent_set] in [graph_bipartite]
+
+- complement of a [maximum_independent_set] is [minimum_vertex_cover]
+- and then problem can be solved by [minimum_vertex_cover_bipartite]
+
+Up: [maximum_independent_set], [graph_bipartite]
diff --git a/maximum_matching b/maximum_matching
@@ -0,0 +1,12 @@
+# Maximum matching
+
+Particular case: [perfect_matching].
+
+- Problem: [maximum_matching_problem]
+- Counting: [maximum_matching_counting]
+
+Also [online_algorithm] for maximum matching
+
+Up: [computational_problem] on [matching]
+
+See also: [alternating_path]
diff --git a/membership_problem b/membership_problem
@@ -0,0 +1,10 @@
+# Membership problem
+
+given [formal_language] L description and [word] w, test if w belongs to L
+
+- [regular_language_membership]
+- [context_free_language_membership]
+
+- [radoszewski2021hardness] for hardness under [3SUM_conjecture] of testing membership of a string to some [formal_languages]
+
+Up: [formal_language_computational_problem]
diff --git a/mengers_theorem b/mengers_theorem
@@ -0,0 +1,7 @@
+# Menger's theorem
+
+https://en.wikipedia.org/wiki/Menger's_theorem
+
+[theorem] on [disjoint_paths] in [graph]
+
+Up: [theorem] on [graph]
diff --git a/mim_width b/mim_width
@@ -0,0 +1,11 @@
+# Mim width
+
+defined in [vatshelle2012new]
+
+via [induced_matching]
+
+linear version [lmim_width], like [pathwidth] is to [treewidth], cf [golovach2017output]
+
+variant [sim_width]
+
+Up: [width_measure]
diff --git a/minimal_absent_word b/minimal_absent_word
@@ -0,0 +1,14 @@
+# Minimal absent word (MAW)
+
+minimal word which is not a [factor] of a [word] but every shorter word is
+
+given a word, there is a linear number of minimal absent words
+
+- [directed_acyclic_word_graph] (DAWG)
+ representing all [factors] of the word
+ - [fujishige2023linear]
+ - compact DAWG (CDAWG), keep only branching nodes + path compression
+
+variant [minimal_rare_word] with a threshold on the number of occurrences
+
+Up: [stringology]
diff --git a/minimal_unsatisfiable b/minimal_unsatisfiable
@@ -0,0 +1,12 @@
+# Minimal unsatisfiable
+
+[conjunctive_normal_form] [boolean_formula] which is unsatisfiable but every strict clause subset is satisfiable
+
+[dp_complete] to identify
+- cf [minimum_unsatisfiable_core]
+
+Relevant result: [tarsis_lemma]
+
+Up: [satisfiability_boolean]
+
+See also: [extremal_combinatorics]
diff --git a/minimal_witness b/minimal_witness
@@ -0,0 +1,14 @@
+# Minimal witness
+
+Find the smallest subset of a [relational_database] that satisfies a [query]
+- formally, for query Q and database D, find smallest subset D' of D giving the same result
+- [approximation]: find a subset of tuples giving the same results which is within a [approximation_multiplicative] factor of the size of the optimal subset
+
+easy for [conjunctive_query_full], so hardness comes from [projection]
+
+- [miao2019explaining], with [ptime] algorithm for a specific tuple
+- [hu2023finding], [best_paper_award] at [icdt_2024]
+
+Up: [database_theory]
+
+See also: [query_resilience]
diff --git a/minimization b/minimization
@@ -0,0 +1,7 @@
+# Minimization
+
+- [minimization_conjunctive_query], cf [homomorphism] / [core]
+- [minimization_automaton]
+ - [automaton_minimal]
+
+Up: [theoretical_computer_science]
diff --git a/minimization_automaton b/minimization_automaton
@@ -0,0 +1,10 @@
+# Minimization automaton
+
+- [brzozowskis_algorithm]
+ - https://fr.wikipedia.org/wiki/Algorithme_de_Brzozowski_de_minimisation_d%27un_automate_fini
+- [hopcrofts_algorithm]
+- [moores_algorithm]
+
+Up: [minimization]
+
+Aliases: minimization of automata, automata minimization, automaton minimization, minimization automata
diff --git a/minimum_circuit_size_problem b/minimum_circuit_size_problem
@@ -0,0 +1,11 @@
+# Minimum circuit size problem (MCSP)
+
+Given the truth table of a [boolean_formula] and an integer s, decide if there is a [boolean_circuit] of size s computing the formula
+
+Clearly in [nptime] and not known to be [np_hard], cf [ilango2022minimum]
+
+[minimum_circuit_size_problem_arithmetic_circuit]
+
+See also: [minimum_formula_size_problem], [addition_chain]
+
+Up: [minimization] of [boolean_circuit]
diff --git a/minimum_degree_spanning_tree b/minimum_degree_spanning_tree
@@ -0,0 +1,7 @@
+# Minimum degree spanning tree
+
+https://en.wikipedia.org/wiki/Minimum_degree_spanning_tree
+
+Up: [spanning_tree]
+
+See also: [degree]
diff --git a/minimum_feedback_vertex_set b/minimum_feedback_vertex_set
@@ -0,0 +1,12 @@
+# Minimum feedback vertex set
+
+[computational_problem] of finding minimum-[cardinality] [feedback_vertex_set]
+
+[np_complete]
+- already on [graph_directed] with maximal [indegree] 2 and maximal [outdegree] 2
+ - and on [directed_planar_graph] with maximal [indegree] 3 and maximal [outdegree] 3
+- and on [undirected_graphs] with [maximal_degree] 4
+ - [ptime] on graphs with maximal degree 3
+ - reduction to [matroid] parity?
+
+Up: [computational_problem], [feedback_vertex_set]
diff --git a/minimum_spanning_tree b/minimum_spanning_tree
@@ -0,0 +1,7 @@
+# Minimum spanning tree
+
+- [minimum_spanning_tree_dynamic]
+- [prims_algorithm]
+- [kruskals_algorithm]
+
+Up: [spanning_tree]
diff --git a/minimum_vertex_cover_bipartite b/minimum_vertex_cover_bipartite
@@ -0,0 +1,9 @@
+# Minimum vertex cover bipartite
+
+finding [minimum_vertex_cover] in [graph_bipartite]
+
+Algorithm: We use [koenigs_theorem] to say it is equivalent to finding a [maximum_matching]
+
+See also: [maximum_independent_set_bipartite]
+
+Up: [minimum_vertex_cover], [graph_bipartite]
diff --git a/mixed_chinese_postman_problem b/mixed_chinese_postman_problem
@@ -0,0 +1,7 @@
+# Mixed chinese postman problem
+
+https://en.wikipedia.org/wiki/Mixed_Chinese_postman_problem
+
+[np_complete]
+
+Up: [chinese_postman_problem] on [graph_mixed]
diff --git a/monadic b/monadic
@@ -0,0 +1,10 @@
+# Monadic
+
+Having [arity] of 1.
+
+- [monadic_second_order_logic]
+- [datalog_monadic]
+
+Up: [logic]
+
+See also: [monad]
diff --git a/monadic_second_order_logic_model_checking b/monadic_second_order_logic_model_checking
@@ -0,0 +1,7 @@
+# Monadic second order logic model checking
+
+- [courcelle_theorem]
+
+Up: [model_checking] for [monadic_second_order_logic]
+
+See also: [first_order_model_checking]
diff --git a/montgomery2020proof b/montgomery2020proof
@@ -0,0 +1,5 @@
+# montgomery2020proof
+
+https://arxiv.org/abs/2001.02665
+
+Up: [academic_paper] on [ringels_conjecture]
diff --git a/moore_graph b/moore_graph
@@ -0,0 +1,18 @@
+# Moore graph
+
+https://en.wikipedia.org/wiki/Moore_graph
+
+Connect as many [vertex] as possible while limiting [graph_diameter] and [graph_degree]
+
+A Moore graph is a [graph] satisfying the Moore bound on [degree] and
+[diameter] (cf also [girth]):
+ - the bound is the obvious one where summing the number of vertices reachable at the indicated distance
+ - [open_problems]: open for [degree] 57 whether a Moore graph exists
+
+[miller2013moore] and also mentioned in [cranston2023coloring]
+
+Records: https://en.wikipedia.org/wiki/Table_of_the_largest_known_graphs_of_a_given_diameter_and_maximal_degree
+
+Up: [graph]
+
+See also: [extremal_graph_theory]
diff --git a/moores_algorithm b/moores_algorithm
@@ -0,0 +1,9 @@
+# Moore's algorithm
+
+https://fr.wikipedia.org/wiki/Algorithme_de_Moore_de_minimisation_d%27un_automate_fini
+
+Constructs [myhill_nerode_equivalence] by successive refinement from the partition of states into [final_states] and [nonfinal_states]
+
+Up: [minimization_automaton]
+
+See also: [hopcrofts_algorithm]
diff --git a/morphism b/morphism
@@ -0,0 +1,10 @@
+# Morphism
+
+on [word]s
+
+- [non_erasing_morphism]
+- [length_preserving_morphism]
+
+Up: [mathematics]
+
+See also: [homomorphism]
diff --git a/mpe b/mpe
@@ -0,0 +1,11 @@
+# Most Probable Explanation (MPE)
+
+find [satisfying_valuation] with largest weight for a [boolean_function]
+
+- for [monotone2cnf]: [np_hard] by reduction from [minimum_vertex_cover]
+- for [horn_clause]: [np_hard] by padding previous argument
+- for [2horn_clause] (no two literals of same polarity per clause = "definite horn with size at most two), [ptime] by reduction to [project_selection_problem]
+
+Up: [satisfiability_boolean]
+
+See also: [sharp_satisfiability]
diff --git a/multigraph b/multigraph
@@ -0,0 +1,10 @@
+# Multigraph
+
+A [graph] where the same [edge] can exist multiple times.
+
+Can also be seen as a [weighted_graph] where edges carry a nonzero integer weight
+
+- [multigraph_directed]
+- [multigraph_undirected]
+
+Up: [graph]
diff --git a/multitree b/multitree
@@ -0,0 +1,13 @@
+# Multitree
+
+https://en.wikipedia.org/wiki/Multitree
+
+[Directed_acyclic_graph] without a [diamond]
+
+A multitree is not necessarily a [polytree], but a [polytree] is a multitree.
+
+Up: [tree]
+
+See also: [polytree]
+
+Aliases: multitrees
diff --git a/naturally_ordered_semiring b/naturally_ordered_semiring
@@ -0,0 +1,5 @@
+# Naturally ordered semiring
+
+[semiring] with [natural_order]
+
+Up: [natural_order], [semiring]
diff --git a/nbdd b/nbdd
@@ -0,0 +1,9 @@
+# Nbdd
+
+[bdd] which is [nondeterministic]
+
+- [nfbdd]
+
+Up: [bdd]
+
+Aliases: nBDDs
diff --git a/nbp b/nbp
@@ -0,0 +1,11 @@
+# Nondeterministic branching program (NBP)
+
+Like [nrobp] but without the "free" aspect (cf [fbdd]).
+
+Other name: nFBDD
+
+It is shown in meinel1989nondeterministic to be as powerful as [nptime] and so
+we can translate [circuit] to NBPs in [ptime]
+- the key argument is to use the [tseitsin_transform]
+
+Up: [diagram]
diff --git a/nc b/nc
@@ -0,0 +1,18 @@
+# NC
+
+"Nick's class"
+
+understood as meaning that a problem is efficiently parallelizable [parallelization]
+
+NCi: class of [formal_language] accepted by uniform [boolean_circuit] with polynomial number of gates, maximum [fan_in] 2, and depth O(log^i n)
+
+It is not known whether the NC hierarchy is proper: if it is not, then it leads to a collapse
+
+- [barringtons_theorem]: the class BWBP of [regular_language] on {0, 1} that can be recognized with branching programs of polynomial length and bounded width is exactly "nonuniform [nc1]"
+
+It is assumed but unknown that [nc] neq [ptime]
+
+- [nc0]
+- [nc1]
+
+Up: [ac]
diff --git a/nc1 b/nc1
@@ -0,0 +1,13 @@
+# NC1
+
+https://en.wikipedia.org/wiki/NC_(complexity)
+
+circuits with [polynomial] [circuit_size] and [polylogarithmic] [depth]
+
+NC1 circuits equivalent to polynomial-size uniform family of [formula_boolean]
+
+https://en.wikipedia.org/wiki/NL_(complexity) says we have:
+
+[nc1] included in [logtime] included in [nlogtime] included in [nc2]
+
+Up: [nc], [circuit_complexity]
diff --git a/network_reliability b/network_reliability
@@ -0,0 +1,8 @@
+# Network reliability
+
+- [st_reliability]
+- [network_reliability_fpras]
+
+Up: [graph]
+
+See also: [pqe], [reliability_database]
diff --git a/neural_network_compression b/neural_network_compression
@@ -0,0 +1,7 @@
+# Neural network compression
+
+https://bellard.org/nncp/ by [fabrice_bellard]
+
+Up: [compression_algorithm] using [neural_network]
+
+See also: [rnn_compression]
diff --git a/nfbdd b/nfbdd
@@ -0,0 +1,13 @@
+# nFBDD
+
+[fbdd] which is [nondeterministic]
+
+special case: [nobdd]
+
+problem: [sharp_nfbdd]
+
+equivalent to [nrobp]
+
+can do [quasipolynomial] simulation of [dnnf]: [dnnf_to_nfbdd]
+
+Up: [nbdd]
diff --git a/nlogspace b/nlogspace
@@ -0,0 +1,20 @@
+# NL
+
+[complexity_class] of [decision_problem] that can be solved by [nondeterministic] [turing_machine] with [logarithm] amount of memory
+
+Like [logspace] with [nondeterministic]
+
+Complete problems:
+
+- directed [reachability]
+- [2sat]
+
+Known to be equal to [co-NL]: the Immerman–Szelepcsényi theorem [immerman_szelepcsenyi_theorem]
+
+[descriptive_complexity]: corresponds to [fotc] = [first_order_logic] with [transitive_closure] operator
+
+Up: [complexity_class]
+
+See also: [nl_complete]
+
+Aliases: NL
diff --git a/no_meet b/no_meet
@@ -0,0 +1,5 @@
+# No meet
+
+[walks] in a [graph_directed] that avoid each other, cf [benameur2024nomeet]
+
+Up: [walk]
diff --git a/nondeterministic b/nondeterministic
@@ -0,0 +1,12 @@
+# Nondeterministic
+
+- [automata]
+- [tree_automaton]
+- [turing_machine]
+- [degree_of_ambiguity]
+
+See also: [randomness], [alternation], [nptime]
+
+Up: [theoretical_computer_science]
+
+Aliases: nondeterminism
diff --git a/normal_subgroup b/normal_subgroup
@@ -0,0 +1,11 @@
+# Normal subgroup
+
+A [subgroup] N of a [group] G is *normal* if g n g^{-1} in N for every n in N and g in G
+
+- a bit like [ideal] but [ideal] does not make sense in a group in which you have [inverse]
+
+Can be used to build [quotient_group] by a [congruence_relation]: the equivalence class of the [identity_element] is a normal subgroup, and the other equivalence classes are [coset] of that subgroup
+
+When the group is [abelian_group], all subgroups are normal
+
+Up: [finite_simple_group]
diff --git a/np_cap_conp b/np_cap_conp
@@ -0,0 +1,10 @@
+# NP cap coNP
+
+[integer_factorization_in_np_cap_conp]
+
+https://cs.stackexchange.com/questions/41476/what-do-we-know-about-np-cap-co-np
+https://cs.stackexchange.com/questions/38248/what-do-we-know-about-np-%e2%88%a9-co-np-and-its-relation-to-npi
+
+Up: [complexity_class]
+
+See also: [nptime], [conp], [word_automaton_self_verifying]
diff --git a/np_complete b/np_complete
@@ -0,0 +1,30 @@
+# NP-complete
+
+https://en.wikipedia.org/wiki/NP-completeness
+
+Problem which is in [nptime] and [np_hard]
+
+- problems:
+ - [3_partition]
+ - [bin_packing]
+ - [3_dimensional_matching]
+ - [knapsack]
+ - [subset_sum] mais [pseudo_polynomial_time] algorithm
+ - [hitting_set]
+ - https://en.wikipedia.org/wiki/List_of_NP-complete_problems
+ - [garey_johnson]
+ - 1972: the first 21 NP-complete problems of Karp
+ - [minimum_vertex_cover]
+ - [maximum_independent_set]
+
+weakly NP-complete ou [strongly_np_complete] depending on whether there exist
+[pseudo_polynomial_time] algorithms
+
+different notions of [reduction]?
+- it is open whether [np_complete] problems under [logspace_reduction] and [ptime_reduction] are different, cf https://en.wikipedia.org/wiki/Log-space_reduction
+
+Up: [complete] for [nptime]
+
+See also: [intractability], [np_hard], [conp_complete]
+
+Aliases: NP-completeness, NP_completeness
diff --git a/np_hard b/np_hard
@@ -0,0 +1,12 @@
+# NP-hard
+
+at least as hard as the hardest [computational_problem]s in [nptime]
+- admits a [ptime_reduction] from any [nptime] problem
+- subtlety about which type of reduction is allowed, e.g., [many_one_reduction] vs [turing_reduction]
+ - usual notion is [many_one_reduction]
+ - with [turing_reduction], the difference between [np] and [conp] disappears
+ - https://cstheory.stackexchange.com/questions/138/many-one-reductions-vs-turing-reductions-to-define-npc
+
+See also: [nptime], [computational_hardness]
+
+Up: [computational_complexity]
diff --git a/np_intermediate b/np_intermediate
@@ -0,0 +1,10 @@
+# NP-intermediate
+
+Problems in [nptime] not thought likely to be [np_complete]
+
+- [integer_factoring]
+- [graph_isomorphism_problem]
+
+Up: [complexity_class]
+
+See also: [qp]
diff --git a/nptime b/nptime
@@ -0,0 +1,17 @@
+# NP
+
+definition:
+- via [nondeterministic] [ptime] [turing_machine]
+- via [witness]
+
+- "Berman-Hartmanis conjecture": all NP languages can be related by PTIME-computable isomorphisms
+
+subset [snp]
+
+subset [up]
+
+[npo] for [optimization_problem]
+
+Up: [complexity_class]
+
+See also: [ptime], [np_complete], [np_hard], [np_cap_conp], [conp], [nondeterministic_PTIME_Turing_machine]
diff --git a/nrobp b/nrobp
@@ -0,0 +1,13 @@
+# NROBP
+
+An [fbdd] with [nondeterministic], cf [razgon2015read]
+
+Variant with [nondeterministic] only at the [root] : [savicky2005hierarchy]
+
+Equivalent to [nfbdd].
+
+Generalization: [read_k_branching_program]
+
+See also: [nbp], [read_once]
+
+Up: [diagram]
diff --git a/number b/number
@@ -0,0 +1,12 @@
+# Number
+
+- [natural_number]
+ - [diophantine_equation]
+ - [sum_of_powers]
+- [rational_number]
+- [real_number]
+- [complex_number]
+- [gcd]
+ - [euclidean_algorithm]
+
+Up: [mathematics]
diff --git a/number_theory b/number_theory
@@ -0,0 +1,14 @@
+# Number theory
+
+Open problems:
+
+- Infinite number of [mersenne_prime] / odd [perfect_number]?
+- existence of an even [perfect_number]?
+- [goldbach_conjecture]
+ - [ternary_goldbach_problem]
+- [twin_prime_conjecture]
+- [chens_theorem]
+
+See also: [prime_number], [arithmetic]
+
+Up: [mathematics]
diff --git a/obdd b/obdd
@@ -0,0 +1,12 @@
+# OBDD
+
+A [deterministic] [bdd] with a [variable_order]
+
+- [uobdd]
+- [nobdd]
+
+[synthesis]: we can take [conjunction] and [disjunction] of two OBDDs where the [variable_order] is the same
+
+Up: [bdd]
+
+See also: [fbdd]
diff --git a/oberwolfach_problem b/oberwolfach_problem
@@ -0,0 +1,9 @@
+# Oberwolfach problem
+
+https://en.m.wikipedia.org/wiki/Oberwolfach_problem
+
+- seating people at circular tables so that everyone occurs as a neighbouring pair exactly once
+
+Up: [combinatorics]
+
+See also: [oberwolfach]
diff --git a/omqa b/omqa
@@ -0,0 +1,13 @@
+# Ontology-Mediated Query Answering (OMQA)
+
+definition:
+- given an [instance] I and [query] Q and [logical_constraint]s Sigma
+- does every [superinstance] of I satisfying Sigma also satisfy Q?
+
+subtlety: [omqa_finite] vs [omqa_unrestricted]
+
+OMQA and [counting]: [bienvenu2022complexity]
+
+Up: [database_theory]
+
+See also: [description_logics]
diff --git a/open_world_query_answering b/open_world_query_answering
@@ -0,0 +1,20 @@
+# Open world query answering
+
+Given a [database], [database_dependency] or [ontology], and [query], check if
+it implied
+
+Also called "ontology-based data access", see also [ontology_mediated_query]
+
+- [query_rewriting]
+- [chase]
+- [combined_complexity] approaches, for instance [gottlob2023polynomial]
+
+By [constraint_language]:
+
+- [open_world_query_answering_fds]
+
+- [open_world_query_answering_rpqs]
+
+See also: [query_evaluation], [satisfiability], [open_world_semantics]
+
+Up: [database_theory]
diff --git a/open_world_query_answering_fds b/open_world_query_answering_fds
@@ -0,0 +1,11 @@
+# Open world query answering fds
+
+with [FDs]
+
+- [owqa_frontier_one_fds]
+
+- [non_conflicting_condition]
+ - in particular ensures that the [chase] by the [UIDs] will not violate the [FDs]
+ - so it suffices to check the [FDs] on the [base_instance]
+
+Up: [open_world_query_answering]
diff --git a/optimization b/optimization
@@ -0,0 +1,14 @@
+# Optimization
+
+- [optimization_problem]:
+- [optimization_algorithm]:
+ - [linear_programming]
+ - [integer_linear_programming]
+
+- [submodular_optimization]
+
+- "combinatorial optimization"
+
+Up: [computer_science]
+
+See also: [inefficiency]
diff --git a/optimization_problem b/optimization_problem
@@ -0,0 +1,8 @@
+# Optimization problem
+
+- [quadratic_assignment_problem]
+- [activity_selection_problem]
+
+- [complexity_class] [NPO]
+
+Up: [optimization]
diff --git a/order b/order
@@ -0,0 +1,9 @@
+# Order
+
+- [partial_order]
+- [total_order]
+- [inequality_mathematics]
+- [linear_extension], see also [topological_sort]
+- [well_quasi_ordering]
+
+Up: [mathematics]
diff --git a/ordered_decision_circuit b/ordered_decision_circuit
@@ -0,0 +1,13 @@
+# Ordered decision circuit
+
+used in [capelli2023direct]
+
+Formally a [decision_dnnf] such that there is an [order] on variables such that for each [trace], for each path in the [trace], the variables are in the correct order
+
+Can also be seen as [obdd] with [decomposable] [conjunction]
+
+occurs in:
+- [cali2017non]
+- [lai2017new]
+
+Up: [decision_dnnf]
diff --git a/ov_conjecture b/ov_conjecture
@@ -0,0 +1,13 @@
+# OV-conjecture
+
+OV conjecture statement: we assume that we need time Omega(n^{2-o(1)}) to solve the [orthogonal_vectors] problem
+
+Variant: [k_ov_conjecture]
+
+We know that [seth_implies_ov] (since 2005)
+
+This is equivalent to the [batch_partial_match_hypothesis]
+
+Up: [computational_hypothesis] on [orthogonal_vectors]
+
+See also: [omv], [fine_grained_complexity]
diff --git a/owqa_frontier_one_fds b/owqa_frontier_one_fds
@@ -0,0 +1,7 @@
+# OWQA with frontier one TGDs and FDs
+
+In [amarilli2015combining] Theorem 5.1:
+- [undecidability] with [frontier_one] [linear_TGDs] and [unary_FDs]
+- just because of [variable_repetition] in the [head]
+
+Up: [open_world_query_answering_fds], [frontier_one], [unary_FDs]
diff --git a/p_poly b/p_poly
@@ -0,0 +1,7 @@
+# P/poly
+
+[ptime] with [polynomial] [advice]
+
+Up: [complexity_class], [ptime], [advice]
+
+See also: [l_poly]
diff --git a/p_subsequence b/p_subsequence
@@ -0,0 +1,9 @@
+# P subsequence
+
+A [word] u is a p-subsequence of a [word] v for an integer p if the factor of v containing u as an embedding has total length at most p
+
+Discussed in [kosche2022combinatorial]
+
+Up: [subsequence]
+
+See also: [subsequence_testing_gap_constraints]
diff --git a/packing_problem b/packing_problem
@@ -0,0 +1,15 @@
+# Packing problem
+
+- [squares_in_squares]
+- https://en.wikipedia.org/wiki/Square_packing_in_a_square#Square_packing_in_a_circle
+- packing circles into triangles
+ https://en.wikipedia.org/wiki/Circle_packing_in_an_equilateral_triangle
+- packing circle into circle https://en.wikipedia.org/wiki/Circle_packing_in_a_circle
+- what about packing equilateral triangles into equilateral triangles ?
+- similar looking problem "Heilbronn triangle problem" https://en.wikipedia.org/wiki/Heilbronn_triangle_problem https://www.quantamagazine.org/the-biggest-smallest-triangle-just-got-smaller-20230908/
+- conjecture that you can pack any set of [tree] into [clique]: Gyárfás tree packing conjecture
+- [ringels_conjecture]
+
+Up: [computational_geometry]
+
+See also: [graph_packing], [packing_coloring]
diff --git a/palindrome b/palindrome
@@ -0,0 +1,7 @@
+# Palindrome
+
+[word] which is equal to its [mirror]
+
+Up: [word]
+
+See also: [manachers_algorithm], [context_free_language]
diff --git a/parallelism b/parallelism
@@ -0,0 +1,14 @@
+# Parallelism
+
+- [pram]
+- [mpc]
+- [multicore]
+- [enumeration_parallel]
+- [database_parallelism]
+- [single_instruction_multiple_data]
+- [fpga]
+- [parallel_algorithm]
+
+Up: [computer_science]
+
+See also: [distributed_computing], [machine_model]
diff --git a/paranp b/paranp
@@ -0,0 +1,8 @@
+# ParaNP
+
+From https://simonrey.fr/static/talks/PCT_Hardness.pdf
+- def: [parameterized_language] for which there is a nondeterministic [turing_machine] that takes as input (x, k), runs in [fpt] time f(k) x^c for some c,
+ and decides membership
+- [fpt] = paraNP iff [ptime] = [nptime]
+
+Up: [parameterized_complexity]
diff --git a/parikhs_theorem b/parikhs_theorem
@@ -0,0 +1,7 @@
+# Parikhs theorem
+
+https://en.m.wikipedia.org/wiki/Parikh's_theorem
+
+[regular_language] and [context_free_language] have same kind of [parikh_image]
+
+Up: [parikh_image]
diff --git a/parity b/parity
@@ -0,0 +1,10 @@
+# Parity
+
+- [parity_games] / [parity_acceptance]
+- [parity_p]
+- [parity_fine_grained]
+
+- [even]
+- [odd]
+
+Up: [modulo]
diff --git a/parity_p b/parity_p
@@ -0,0 +1,9 @@
+# Parity P
+
+https://en.wikipedia.org/wiki/Parity_P
+
+[Computational_problem] solvable by [nondeterministic_Turing_machine] where the [acceptance_condition] is that the number of [accepting_runs] is [even].
+
+Up: [parity], [complexity_class]
+
+See also: [parity_fine_grained]
diff --git a/partition b/partition
@@ -0,0 +1,5 @@
+# Partition
+
+Up: [mathematics]
+
+See also: [laminar_set_family], [partition_problem], [equivalence_relation]
diff --git a/partition_problem b/partition_problem
@@ -0,0 +1,9 @@
+# Partition problem
+
+[np_complete], admits [pseudo_polynomial_time] algorithm
+
+[reduction_subset_sum_partition_problem]
+
+Up: [decision_problem], [subset_sum]
+
+See also: [graph_partition], [partition]
diff --git a/path b/path
@@ -0,0 +1,16 @@
+# Path
+
+sequence of vertices in a [graph] such that any two successive vertices are connected by an [edge]
+
+- [simple_path]
+- [trail]
+- [shortest_path]
+- [hamiltonian_path]
+- [eulerian_path]
+- [path_undirected]
+
+Up: [graph]
+
+See also: [pathwidth], [path_graph]
+
+Aliases: paths
diff --git a/path_undirected b/path_undirected
@@ -0,0 +1,7 @@
+# Path undirected
+
+[path] in [undirected_graph]
+
+Up: [path]
+
+Aliases: undirected path, undirected paths
diff --git a/pathwidth b/pathwidth
@@ -0,0 +1,10 @@
+# Pathwidth
+
+like [treewidth] but for [tree_decomposition] which is a [path]
+
+- [pathwidth_directed]
+- [pathwidth_approximation]
+
+Up: [width_measure], [path]
+
+See also: [treewidth], [path_excentricity], [obstruction], [treelength]
diff --git a/pathwidth_approximation b/pathwidth_approximation
@@ -0,0 +1,6 @@
+# Pathwidth approximation
+
+- [groenland2022approximating], for graphs of bounded [treewidth]
+- [bansal2024approximating]
+
+Up: [pathwidth], [width_measure_approximation]
diff --git a/pathwidth_directed b/pathwidth_directed
@@ -0,0 +1,11 @@
+# Directed pathwidth
+
+- [barat2006directed], links with [cops_and_robbers]
+
+Relationship to [pathwidth]:
+- the directed pathwidth of a [graph_directed] which is actually [graph_undirected] is equal to the [pathwidth]
+- the directed pathwidth can be less than the [pathwidth], e.g., the directed pathwidth of a [directed_acyclic_graph] is always 0
+
+Up: [pathwidth]
+
+See also: [treewidth_directed]
diff --git a/pattern_language b/pattern_language
@@ -0,0 +1,14 @@
+# Pattern language
+
+[language_formal] defined as the set of [words] that can be obtained by [substituting] the variables of a [pattern_with_variables]
+
+Two variants:
+
+- [NE_pattern_language]: only consider [non_erasing_substitutions]
+- [E_pattern_language]: also allow [erasing_substitution]
+
+Problems: [pattern_language_computational_problems]
+
+variant erasing vs non-erasing
+
+Aliases: pattern languages
diff --git a/pattern_matching b/pattern_matching
@@ -0,0 +1,41 @@
+# Finding a string as a factor of another string
+
+## [computational_complexity]
+
+- [pattern_matching_algorithm]
+- [lower_bounds] on [combined_complexity]:
+ - [backurs2016which], cf [regular_expression_matching]
+
+## [dynamic_data]
+
+- [pattern_matching_dynamic]
+- [pattern_matching_realtime]
+
+## Other settings
+
+- [pattern_matching_streaming]
+
+## Variants
+
+- [circular_pattern_matching]
+- [point_set_pattern_matching]
+- [approximate_pattern_matching]
+- [maximal_exact_match]
+
+## Generalizations
+
+- [two_way_string_matching]
+- [regular_expression]
+- [pattern_with_variables]
+- [pattern_matching_wildcards] when allowing [wildcard]s
+- [pattern_matching_dontcare] when allowing [dontcare]s (one single symbol can be anything)
+- [pattern_matching_compressed] on [compressed_data]
+- [gapped_pattern_matching]: find two patterns separated by a distance within a specified range
+
+## Implementations
+
+- [pattern_matching_practice]
+
+Up: [stringology]
+
+See also: [pattern], [pattern_matching_2d]
diff --git a/pattern_matching_algorithm b/pattern_matching_algorithm
@@ -0,0 +1,8 @@
+# Pattern matching algorithm
+
+- [boyer_moore]
+- [aho_corasick]
+- [knuth_morris_pratt]
+- [rabin_karp] with [rolling_hash]
+
+Up: [algorithm] for [pattern_matching]
diff --git a/pattern_matching_realtime b/pattern_matching_realtime
@@ -0,0 +1,7 @@
+# Pattern matching realtime
+
+on text which arrives in streaming: [realtime]
+
+- [kucherov2013full]: pattern matching in [linear_time] in the pattern + number of occurrences on [dynamic_data] (with append in O(1) worst case)
+
+Up: [pattern_matching_dynamic], [realtime]
diff --git a/pattern_matching_streaming b/pattern_matching_streaming
@@ -0,0 +1,5 @@
+# Pattern matching streaming
+
+you get the pattern character by character and must build a [sketching] of the pattern, and then you get the text character by character and must match
+
+Up: [approximate_pattern_matching_streaming]
diff --git a/perfect_matching b/perfect_matching
@@ -0,0 +1,13 @@
+# Perfect matching
+
+A [matching] where every vertex is incident to an edge of the matching
+
+- [minimum_perfect_matching] / [hungarian_algorithm]
+
+- [perfect_matching_counting]
+
+Up: [matching]
+
+See also: [matching_counting]
+
+Aliases: perfect matchings
diff --git a/perfect_matching_counting b/perfect_matching_counting
@@ -0,0 +1,13 @@
+# Counting perfect matchings
+
+- On [planar_graphs], we can exactly count [perfect_matchings] via the [FKT_algorithm]
+- [Approximate_counting]:
+ - There is a [FPRAS] to count [perfect_matchings] on [bipartite_graphs] via [markov_chain_monte_carlo].
+ - connection to [permanent]?
+ - For [perfect_matchings] and general [graphs], the existence of an approximation algorithm is an [open_problem].
+
+See also: [matching_counting]
+
+Up: [counting_problem] of [perfect_matching]
+
+Aliases: counting perfect matchings, counting of perfect matchings
diff --git a/permutation b/permutation
@@ -0,0 +1,29 @@
+# Permutation
+
+## Notions
+
+- [orbit]
+- [permutation_matrix]
+
+## Problems
+
+- [permutation_distance]
+- [permutation_pattern_matching]
+- [superpermutation]
+
+## Specific permutations
+
+- [transposition]
+- [circular_permutation]
+
+## Variants
+
+- [permutation_signed]
+
+## Derived notions
+
+- [permutation_pattern]
+
+Up: [mathematics]
+
+See also: [sorting]
diff --git a/permutation_distance b/permutation_distance
@@ -0,0 +1,9 @@
+# Permutation distance
+
+related notion https://en.wikipedia.org/wiki/Rank_correlation
+
+- [kendall_tau_distance] ([bubble_sort] distance)
+- [spearman_footrule_distance] (L1-distance)
+- diaconis-graham bound showing that both distances are within a factor of 1/2
+
+Up: [distance] on [permutation]
diff --git a/planar_graph b/planar_graph
@@ -0,0 +1,29 @@
+# Planar graph
+
+A [graph_undirected] that can be embedded on [plane_mathematics]
+
+- Recognizing them: [planarity_testing]
+ - [dynamic_planarity_testing]
+- [carving_width] efficient computation:
+ - [seymour1994call] "rat-catcher" "ratcatcher"
+ - open for [treewidth]
+- [planar_language]
+
+[Theorem]s:
+
+- [Kuratowskis_theorem] in terms of [topological_minors]
+- [Wagners_theorem] in terms of [graph_minors]
+
+Specific algorithms:
+
+- [fkt_algorithm]
+
+Generalizations to [hypergraph]s: [planar_hypergraph]
+
+Generalization: [directed_planar_graph]
+
+See also: [graph_drawing]
+
+Up: [graph]
+
+Aliases: planar graphs, planar, graph planar, graphs planar
diff --git a/planarity_testing b/planarity_testing
@@ -0,0 +1,16 @@
+# Planarity testing
+
+https://en.wikipedia.org/wiki/Planarity_testing
+
+given [graph_undirected] G, is G [planar_graph]?
+
+can be done in [linear_time]
+
+on [dynamic_data]:
+
+- if edges arrive but are not deleted, tight [inverse_ackermann] algorithm
+- if edges can be added and deleted,
+ - [logarithmic] [lower_bounds]
+ - [polylogarithmic] [algorithm]
+
+Up: [planar_graph], [computational_problem]
diff --git a/polynomial_hierarchy b/polynomial_hierarchy
@@ -0,0 +1,13 @@
+# Polynomial hierarchy (PH)
+
+- first levels: [nptime], [conptime]
+ - see also [np_cap_conp]
+- second level: [pi2], [sigma2]
+ - see also [pi2_cap_sigma2]
+- [delta2p] = [ptime] with an [nptime] [oracle]
+ - https://complexityzoo.net/Complexity_Zoo:D#delta2p
+ - contains [boolean_hierarchy]
+
+Up: [complexity_hierarchy]
+
+See also: [boolean_hierarchy]
diff --git a/polytree b/polytree
@@ -0,0 +1,16 @@
+# Polytree
+
+https://en.wikipedia.org/wiki/Polytree
+
+A polytree is a [directed_acyclic_graph] whose underlying [undirected_graph] is a [tree]
+
+A polytree is always a [multitree]
+
+In a polytree, we can do [transitive_closure] in [output_linear] time, and do [enumeration] of reachable leaves with linear preprocessing and constant delay
+- this is like [boolean_matrix_multiplication] when there are no duplicate ways to obtain ones
+ - like [context_free_grammar_unambiguous]
+ - like [circuit] [deterministic]
+
+Up: [graph_family]
+
+See also: [multitree], [pseudoforest]
diff --git a/pqe_mso b/pqe_mso
@@ -0,0 +1,7 @@
+# PQE for MSO
+
+Can be done on [treelike_data]
+
+Up: [pqe] of [monadic_second_order_logic]
+
+See also: [pqe_fo]
diff --git a/pratt_hartmann b/pratt_hartmann
@@ -0,0 +1,8 @@
+# Pratt-Hartmann
+
+- [guarded_fragment]
+ - [gc2]
+
+- [pratt2024walking]
+
+Up: [researchers]
diff --git a/prefix b/prefix
@@ -0,0 +1,9 @@
+# Prefix
+
+- [prefix_u1]
+- [prefix_code]
+- [prefix_suffix_query]
+
+Up: [formal_language_theory]
+
+See also: [suffix], [factor], [subword]
diff --git a/prefix_suffix_query b/prefix_suffix_query
@@ -0,0 +1,9 @@
+# Prefix suffix query
+
+[pissis2024optimal]: given [word] T, [preprocess] it so that given i and j you can efficiently [find_all_occurrences] of T in T[0...i] T[j...n-1] (concatenation of a [prefix] and a [suffix])
+
+Uses [border_tree] [data_structure] from [gu1993efficient]
+
+Up: [stringology]
+
+See also: [prefix], [suffix]
diff --git a/preprocessing b/preprocessing
@@ -0,0 +1,11 @@
+# Preprocessing
+
+Computation done before something else
+
+Used in [enumeration_definition]
+
+Up: [enumeration_definition]
+
+See also: [delay], [enumeration_phase]
+
+Aliases: preprocess
diff --git a/preprocessing_phase b/preprocessing_phase
@@ -0,0 +1,7 @@
+# Preprocessing phase
+
+Phase of [enumeration_definition] when you do [preprocessing]
+
+Up: [enumeration_definition]
+
+See also: [enumeration_phase]
diff --git a/primal_graph b/primal_graph
@@ -0,0 +1,11 @@
+# Primal graph
+
+[graph_undirected]:
+- vertices are variables
+- edge connects two variables if they co-occur in a clause
+
+if [clause_width] is unbounded then contains large [clique]
+
+Up: [graph_undirected] for [conjunctive_normal_form]
+
+See also: [dual_graph], [incidence_graph], [primal_treewidth]
diff --git a/primal_treewidth b/primal_treewidth
@@ -0,0 +1,7 @@
+# Primal treewidth
+
+[treewidth] of [primal_graph] of [conjunctive_normal_form] [boolean_formula]
+
+Up: [conjunctive_normal_form]
+
+See also: [primal_pathwidth]
diff --git a/prime_number b/prime_number
@@ -0,0 +1,11 @@
+# Prime number
+
+- [prime_number_decomposition]
+- [prime_number_theorem]
+- [primality_testing] in [ptime]
+
+Up: [arithmetic]
+
+See also: [prime_implicant], [polynomial_irreducible], [twin_prime_conjecture], [goldbach_conjecture], [primitive_word]
+
+Aliases: prime numbers
diff --git a/prime_number_theorem b/prime_number_theorem
@@ -0,0 +1,7 @@
+# Prime number theorem
+
+[theorem] by Hadamard and La Vallée Poussin about [asymptotic] distribution of [prime_number]
+
+inequality without asymptotics: [rosser1962approximate], 3.13
+
+Up: [prime_number]
diff --git a/prisoners_dilemma b/prisoners_dilemma
@@ -0,0 +1,7 @@
+# Prisoners dilemma
+
+https://en.wikipedia.org/wiki/Prisoner%27s_dilemma
+
+Up: [game_theory]
+
+See also: [paradox], [collective_action_problem]
diff --git a/probabilistic_circuit b/probabilistic_circuit
@@ -0,0 +1,28 @@
+# Probabilistic circuit
+
+[circuit] which represents [probability_distribution]
+
+- leaves: distribution on a subset of variables called its scope
+- [product] of distributions, with [decomposability]
+- sum with coefficients to [mix] distributions
+
+optional conditions:
+- [smooth]
+- [determinism]: disjoint support on the inputs (= non-zero proba mass?)
+- [structured]
+
+we want to do [maximum_a_posteriori] on such circuits
+- [marginal_maximum_a_posteriori], MMAP
+ - max_Q sum_H p(Q, H)
+ - the problem is that summing on a subset of the variables loses [circuit_determinism]
+
+- a sum node is Q-deterministic if support is disjoint even when projecting out Q
+- and a circuit is Q-det if all sum nodes are Q-det or their scope does not
+ involve variables of Q
+
+- md-vtrees: a way to guarantee marginal determinism, just by labeling v-tree
+ nodes with a subset S of variables on which you have to be S-deterministic
+
+connections to other kinds of polynomials than [probability_distribution]: see [broadrick2024polynomial]
+
+See also: [arithmetic_circuit], [probabilities], [circuit_algebraic]
diff --git a/probabilistic_database_model b/probabilistic_database_model
@@ -0,0 +1,8 @@
+# Probabilistic database model
+
+- [tuple_independent_database]
+- [block_independent_disjoint] [database]
+- [pc_table]
+- also: [probabilistic_xml]
+
+Up: [probabilistic_databases], [database_model]
diff --git a/probabilistic_method b/probabilistic_method
@@ -0,0 +1,9 @@
+# Probabilistic method
+
+- farago2021meeting
+
+- [lovasz_local_lemma]
+
+- [gowers2010two] for bounds on [ramsey_theorem]
+
+Up: [theoretical_computer_science]
diff --git a/probabilities b/probabilities
@@ -0,0 +1,33 @@
+# Probabilities
+
+[probabilistic_model]s:
+- [bayes_network]
+- [markov_logic_network]
+- [probabilistic_circuit]
+- [determinantal_point_process]
+
+Tasks:
+
+- [pqe]
+- [maximum_a_posteriori]
+- [marginal]
+
+Algorithms:
+
+- [message_passing]
+- [monte_carlo]
+
+Concepts:
+
+- [random_variable]
+ - [probability_outcome]
+- [probability_distribution]
+
+Results:
+
+- [concentration_inequality]
+- [hoeffdings_inequality]
+
+Up: [mathematics]
+
+See also: [probabilistic_databases], [random_variable], [algorithm_randomized], [randomness]
diff --git a/probability_outcome b/probability_outcome
@@ -0,0 +1,9 @@
+# Probability outcome
+
+https://en.wikipedia.org/wiki/Outcome_(probability)
+
+Value of a [random_variable]
+
+Up: [probabilities]
+
+Aliases: probability outcomes, probabilistic outcome, probabilistic outcomes
diff --git a/provenance_circuit b/provenance_circuit
@@ -0,0 +1,8 @@
+# Provenance circuit
+
+Can use [circuit] for [provenance], e.g.,
+
+- [datalog] provenance: foundational paper [deutch2014circuits]
+- [provenance_mso]: [monadic_second_order_logic] provenance [amarilli2015provenance]
+
+Up: [provenance], [circuit]
diff --git a/provenance_description_logics b/provenance_description_logics
@@ -0,0 +1,5 @@
+# Provenance description logics
+
+[academic_papers]: [penaloza2023semiring]
+
+Up: [provenance], [description_logics]
diff --git a/provenance_optimal_joins b/provenance_optimal_joins
@@ -0,0 +1,5 @@
+# Provenance for optimal joins
+
+- wang2022query, achieves [polymatroid] bound
+
+Up: [optimal_joins] with [provenance]
diff --git a/proximity_search b/proximity_search
@@ -0,0 +1,7 @@
+# Proximity search
+
+- [conte2022proximity] (seen at [wepa_2022])
+- [conte2019new]
+- [brosse2019polynomial] for an application
+
+Up: [enumeration]
diff --git a/pspace b/pspace
@@ -0,0 +1,9 @@
+# PSPACE
+
+https://en.wikipedia.org/wiki/PSPACE
+
+- [PSPACE_complete]
+
+Up: [complexity_class]
+
+See also: [P_complete]
diff --git a/ptime b/ptime
@@ -0,0 +1,14 @@
+# PTIME
+
+[ptime_complete]
+
+When the input consists of integers, we distinguish: https://en.wikipedia.org/wiki/Time_complexity#Strongly_and_weakly_polynomial_time
+- "strongly polynomial" which means
+ - polynomial in the number of inputs
+ - the memory used in polynomial in the size of the input
+- "weakly polynomial" meaning polynomial in the number of integers and in the log of integers, e.g., [euclidean_algorithm], not just polynomial in the number of integers
+- not to be confused with [pseudo_polynomial_time]!!
+
+Up: [complexity_class]
+
+See also: [pseudo_polynomial_time], [quasipolynomial], [oplusp], [ptime_reduction]
diff --git a/pursuit_evasion b/pursuit_evasion
@@ -0,0 +1,10 @@
+# Pursuit evasion
+
+- [cops_and_robbers]
+- [hunters_and_rabbit]
+
+notion:
+- [monotone_strategy], cf for instance [dissaux2023recontamination]
+- [capture_time], cf for instance [benameur2024cops]
+
+Up: [graph]
diff --git a/pushdown_automaton b/pushdown_automaton
@@ -0,0 +1,13 @@
+# Pushdown automaton
+
+[context_free_grammar_pushdown_automaton_equivalence]
+
+[determinism]: [pushdown_automaton_deterministic]
+
+- k-turn pushdown automata: limits the alternation between [push_operation] and [pop_operation]
+ - introduced in [ginsburg1966finite]
+ - mentioned in [ganardi2018sliding]
+
+Up: [stack_automata]
+
+See also: [visibly_pushdown_automaton]
diff --git a/qp b/qp
@@ -0,0 +1,9 @@
+# QP
+
+https://en.wikipedia.org/wiki/Quasi-polynomial_time
+
+[complexity_class] of [decision_problem] that can be solved in [quasipolynomial] time (2^{log n}^c})
+
+According to [wikipedia], good candidates for [np_intermediate] problems
+
+Up: [complexity_class]
diff --git a/query b/query
@@ -0,0 +1,14 @@
+# Query
+
+- [query_language]
+ - [conjunctive_query]
+- [query_full]
+- [query_boolean]
+
+## Problems
+
+- [query_resilience]
+- [query_containment]
+- [minimal_witness]
+
+Up: [database_theory]
diff --git a/query_complexity b/query_complexity
@@ -0,0 +1,11 @@
+# Query complexity
+
+[Computational_complexity] of a [database_theory] [computational_problem] expressed as a function of the [query], assuming that the input [database_instance] remains constant.
+
+Also called "expression complexity"
+
+Introduced in [vardi1982complexity]
+
+Up: [database_theory_complexity]
+
+See also: [combined_complexity], [data_complexity]
diff --git a/query_evaluation b/query_evaluation
@@ -0,0 +1,21 @@
+# Query evaluation
+
+- [query_evaluation_conjunctive_query] for [conjunctive_query]
+- [datalog_query_evaluation] for [datalog]
+- [datalog_semiring_query_evaluation] for [datalog_semiring]
+- [agm_bound] pour [conjunctive_query] / [optimal_joins]
+- [panda]
+ - for [provenance] and [datalog_acyclic], see [wang2021query]
+- [query_optimization]
+- [query_evaluation_treewidth]
+
+- [complexity_space] / [complexity_time] tradeoff
+ - [deep2020space]
+
+- [query_evaluation_dichotomies]
+
+- [query_evaluation_incremental]
+
+Up: [database_theory]
+
+See also: [query_language], [enumeration_query_answers]
diff --git a/query_evaluation_incremental b/query_evaluation_incremental
@@ -0,0 +1,12 @@
+# Query evaluation incremental
+
+- [incremental_maintenance_cq]
+- [incremental_maintenance_rpq]
+- [incremental_maintenance_pqe]
+- [incremental_maintenance_mso]
+
+special case : [first_in_first_out_update_sequence] / "enclosureness"
+
+Up: [incremental_maintenance], [query_evaluation]
+
+See also: [incremental_view_maintenance]
diff --git a/query_language b/query_language
@@ -0,0 +1,41 @@
+# Query language
+
+- [conjunctive_query]
+ - [sjfcq]
+- [union_of_conjunctive_queries]
+- [first_order_logic]
+- [monadic_second_order_logic]
+
+## Other formalisms
+
+- [ontology_mediated_query]
+- [relational_calculus] / [relational_algebra]
+ - [nested_relational_calculus]
+ - nested [k_relation]
+- [graph_query_languages]
+
+## Features
+
+- [query_recursive]
+ - [regular_path_query]
+ - [datalog]
+ - with [negation]
+ - with [aggregation]
+- [aggregation]
+
+## Subclasses
+
+- [homomorphism_closed]
+- [query_acyclic]
+ - [datalog_acyclic]
+ - [conjunctive_query_acyclic]
+- [query_full]
+ - [conjunctive_query_full]
+
+## Variants
+
+- [sum_product_query]
+
+Up: [database_theory]
+
+See also: [query_rewriting]
diff --git a/queue b/queue
@@ -0,0 +1,8 @@
+# Queue
+
+- [circular_buffer]
+- [priority_queue]
+
+Up: [data_structure]
+
+See also: [stack]
diff --git a/quicksort b/quicksort
@@ -0,0 +1,7 @@
+# Quicksort
+
+uses [pivot]
+
+Up: [algorithm] for [sorting]
+
+See also: [quickselect]
diff --git a/radoszewski2011hamiltonian b/radoszewski2011hamiltonian
@@ -0,0 +1,11 @@
+# Radoszewski2011hamiltonian
+
+Studies when the [graph_square] of an [undirected_graph] has [Hamiltonian_cycle] and [Hamiltonian_path]
+
+[harary1971trees] shows that [graph_square] of [tree] contains a [Hamiltonian_cycle] iff it is a [caterpillar_tree]
+
+They show that [graph_square] of [tree] contains a [Hamiltonian_path] iff it is a [horsetail_graph]. Testing this, and finding the path, can be done in [linear_time], and [linear_time] [preprocessing] is sufficient to test in constant time, given (u, v), whether there is a [Hamiltonian_path] from u to v.
+
+Up: [academic_paper] on [hamiltonian_cycle]
+
+See also: [hamiltonian_cycle_square], [hamiltonian_cycle_cube]
diff --git a/ramsey_theorem b/ramsey_theorem
@@ -0,0 +1,15 @@
+# Ramsey theorem
+
+Consequence: any sufficiently large [undirected_graph] contains either a big [clique] or a big [independent_set]
+- so the [union] of both problems is trivial
+
+Generalizations:
+
+- more than 2 colors
+ - https://en.wikipedia.org/wiki/Ramsey%27s_theorem#More_colors
+- [hypergraphs]
+ - https://en.wikipedia.org/wiki/Ramsey%27s_theorem#Hypergraphs
+
+Can also be useful in [formal_language_theory]
+
+Up: [mathematics]
diff --git a/random_graph b/random_graph
@@ -0,0 +1,7 @@
+# Random graph
+
+also: [random_dfa]
+
+Up: [graph], [randomness]
+
+See also: [random_walk]
diff --git a/random_structure b/random_structure
@@ -0,0 +1,7 @@
+# Random structure
+
+- [random_graph]
+- [random_walk]
+- [random_dfa]
+
+Up: [randomness]
diff --git a/random_variable b/random_variable
@@ -0,0 +1,10 @@
+# Random variable
+
+- [uniform]
+- [bernoulli]
+
+Can take several values, each of which is called a [probability_outcome]
+
+Up: [probabilities]
+
+See also: [correlation]
diff --git a/randomness b/randomness
@@ -0,0 +1,23 @@
+# Randomness
+
+- [complexity_random]
+- [algorithm_randomized]
+- [kolmogorov_complexity]
+- [pseudorandomness]
+ - [prng]
+
+## [random_structure]
+
+- [random_graph]
+- [random_walk]
+- [random_dfa]
+
+## Tasks
+
+- [enumeration_random_order]
+- [sampling]
+ - [uniform_sampling]
+
+Up: [mathematics]
+
+See also: [probabilities]
diff --git a/range_query b/range_query
@@ -0,0 +1,9 @@
+# Range query
+
+Maintain a collection of points and answer queries asking about all the points in a specific range
+
+- [range_sum]: sum the points
+- [range_reporting]: report the points
+- [gupta1995further]: range color counting/reporting in [rectangle]
+
+See also: [skyline], [2d_range_reporting], [range_reporting], [range_tree]
diff --git a/ranking_function b/ranking_function
@@ -0,0 +1,11 @@
+# Ranking function
+
+Mentioned by [Nikos] for [tziavelis2022optimal]
+
+From least to most restrictive:
+
+- "holistic-monotone" in [fagin2003optimal]
+- "subset-monotone" in [kimelfeld2006incrementally]
+- "strongly subset-monotone" in [tziavelis2022optimal]
+
+Up: [function] for [ranked_access]
diff --git a/reachability b/reachability
@@ -0,0 +1,10 @@
+# Reachability
+
+- [st_reachability]
+ - [st_reachability_undirected]
+- [reachability_single_source]
+- [reachability_all_pairs]
+
+Up: [computational_problem], [graph_theory]
+
+Aliases: reachability problem
diff --git a/reconstruction_conjecture b/reconstruction_conjecture
@@ -0,0 +1,5 @@
+# Reconstruction conjecture
+
+https://en.wikipedia.org/wiki/Reconstruction_conjecture
+
+Up: [graph_reconstruction]
diff --git a/reduction_gap b/reduction_gap
@@ -0,0 +1,9 @@
+# Reduction gap
+
+https://en.wikipedia.org/wiki/Gap_reduction
+
+for [approximation]
+
+Up: [reduction]
+
+See also: [maj_sat]
diff --git a/regex b/regex
@@ -0,0 +1,12 @@
+# Regex
+
+[regular_expression] with [back_reference]s
+
+[membership_problem] for Regex is [np_complete]
+- already for [patterns_with_variables]
+
+can be translated to [FCreg] if there is no variable under [kleene_star]
+
+[regex_deterministic]
+
+Up: [regular_expression]
diff --git a/regex_deterministic b/regex_deterministic
@@ -0,0 +1,7 @@
+# Regex deterministic
+
+[freydenberger2019deterministic]
+
+generalizes [regular_expression_deterministic]
+
+Up: [regex], [determinism_language]
diff --git a/regexp_dataset b/regexp_dataset
@@ -0,0 +1,17 @@
+# Regexp dataset
+
+- regexlib.com
+- [polyglot_regex_corpus]
+- [snort]
+- [suricata] dataset https://suricata.io/
+ - similar to [snort]
+- [sparql_logs]
+ - [bonifati2017analytical]
+- those of [kong2002software]
+ - [clamav]
+ - [spamassassin]
+ - [protomata]
+
+See also: [regexp_information_extraction]
+
+Up: [regular_expression_practice]
diff --git a/regular_expression_denial_of_service b/regular_expression_denial_of_service
@@ -0,0 +1,13 @@
+# Regular_expression_denial_of_service (ReDoS)
+
+Caused in particular by [backtracking]
+
+Mentioned in [moseley2023derivative]
+
+[parolini2023sound]: [static_analysis] to identify denial of service
+
+Up: [regular_expression], [denial_of_service]
+
+Aliases: [redos]
+
+See also: [catastrophic_backtracking]
diff --git a/regular_expression_deterministic b/regular_expression_deterministic
@@ -0,0 +1,38 @@
+# Deterministic regular expression, aka "one-unambiguous"
+
+- position automaton is [automata_deterministic]
+ - aussi [glushkov_automaton] is [automata_deterministic]
+
+[groz2012deterministic] and [groz2017efficient]
+- can check in [linear_time] if [regular_expression] is deterministic
+- can perform [regular_expression_matching] in O(n log log m + m)
+
+according to [freydenberger2019deterministic], also an algorithm in O(|Sigma| m + n)
+
+- notion used in [document_type_definition]
+
+- generalizations:
+ - [DRX] with [backreferences] (no longer [regular_language])
+ - [caron2017hierarchy], extensions within [regular_languages]:
+ - [k_block_deterministic_regular_expression]: something about a block of k input symbols moving unambiguously to the next k positions of the regular expression
+ - proper hierarchy
+ - according to [han2008generalizations]
+ - any block deterministic [unary_language] is deterministic regular expression
+ - [k_lookahead_deterministic_regular_expression]: reading the k next symbols of the word makes the following position unique
+ - proper hierarchy
+ - notion of (k,l)-unambiguous
+
+Recognizes a subset of [regular_languages] according to [groz2017efficient]:
+- [bruggemannklein1998one]: (a+b)^* a (a+b) has no equivalent deterministic regular expression
+- [ping2015deciding] and [czerwinski2017deciding]: decide if an input [language] has an equivalent deterministic regular expression
+ - [bruggemannklein1998one]: given a [deterministic_automaton], can be done in [ptime]
+ - given a [nondeterministic_automaton], it is [PSPACE_complete]
+
+subclass: [regular_expression_strongly_deterministic] [gelade2009regular]
+- in the context of this, "deterministic" is called "weakly deterministic"
+
+- [language_intersection], [language_inclusion] problem for deterministic regexps
+
+Up: [regular_expression], [determinism]
+
+Aliases: deterministic regular expression, deterministic regular expressions, one-unambiguous regular expression, one-unambiguous regular expressions, 1-unambgiuous regular expression, 1-unambiguous regular expressions
diff --git a/regular_expression_repetition b/regular_expression_repetition
@@ -0,0 +1,6 @@
+# Regular expression repetition
+
+e^{p,q}: repeat e between p and q times
+- p and q written in binary (concise)
+
+Up: [regular_expression_extensions]
diff --git a/regular_expression_strongly_deterministic b/regular_expression_strongly_deterministic
@@ -0,0 +1,8 @@
+# Regular expression strongly deterministic
+
+- at each position it is clear which operator to use next (not just which letter to match)
+- leads to the same class of languages as [regular_expression_deterministic]
+
+discussed in [gelade2009regular]
+
+Up: [regular_expression_deterministic]
diff --git a/regular_language b/regular_language
@@ -0,0 +1,48 @@
+# Regular language
+
+## [computational_problem]
+
+- [regular_language_membership]
+ - [approximate_membership]
+ - [dynamic_membership]
+- [sliding_window]
+- [regular_language_communication_complexity]
+
+## [regular_language_list]
+
+- [parity]
+
+## [regular_language_family]
+
+- [locally_testable_language]
+- [regular_language_sparse]: polynomial number of words per length
+ - [regular_language_slender]: constant number of words
+ - [regular_language_thin]: at most one word
+
+## Connections
+
+- [regular_language_communication_complexity]
+
+## Generalizations
+
+- [regular_tree_language]
+
+## Concepts
+
+- [star_height]
+ - arbitrarily large
+ - connection to [cycle_rank] of [automata] via [eggans_theorem]
+- [generalized_star_height] en ajoutant [complementation]
+ - generalized star height of zero is [star_free_language]
+
+## Results
+
+- [myhill_nerode_theorem]
+ - [myhill_nerode_relation]
+- [pumping_lemma]
+
+See also: [automata]
+
+Up: [formal_language], [regular]
+
+Aliases: regular languages
diff --git a/regular_language_membership b/regular_language_membership
@@ -0,0 +1,8 @@
+# Regular language membership
+
+- [automaton_acceptance]
+- [approximate_membership]
+- [dynamic_membership]
+- [regular_expression_matching]
+
+Up: [membership_problem] for [regular_language]
diff --git a/regular_path_query b/regular_path_query
@@ -0,0 +1,29 @@
+# Regular path query
+
+[query] on [graph_database] defined by [regular_expression]
+
+- [rpq_query_evaluation]
+- [rpq_captures]
+
+## Extensions
+
+- [2rpq]
+- [uc2rpq]
+
+## Special cases
+
+- [word_query]
+
+## Fragments
+
+- [rpq_unbounded]
+
+## Problems
+
+- [pqe_rpq]
+
+Up: [graph_query_languages]
+
+See also: [regular_trail_query]
+
+Aliases: regular path queries, RPQ, RPQs
diff --git a/regular_trail_query b/regular_trail_query
@@ -0,0 +1,7 @@
+# Regular trail query
+
+[regular_path_query] but with [trail] semantics
+
+see article [martens2023trichotomy]
+
+Up: [regular_path_query], [trail]
diff --git a/regular_tree_language b/regular_tree_language
@@ -0,0 +1,7 @@
+# Regular tree language
+
+[tree_language] defined by [tree_automaton]
+
+Up: [regular_language] on [tree]
+
+Aliases: regular tree languages
diff --git a/rematch b/rematch
@@ -0,0 +1,10 @@
+# Rematch
+
+- https://rematchcl.web.app/ / rematch.cl
+- https://github.com/REmatchChile/REmatch-paper
+- [riveros2023rematch]
+- [bossonney2024demonstrating]
+
+notion of [earliest_answering] according to [bossonney2024demonstrating]
+
+Up: [enumeration_spanner]
diff --git a/repair_counting b/repair_counting
@@ -0,0 +1,5 @@
+# Repair counting
+
+[calautti2021counting]: [dichotomy] on [repair_counting] entailing a query for [functional_dependency]
+
+Up: [counting_problem], [database_repairs]
diff --git a/resolution b/resolution
@@ -0,0 +1,6 @@
+# Resolution
+
+- [resolution_rule]
+- [resolution_proof]
+
+Up: [satisfiability_boolean], [logic]
diff --git a/resolution_rule b/resolution_rule
@@ -0,0 +1,5 @@
+# Resolution rule
+
+(C or x) AND (D or not x) IMPLIES C or D
+
+Up: [satisfiability_boolean]
diff --git a/result b/result
@@ -0,0 +1,10 @@
+# Result
+
+A [mathematical] claim with associated [proof]
+
+- [theorem]
+- [lemma]
+
+Up: [mathematics]
+
+See also: [conjecture]
diff --git a/ringels_conjecture b/ringels_conjecture
@@ -0,0 +1,8 @@
+# Ringels conjecture
+
+We can pack any tree with n edges 2n+1 times into the complete graph K_{2n+1}
+
+Proved for large enough n in [montgomery2020proof]
+- also covered in [quanta_magazine]
+
+Up: [packing_problem] of [tree] in [graph_complete]
diff --git a/roths_theorem b/roths_theorem
@@ -0,0 +1,11 @@
+# Roths theorem
+
+https://en.wikipedia.org/wiki/Roth%27s_theorem_on_arithmetic_progressions
+
+[szemeredis_theorem] for [arithmetic_progressions] of length 3
+
+connection to [triangles] and [graph_removal_lemma]
+
+Also [salem_spencer_set] for a set without [arithmetic_progression] of length 3
+
+Up: [szemeredis_theorem]
diff --git a/rp b/rp
@@ -0,0 +1,16 @@
+# RP
+
+Class of [decision_problem] having [algorithm_randomized] running in [ptime]
+with [one_sided_error]:
+- accept with probability 3/4 if the input is true
+- always reject if the input is false
+
+RP subseteq [nptime], and believed to be different
+
+Corresponding notion of [algorithm] running in [ptime]: "Monte Carlo algorithm with bounded probability of one-sided error"
+
+[rp] subseteq [bpp]
+
+Up: [complexity_random]
+
+See also: [bpp], [zpp], [corp], [automaton_monte_carlo_one_sided]
diff --git a/rpq_query_evaluation b/rpq_query_evaluation
@@ -0,0 +1,14 @@
+# Rpq query evaluation
+
+survey: [barcelo2013querying]
+
+naive algorithm: [product_graph]
+
+- [rpq_fine_grained]
+- [rpq_trichotomies]
+- [enumeration_rpq]
+- [rpq_answer_testing]
+- [rpq_counting_answers]
+- [rpq_output_sensitive]
+
+Up: [regular_path_query], [query_evaluation]
diff --git a/salem_spencer_set b/salem_spencer_set
@@ -0,0 +1,7 @@
+# Salem spencer set
+
+https://en.wikipedia.org/wiki/Salem%E2%80%93Spencer_set
+
+Up: [combinatorics]
+
+See also: [roths_theorem]
diff --git a/satisfiability_unambiguous b/satisfiability_unambiguous
@@ -0,0 +1,10 @@
+# Unambiguous-SAT
+
+SAT when you are promised there is at most a unique solution
+
+https://en.wikipedia.org/wiki/Valiant%E2%80%93Vazirani_theorem
+- if unambiguous SAT has a [ptime] algorithm then [rp] = [nptime]
+
+https://eccc.weizmann.ac.il//report/2011/151/ rules out some possible improvements
+
+Up: [sat_variants], [unambiguity]
diff --git a/satisfiability_weighted b/satisfiability_weighted
@@ -0,0 +1,10 @@
+# Weighted satisfiability
+
+creignou2012satisfiability: given a [formula_boolean] phi and integer k, decide
+if phi has a [satisfying_assignment] of [hamming_weight] exactly k
+
+- [satisfiability_weighted_monotone_cnf]
+
+Up: [sat_variants]
+
+See also: [maxsat]
diff --git a/schnyders_theorem b/schnyders_theorem
@@ -0,0 +1,9 @@
+# Schnyder's theorem
+
+https://en.wikipedia.org/wiki/Schnyder%27s_theorem
+
+An [undirected_graph] is [planar] iff the [partial_order_dimension] of its [incidence_poset] is <= 3
+
+[generalization] to [simplicial_complex] in [mendez1999geometric]
+
+Up: [theorem] about [planar_graph]
diff --git a/schutzenbergers_theorem b/schutzenbergers_theorem
@@ -0,0 +1,8 @@
+# Schutzenbergers theorem
+
+- [first_order_logic]
+- [monoid_aperiodic]
+- [regular_expression_star_free]
+- [automata_counter_free]
+
+Up: [theorem] in [formal_language_theory]
diff --git a/sdnnf b/sdnnf
@@ -0,0 +1,5 @@
+# SDNNF
+
+like [dnnf] but obeys [structuredness]
+
+Up: [knowledge_compilation_classes], [dnnf], [structuredness]
diff --git a/selection_algorithm b/selection_algorithm
@@ -0,0 +1,7 @@
+# Selection algorithm
+
+- [quickselect]
+
+Up: [algorithms_list]
+
+See also: [median_of_medians]
diff --git a/self_loop b/self_loop
@@ -0,0 +1,13 @@
+# Self loop
+
+An [edge] from a [vertex] to itself
+
+In [undirected_graphs], this is typically not allowed, or you would explicitly say that you are considering a graph with self-loops allowed.
+
+In [directed_graphs], this is typically allowed
+
+In [multigraph_directed], you may have multiple self-loops
+
+Up: [graph_basic_notions]
+
+Aliases: self-loops, self_loops
diff --git a/semantic_acyclicity b/semantic_acyclicity
@@ -0,0 +1,9 @@
+# Semantic acyclicity
+
+- decide if [conjunctive_query] is [query_equivalent] to [conjunctive_query_acyclic]
+
+- e.g., for [uc2rpq]
+
+Up: [database_theory]
+
+See also: [semantic_treewidth], [formula_width]
diff --git a/semiring_idempotent b/semiring_idempotent
@@ -0,0 +1,5 @@
+# Idempotent semiring
+
+A [semiring] satisfying the equation a+a = a for every a
+
+Up: [semiring], [idempotent]
diff --git a/separation_logic b/separation_logic
@@ -0,0 +1,9 @@
+# Separation logic
+
+https://en.wikipedia.org/wiki/Separation_logic
+
+Different from [separator_logic]
+
+Up: [logic]
+
+See also: [formal_language_separation]
diff --git a/separator_logic b/separator_logic
@@ -0,0 +1,11 @@
+# Separator logic
+
+[first_order_logic] with a predicate talking about the existence of a path (see [reachability], [transitive_closure]) while avoiding certain vertices
+
+See bojanczyk2021separator
+
+Between [first_order_logic] and [monadic_second_order_logic]
+
+Different from [separation_logic]
+
+Up: [logic]
diff --git a/sequence b/sequence
@@ -0,0 +1,13 @@
+# Sequence
+
+## Examples
+
+- [Kleene_sequence]
+- [De_Bruijn_sequence]
+- [arithmetic_progression]
+
+## Concepts
+
+- [subsequence]
+
+Up: [mathematics]
diff --git a/set b/set
@@ -0,0 +1,5 @@
+# Set
+
+- [multiset]
+
+Up: [set_theory]
diff --git a/set_function b/set_function
@@ -0,0 +1,11 @@
+# Set function
+
+- [monotone], non-negative, zero for [empty_set]
+- [subadditive]
+- [submodular]: corresponds to [polymatroid]
+ - defined by [shannon_type_inequality]
+- [entropic]: also defined by [non_shannon_type_inequality]
+- [normal]
+- [modular]
+
+See also: [statistical_profile], [entropic_vector]
diff --git a/set_intersection b/set_intersection
@@ -0,0 +1,9 @@
+# Set intersection problem
+
+Given sets S_1, ..., S_m, preprocess them such that given any two sets you can efficiently report the elements of the intersection
+
+[goldstein2019hardness], [kopelowitz2020towards], [fischer2024deterministicb]
+
+- [sorted_list_intersection]
+
+See also: [ov_conjecture], [set_union]
diff --git a/set_intersection_2 b/set_intersection_2
@@ -0,0 +1,5 @@
+# Intersection of two sets
+
+[munro1976sorting], lower bound on two sets (not ordered)
+
+See also: [sorted_list_intersection], [set_intersection]
diff --git a/set_theory b/set_theory
@@ -0,0 +1,5 @@
+# Set_theory
+
+- [set]
+
+Up: [mathematics]
diff --git a/sharp_automaton b/sharp_automaton
@@ -0,0 +1,9 @@
+# Sharp automaton
+
+[counting_problem] of [density_function] of [automata]
+
+- [sharp_nfa]
+- [sharp_ufa]
+- [sharp_dfa]
+
+Up: [counting_problem], [automata]
diff --git a/sharp_dfa b/sharp_dfa
@@ -0,0 +1,11 @@
+# Sharp DFA
+
+counting the number of words accepted by [automata_deterministic]
+
+in [ptime], because [sharp_ufa] is in [ptime]
+
+also works with [word_automaton_unambiguous]
+
+See also: [sharp_nfa], [sharp_ufa], [density_function]
+
+Up: [sharp_automaton], [automata_deterministic]
diff --git a/sharp_nfa b/sharp_nfa
@@ -0,0 +1,17 @@
+# Sharp NFA
+
+[counting_problem] of [density_function] of [automata_nondeterministic]:
+- input:
+ - [automata_nondeterministic]
+ - a length n written in [unary]
+- output: cardinality of [slice] of accepted language
+
+[computational_complexity]:
+- [sharpp]-hard
+ - by reduction from [sharp_satisfiability_dnf]
+- [spanl]-complete
+- admits a [fpras]: [arenas2021nfa]
+
+Up: [sharp_automaton], [automata_nondeterministic]
+
+See also: [sharp_dfa], [sharp_cfg]
diff --git a/sharp_ufa b/sharp_ufa
@@ -0,0 +1,12 @@
+# Sharp-UFA
+
+given [word_automaton_unambiguous] A and length n in [unary], count the number of words of length n accepted by A
+
+in [ptime], by counting [run]s
+
+even if n is given in binary, by [fast_exponentiation] and [matrix_multiplication]
+- cf https://cstheory.stackexchange.com/a/8202
+
+Up: [sharp_automaton], [word_automaton_unambiguous]
+
+See also: [sharp_nfa], [sharp_dfa], [density_function]
diff --git a/shortest_disjoint_paths b/shortest_disjoint_paths
@@ -0,0 +1,11 @@
+# Shortest disjoint paths
+
+- reference [berczi2017directed]
+ - if edge weights can be zero
+ - [np_complete] because can reduce from [disjoint_paths]
+ - if edge weights are positive
+ - 2-disjoint shortest path is [ptime] on [graph_directed]
+ - other results on [planar_graph]
+- open whether 3-disjoint shortest path is ptime on [graph_directed]
+
+Up: [disjoint_paths]
diff --git a/shortest_path_almost b/shortest_path_almost
@@ -0,0 +1,9 @@
+# Shortest path almost
+
+in a [graph_directed], is there a [simple_path] from source to sink whose length is longer than the shortest path?
+
+tractable on [planar_graph]: cf [wu2015next]
+
+[parameterized_complexity]: [bezakova2017finding]
+
+Up: [shortest_path]
diff --git a/shuffle b/shuffle
@@ -0,0 +1,6 @@
+# Shuffle
+
+- [shuffle_square]
+- a finite set of [word] can be decomposed into at most one multiset of which it is the shuffle: see [berstel2002shuffle]
+
+Up: [formal_language_theory]
diff --git a/shuffle_square b/shuffle_square
@@ -0,0 +1,9 @@
+# Shuffle square
+
+A [word] which can be written as the [shuffle] of a word with itself
+
+[np_complete] to test if a word is a shuffle square
+
+It's [open_problem] what is the minimum alphabet size required to have infinitely many words without shuffle squares, cf https://a3nm.net/work/research/questions/#words-without-shuffle-squares
+
+Up: [shuffle]
diff --git a/sidon_set b/sidon_set
@@ -0,0 +1,9 @@
+# Sidon set
+
+set of [natural_numbers] where all pairwise [sums] are unique
+
+[open_question]: how many integers <= x can a Sidon set contain, as a function of x?
+
+Up: [combinatorics]
+
+See also: [golomb_ruler]
diff --git a/sim_width b/sim_width
@@ -0,0 +1,5 @@
+# Sim width
+
+defined in [kang2017width], variant of [mim_width]
+
+Up: [width_measure]
diff --git a/simple_path b/simple_path
@@ -0,0 +1,7 @@
+# Simple path
+
+path with no repeated vertices
+
+Up: [path]
+
+See also: [trail]
diff --git a/sipser_lautemann_theorem b/sipser_lautemann_theorem
@@ -0,0 +1,7 @@
+# Sipser lautemann theorem
+
+https://en.wikipedia.org/wiki/Sipser%E2%80%93Lautemann_theorem
+
+[bpp] is in [sigma2_cap_pi2]
+
+Up: [theorem] about [bpp]
diff --git a/sjfcq b/sjfcq
@@ -0,0 +1,7 @@
+# SJFCQ
+
+[conjunctive_query] without [self_join]
+
+[dichotomy] for [pqe] in [dalvi2007efficient]
+
+Up: [conjunctive_query], [self_join]
diff --git a/skew_multicut b/skew_multicut
@@ -0,0 +1,5 @@
+# Skew multicut
+
+- [eiben2022parameterized]
+
+Up: [minimum_multicut]
diff --git a/slogspace b/slogspace
@@ -0,0 +1,17 @@
+# SL
+
+class of [decision_problem] reducible to [st_reachability_undirected]
+
+Can be defined via [turing_machine_reversible]
+
+Shown to be equal to [logspace] by [reingold]
+
+- for [2sat]: corresponds to the case where exactly one literal in each clause must hold
+
+Closed under [complementation]
+
+Up: [complexity_class]
+
+See also: [complexity_space]
+
+Aliases: SL
diff --git a/small_universe_hitting_set b/small_universe_hitting_set
@@ -0,0 +1,11 @@
+# Small universe hitting set problem
+
+Variant of the [OV_conjecture], implies the [OV_conjecture]
+
+Introduced in [williams2015hardness] (Conjecture 5)
+
+Used in [eldar2023direct]
+
+See also: [orthogonal_vectors], [hitting_set]
+
+Up: [hypothesis]
diff --git a/sorted_list_intersection b/sorted_list_intersection
@@ -0,0 +1,11 @@
+# Sorted list intersection
+
+- can be done in [linear_time] in both lists
+- but if one of the lists is much smaller than the others, you can do [binary_search] of the values of the small list into the big list
+
+https://stackoverflow.com/a/40538162 lower bound and upper bound
+- Theta (n log (m/n)) for n the smaller value
+
+See also: [set_intersection], [set_intersection_2], [sorted_array]
+
+Up: [intersection] of [sorted_list]
diff --git a/sorting b/sorting
@@ -0,0 +1,15 @@
+# Sorting
+
+- [insertion_sort]
+- [selection_sort]
+- [heap_sort]
+- [binary_tree_sort]
+- [quicksort]
+- [merge_sort]
+- [bucket_sort]
+- [sorting_ram] on the [ram_model]
+- [bubble_sort]
+
+Up: [algorithms]
+
+See also: [permutation], [sorted_list]
diff --git a/spanl b/spanl
@@ -0,0 +1,9 @@
+# SpanL
+
+Counting the number of *distinct* outputs of an [nl] [transducer]
+
+Complete problem: [sharp_nfa]
+
+See also: [spanp]
+
+Up: [complexity_class], [counting]
diff --git a/spanner b/spanner
@@ -0,0 +1,55 @@
+# Spanner
+
+- [spanner_surveys]
+- other model: [annotation_transducer]
+
+## Tasks
+
+- [enumeration_spanner]
+- [spanner_dynamic]
+
+## Classes
+
+- [spanner_regular]
+- [spanner_core]
+ - [refl_spanner]
+ - [generalized_core_spanner]
+
+## Variants
+
+- [spanner_weighted]
+- [v_structure]
+
+## Formalisms
+
+- [regex_formula]s
+- [variable_set_automaton]
+- can be extended with
+ - [relational_algebra]
+ - [datalog]
+- [spanner_cfg]
+- [spanners_incomplete]
+
+## Framework
+
+- formal framework: see [riveros2024framework]
+
+## Other settings
+
+- [spanner_practice]
+
+## Questions
+
+- [spanner_expressiveness]
+- [spanner_parallelizability]
+- [spanner_frequent_sequence_mining]
+
+## References
+
+- [peterfreund2019complexityb], [phd_thesis] of [liat]
+
+Up: [formal_language_theory], [database_theory]
+
+See also: [graph_spanner], [capture_variable], [annotation_automata]
+
+Aliases: document spanner, document spanners, spanners
diff --git a/spanner_cfg b/spanner_cfg
@@ -0,0 +1,6 @@
+# Spanner-CFG
+
+- [peterfreund2021grammars]
+- [amarilli2022efficient]
+
+Up: [spanner], [context_free_grammar]
diff --git a/spanner_core b/spanner_core
@@ -0,0 +1,14 @@
+# Spanner core
+
+[regex_formula]s extended with [projection], [union], [join], and [string_equality_selection]
+
+Other way to see it: [query] over the result of [spanner]s
+([freydenberger2018joining] / [peterfreund2019complexity])
+
+Extension: [generalized_core_spanner]
+
+See also: [refl_spanner]
+
+Up: [spanner]
+
+Aliases: core spanner, core spanners
diff --git a/spanner_dynamic b/spanner_dynamic
@@ -0,0 +1,6 @@
+# Spanner dynamic
+
+- [academic_paper] but from [research_practical]: [kassaie2023update]
+- otherwise, [losemann2014mso] etc.
+
+Up: [spanner], [dynamic_data]
diff --git a/spanner_regular b/spanner_regular
@@ -0,0 +1,8 @@
+# Spanner regular
+
+two equivalent definitions ([peterfreund2019complexityb] section 2.4):
+- with [variable_set_automaton]
+- with [regex_formula]s extended with [union], [projection], and [join]
+ - optionally with [difference]
+
+Up: [spanner]
diff --git a/spanner_surveys b/spanner_surveys
@@ -0,0 +1,8 @@
+# Spanner surveys
+
+- [schmid2024information]
+- [schmid2024short]: [eatcs_bulletin] article
+- [phd_thesis] of [liat]
+- [fagin2015document]
+
+Up: [spanner], [survey_paper]
diff --git a/spanner_weighted b/spanner_weighted
@@ -0,0 +1,8 @@
+# Spanner weighted
+
+- [doleschal2020complexity], [aggregation] over [spanner]
+- [doleschal2020weight], with [semiring]
+
+Up: [spanner], [weighted_logic]
+
+See also: [enumeration_ordered]
diff --git a/spanning_tree b/spanning_tree
@@ -0,0 +1,8 @@
+# Spanning tree
+
+- [minimum_spanning_tree]
+- [minimum_degree_spanning_tree]
+
+See also: [steiner_tree]
+
+Up: [tree]
diff --git a/spanp b/spanp
@@ -0,0 +1,9 @@
+# SpanP
+
+Counting the number of *distinct* outputs of an [nptime] [transducer]
+(e.g., counting the number of subgraphs that is [3_colorable])
+-> intuitively you can do [projection] operator
+
+See also: [spanl]
+
+Up: [complexity_class], [counting]
diff --git a/squaring b/squaring
@@ -0,0 +1,10 @@
+# Squaring
+
+- [square_word]
+- [square_testing]
+- [matrix_square]
+- [shuffle_square]
+
+Up: [exponentiation]
+
+See also: [square_root]
diff --git a/st_reachability_undirected b/st_reachability_undirected
@@ -0,0 +1,9 @@
+# Undirected st-reachability
+
+Given an [undirected_graph] and two [vertices] s and t, decide if there is an [undirected_path] between s and t
+
+[Complete] for [SL]
+
+Up: [st_reachability]
+
+Aliases: undirected st-reachability
diff --git a/star_free_language b/star_free_language
@@ -0,0 +1,18 @@
+# Star free language
+
+## Definitions
+
+- Language that can be defined from letters, empty set, empty word, and [boolean_operations] ([union], [intersection], [complement]) and [concatenation] but not [kleene_star]
+- [aperiodic] [syntactic_monoid]
+- characterization based on loops in the [automata] ([automaton_counter_free])
+ - can always tested on the minimal automata ([automaton_minimization])
+
+## Subclass
+
+- [unambiguous_star_free_language]
+
+See also: [star_height], [generalized_star_height], [first_order_logic], [kleene_star], [regular_expression_star_free], [schutzenbergers_theorem], [automaton_counter_free]
+
+Up: [regular_language_family]
+
+Aliases: star free languages
diff --git a/state b/state
@@ -0,0 +1,8 @@
+# State
+
+An [automaton] consists of a set of states, which is generally finite.
+
+- [initial_state]
+- [final_state]
+
+Up: [automata_concepts]
diff --git a/state_set_simulation_faster b/state_set_simulation_faster
@@ -0,0 +1,24 @@
+# State set simulation faster
+
+idea: decompose [thompson_automaton] into a tree of small [TNFAs]
+- two [TNFAs] overlap in at most two states
+- do [state_set_simulation] inside each [TNFA] twice: [state_set_simulation_tabulation]
+ - uses the fact that each simple path has at most one back-edge to say that doing it twice suffices
+(myers1992, bille2006)
+
+## Word-level parallelism
+
+other idea: word-level parallelism, reading a block that corresponds to a machine word
+- main problem: epsilon transitions
+
+idea: separator that splits [TNFA] in two halves of roughly equal size such that paths have to go through the separator
+
+[bille2010regular]
+
+Limits: cannot do better than Omega(nm/w) for w the word size
+
+Can go faster: [bille2009faster], divided by log^{1.5}, 4 traversals over the [TNFAs]
+
+"2D Decomposition algorithm"
+
+Up: [state_set_simulation], [log_shaving]
diff --git a/steiner_tree b/steiner_tree
@@ -0,0 +1,7 @@
+# Steiner tree
+
+Given an unordered [graph] ([graph_weighted]), and a subset of terminal vertices, find a [tree] of minimal weight that includes all the terminals
+
+See also: [spanning_tree], [directed_steiner_forest], [feldman2006directed], [directed_steiner_network]
+
+Up: [algorithm] on [graph]
diff --git a/stochastic_boolean_function_evaluation b/stochastic_boolean_function_evaluation
@@ -0,0 +1,7 @@
+# Stochastic Boolean Function Evaluation
+
+Problem "SBFE" (Stochastic Boolean Function Evaluation): evaluate a known Boolean function on an unknown input, where you have a probability distribution on the inputs and can uncover each input by paying a certain cost
+
+Recent paper [hellerstein2022adaptivity]
+
+Up: [boolean_function]
diff --git a/strahler_number b/strahler_number
@@ -0,0 +1,7 @@
+# Strahler number
+
+https://en.wikipedia.org/wiki/Strahler_number
+
+Up: [parameter] on [tree]
+
+See also: [cantor_bendixson_rank]
diff --git a/straight_line_program b/straight_line_program
@@ -0,0 +1,10 @@
+# Straight line program (SLP)
+
+essentially a [context_free_grammar] that generates a single [string]: [acyclicity] requirement plus only one [production] per [nonterminal]
+
+- [enumeration_slp]
+- [smallest_grammar_problem]
+
+Up: [string_compression]
+
+See also: [forest_straight_line_program]
diff --git a/strassens_algorithm b/strassens_algorithm
@@ -0,0 +1,10 @@
+# Strassen's algorithm
+
+https://en.wikipedia.org/wiki/Strassen_algorithm
+
+multiplication of 2 by 2 matrices can be done with 7 products instead of 8
+- gives an algorithm because you can reapply it recursively
+
+works with integers, but not with [matrix_boolean] in [boolean_semiring]
+
+Up: [matrix_multiplication]
diff --git a/streaming b/streaming
@@ -0,0 +1,15 @@
+# Streaming
+
+- sequence of data items arrives one item after the other
+ - specific kind of [update_word] when you can only append to the right
+ - particular case of [sliding_window], in which you can also pop at the right
+- [enumeration_streaming]
+- [dynamic_membership_streaming] discussed in [ganardi2024regular]
+
+also work on [sampling], [distinct_element], etc.
+
+- possible variants:
+ - are results produced immediately, or only at the end of the stream?
+ - is the stream length bounded? is it known in advance?
+
+Up: [algorithms]
diff --git a/strong_exponential_time_hypothesis b/strong_exponential_time_hypothesis
@@ -0,0 +1,7 @@
+# Strong Exponential Time Hypothesis (SETH)
+
+In the vocabulary of [exponential_time_hypothesis] it claims that lim_k s_k = 1
+
+Up: [exponential_time_hypothesis]
+
+Aliases: SETH
diff --git a/strong_perfect_graph_theorem b/strong_perfect_graph_theorem
@@ -0,0 +1,7 @@
+# Strong perfect graph theorem
+
+https://en.wikipedia.org/wiki/Strong_perfect_graph_theorem
+
+An [undirected_graph] is a [Berge_graph] iff it is a [perfect_graph]
+
+Up: [graph_theorem]
diff --git a/strongly_connected b/strongly_connected
@@ -0,0 +1,8 @@
+# Strongly connected
+
+- [strongly_connected_graph]
+- [strongly_connected_language]
+
+Up: [mathematics]
+
+See also: [connected]
diff --git a/strongly_connected_component b/strongly_connected_component
@@ -0,0 +1,13 @@
+# Strongly connected component
+
+- [Kosaraju's_algorithm]: [algorithm] with two [depth_first_search] with [post_order] numbering
+- [Tarjan's_algorithm]
+
+- [dynamic_strongly_connected_component]
+- [strong_connectivity_augmentation]
+
+Up: [graph]
+
+See also: [biconnected_component], [connected_component], [strongly_connected]
+
+Aliases: SCC
diff --git a/strongly_np_complete b/strongly_np_complete
@@ -0,0 +1,7 @@
+# Strong NP-completeness
+
+[np_complete] even when the input is represented in unary
+
+[strongly_np_complete_list]
+
+Up: [np_complete]
diff --git a/strongly_unimodular b/strongly_unimodular
@@ -0,0 +1,9 @@
+# Strongly unimodular
+
+Matrix which is [totally_unimodular] and any matrix obtained by setting +/-1 entries to 0 is also [totally_unimodular], cf [crama1992decomposition]
+
+equivalent notion in terms of [matrix_base]
+
+ensures that [matrix_ilp] is [integral] and can be solved with [linear_programming]
+
+Up: [matrix]
diff --git a/subfunction b/subfunction
@@ -0,0 +1,7 @@
+# Subfunction
+
+a [boolean_function] obtained from another by setting some variables to specific Boolean values
+
+Up: [boolean_function]
+
+See also: [subsequence], [partial_evaluation]
diff --git a/submodular_maximization b/submodular_maximization
@@ -0,0 +1,9 @@
+# Submodular maximization
+
+[np_hard]
+
+[buchbinder2024deterministic]
+
+Up: [submodular_optimization], [maximization]
+
+See also: [submodular_minimization]
diff --git a/submodular_minimization b/submodular_minimization
@@ -0,0 +1,8 @@
+# Submodular minimization
+
+- [minimization] of [submodular_set_function] is in [ptime]
+- but it is [np_hard] when subject to cardinality constraints
+
+Up: [submodular_optimization], [minimization]
+
+See also: [submodular_maximization]
diff --git a/submodular_optimization b/submodular_optimization
@@ -0,0 +1,8 @@
+# Submodular optimization
+
+https://en.wikipedia.org/wiki/Submodular_set_function#Optimization_problems
+
+- [submodular_minimization]
+- [submodular_maximization]
+
+Up: [optimization]
diff --git a/submodular_set_function b/submodular_set_function
@@ -0,0 +1,12 @@
+# Submodular set function
+
+https://en.wikipedia.org/wiki/Submodular_set_function
+
+function f on sets such that f(X cup {z}) - f(X) >= f(Y cup {z}) - f(Y)
+whenever X \subseteq Y
+
+Implies being [subadditive], converse is not true in general
+
+See also: [submodular_optimization], [concave_function]
+
+Up: [function]
diff --git a/subsequence b/subsequence
@@ -0,0 +1,21 @@
+# Subsequence
+
+- [common_subsequence]
+ - [common_subsequence_automaton]
+ - [longest_common_subsequence]
+ - [maximal_common_subsequence]
+- [common_non_subsequence]
+ - [shortest_common_non_subsequence]
+- [subsequence_testing]
+- [subsequence_embedding]
+- [distinguishing_subsequence]
+ - [shortest_distinguishing_subsequence]
+- [consistent_subsequence]
+- [common_supersequence] [timkovsky1989complexity]
+ - [longest_common_supersequence] [timkovsky1989complexity]
+- [longest_increasing_subsequence]
+- [p_subsequence]
+
+See also: [subword], [sequence], [subword]
+
+Up: [formal_language_theory], [stringology]
diff --git a/subsequence_testing b/subsequence_testing
@@ -0,0 +1,10 @@
+# Subsequence testing
+
+testing if an (entire) word u is a [subsequence] of another word v
+- is in [linear_time] with [greedy_algorithm]
+
+- generalization: [subsequence_testing_gap_constraints]
+
+Up: [computational_problem], [subsequence]
+
+See also: [pattern_matching]
diff --git a/subsequence_testing_gap_constraints b/subsequence_testing_gap_constraints
@@ -0,0 +1,12 @@
+# Subsequence testing gap constraints
+
+[subsequence_testing] with gap constraints
+
+- [day2022subsequences]
+ - gap equalities make problem [NP_complete] (Section 5)
+ - gaps are specified with length intervals and automata given as [DFA]s
+ - with only length constraints, cf [iliopoulos2007algorithms]
+
+Up: [subsequence_testing], [gap_constraints]
+
+See also: [gapped_pattern_matching], [p_subsequence], [gapped_string_indexing]
diff --git a/subset_sum b/subset_sum
@@ -0,0 +1,24 @@
+# Subset sum
+
+given integers S and a target t, can we achieve t exactly as a sum of a subset of elements of S?
+
+[np_complete], admits [pseudo_polynomial_time] algorithm
+ - faster [pseudo_polynomial_time] algorithm: [chen2024improved]
+
+special case: [partition_problem]
+
+[reduction]s:
+- [reduction_sat_subset_sum] from [satisfiability_boolean] on [conjunctive_normal_form]
+- [reduction_3dm_subset_sum] from [3_dimensional_matching]
+
+[algorithms]:
+- [galil1991almost] for dense subset sum
+ - further analysis in [bringmann2021near]
+- [bringmann2017near] which is [randomized_algorithm]
+
+generalization: [all_subset_sums], compute all the sums
+- according to [bringmann2023top], all [pseudo_polynomial_time] algorithms for subset sum actually solve [all_subset_sums]
+
+- [subset_sum_counting]
+
+Up: [decision_problem] on [sum]
diff --git a/subset_sum_counting b/subset_sum_counting
@@ -0,0 +1,11 @@
+# Subset sum counting, aka sharpSubsetSum
+
+[counting_problem] of computing the number of [subset_sum] solutions; it is [sharpP_hard]
+
+Variant: counting the subsets whose sum is at most a value T (not "exactly" T)
+- https://cstheory.stackexchange.com/questions/53767/proving-p-hardness-for-the-number-of-subsets-of-a-set-of-positive-integers-with
+- also [sharpP_hard]
+
+Up: [subset_sum], [counting_problem]
+
+See also: [all_subset_sums]
diff --git a/subword b/subword
@@ -0,0 +1,16 @@
+# Subword
+
+u subword of v means v = xuy
+
+not contiguous, unlike [subsequence]
+
+- [subword_automaton]
+
+- [longest_common_subword] [timkovsky1989complexity]
+- [shortest_common_superword] [timkovsky1989complexity]
+
+Up: [formal_language_theory]
+
+See also: [language_downwards_closed], [subword_universal], [factor], [compressed_subword_problem]
+
+Aliases: subwords
diff --git a/subword_automaton b/subword_automaton
@@ -0,0 +1,13 @@
+# Subword automaton
+
+[Automaton] that accepts the language of the [subwords] of [word]s accepted by another [automaton]
+
+- given an [automaton], can build subword automaton as [automata_nondeterministic]
+ - cf [karandikar2014state] Section 3.1
+- given an [automata], [exponential] blowup to build subword automaton as [automata_deterministic]
+ - already on an alphabet of size 2
+ - cf [karandikar2014state] Section 3.2
+
+Up: [subword]
+
+See also: [subword_universal]
diff --git a/subword_universal b/subword_universal
@@ -0,0 +1,10 @@
+# Subword universal
+
+[automata] where every [word] is a [subword] of an accepted word
+
+can determine in [ptime] if [automata_nondeterministic] is subword-universal
+ - cf [rampersad2009computational] Theorem 12
+
+Up: [universality_automata]
+
+See also: [subword_automaton]
diff --git a/suffix b/suffix
@@ -0,0 +1,13 @@
+# Suffix
+
+- [suffix_tree]
+- [suffix_array]
+- [suffix]
+- [suffix_free_language]
+- [suffix_testable_language]
+
+Up: [formal_language_theory]
+
+See also: [subword], [prefix], [factor]
+
+Aliases: suffixes
diff --git a/superpermutation b/superpermutation
@@ -0,0 +1,21 @@
+# Superpermutation
+
+https://en.wikipedia.org/wiki/Superpermutation
+
+Given a number n, shortest word on alphabet {1, ..., n} containing all permutations as contiguous subsequence, aka "Haruhi problem"
+
+Related problem: [superpattern], shortest permutation on n elements containing all k-element permutation as a [permutation_pattern]
+
+Related notion: [universal_word] (all contiguous factors)
+
+Related notion: shortest word containing all permutations as a [subsequence]
+- discussed here https://mathoverflow.net/questions/165303/shortest-supersequence-of-all-permutations-of-n-elements
+ - on [oeis] https://oeis.org/A062714
+ - article surveying this: https://www.tandfonline.com/doi/full/10.1080/00029890.2021.1835384#d1e3032
+ - lower bound [kleitman1976lower]
+- [conp_hard] to detect, cf [uznanski2015all] by [przemyslaw]
+ - from https://cstheory.stackexchange.com/questions/31559/recognizing-sequences-with-all-permutations-of-1-ldots-n-as-subsequence
+
+Up: [combinatorics]
+
+See also: [universal_random_word], [universal_word], [de_bruijn_sequence]
diff --git a/synchronizing_word b/synchronizing_word
@@ -0,0 +1,7 @@
+# Synchronizing word
+
+- [cerny_conjecture] Cerny's conjecture about the existence of synchronizing words on DFAs
+
+Up: [automata]
+
+See also: [mortal_word], [meeting_time]
diff --git a/syntactic_monoid b/syntactic_monoid
@@ -0,0 +1,7 @@
+# Syntactic monoid
+
+Note that it is a [monoid_ordered]
+
+Up: [monoid]
+
+See also: [syntactic_semigroup], [transition_monoid]
diff --git a/szemeredis_theorem b/szemeredis_theorem
@@ -0,0 +1,11 @@
+# Szemeredi's theorem
+
+https://en.wikipedia.org/wiki/Szemer%C3%A9di%27s_theorem
+
+Finitary formulation: for any number k and density bound delta, there is a N such that every subset of {1, ..., N} of density at least delta contains an [arithmetic_progression] of length k
+
+special case: [roths_theorem]
+
+Up: [theorem] about [arithmetic_progression]
+
+See also: [szemeredi_regularity_lemma]
diff --git a/tape_construction b/tape_construction
@@ -0,0 +1,11 @@
+# Tape construction
+
+[data_structure] for [infix_query] with [DFA] A on [word] w
+
+Gives [rectangular_complexity] O(|A| |w|) in time and space, and O(|Q|) query time
+
+[bojanczyk2009factorization] section 2.2
+
+The complexity is non-optimal, because O(1) instead of O(|Q|) can be achieved with a [data_structure] for [level_ancestor] queries
+
+Up: [tuple_testing_automaton]
diff --git a/tarsis_lemma b/tarsis_lemma
@@ -0,0 +1,5 @@
+# Tarsi's lemma
+
+[theorem] saying that a [minimal_unsatisfiable] formula with n variables has at least n+1 clauses, cf [aharoni1986minimal], aka [clause_variable_difference], cf [szeider2008matched]
+
+Up: [lemma], [minimal_unsatisfiable]
diff --git a/theorem b/theorem
@@ -0,0 +1,39 @@
+# Theorem
+
+A [result] in [mathematics], recognized as challenging to prove
+
+- [Abiteboul_Vianu_theorem]
+- [Brook's_theorem]
+- [Buchi's_theorem]
+- [Chen's_theorem]
+- [Context_free_grammar_pushdown_automaton_equivalence]
+- [Courcelle_theorem]
+- [Eggan's_theorem]
+- [Four_color_theorem]
+- [Fine_Wilf_theorem]
+- [fpras_bpp]
+- [friendship_theorem]
+- [Goedel's_incompleteness_theorem]
+- [Grotzsch's_theorem]
+- [Hall's_theorem]
+- [Immerman_Szelepcsenyi_theorem]
+- [Immerman_Vardi_theorem]
+- [Koenig's_theorem]
+- [Ladner's_theorem]
+- [Mantel's_theorem]
+- [Menger's_theorem]
+- [Parikh's_theorem]
+- [Prime_number_theorem]
+- [Ramsey_theorem]
+- [Roths_theorem]
+- [Savitch's_theorem]
+- [Schnyder's_theorem]
+- [Sipser_lautemann_theorem]
+- [Szemeredi's_theorem]
+- [Time_hierarchy_theorem]
+- [Turan_theorem]
+- [Wiles_theorem]
+
+Up: [mathematics]
+
+See also: [automated_theorem_proving], [theoremkb]
diff --git a/theoretical_computer_science b/theoretical_computer_science
@@ -0,0 +1,47 @@
+# Theoretical computer science
+
+## Fields
+
+- [logic], [finite_model_theory]
+- [automated_theorem_proving]
+- [formal_language_theory]
+- [circuit]
+ - [probabilistic_circuit]
+ - [circuit_complexity]
+- [computational_complexity]
+ - [communication_complexity]
+ - [lower_bounds]
+- [constraint_satisfaction_problem]
+- [typing_theory]
+- [descriptive_complexity]
+- [database_theory]
+- [graph_theory]
+- [stringology]
+
+## Concepts
+
+- [data_structure]
+- [boolean_function]
+- [ram_model]
+- [turing_machine]
+
+## Resources
+
+- cours "A Theorist's Toolkit" with tools that are useful when doing theoretical computer science http://www.cs.cmu.edu/~odonnell/toolkit13/
+- agregator https://cstheory-feed.org/
+ - list of [blog] https://rjlipton.wpcomstaging.com/2022/01/26/a-list-of-most-theory-blogs/
+- descriptive resources https://cstheory.stackexchange.com/questions/36436/where-to-learn-more-about-what-theoretical-computer-science-is
+- wigderson2019mathematics
+
+## Questions
+
+- [balancing]
+- [optimization]
+- [unique_games_conjecture]
+
+## Algorithms
+
+- [sieve_of_eratosthenes]
+- [euclidean_algorithm] for [greatest_common_divisor]
+
+Up: [formal_science], [research_fundamental] of [computer_science]
diff --git a/thompson_automaton b/thompson_automaton
@@ -0,0 +1,15 @@
+# Thompson automaton
+
+construction to transform [regular_expression] to [automata_nondeterministic] with [epsilon_transition]
+
+properties:
+- [states] with an incoming character transition have exactly one [predecessor]
+- almost a [series_parallel_graph], except for [kleene_star]
+- almost a [DAG], except for [kleene_star]:
+ - any cycle-free path has at most one back-edge
+
+Up: [conversion_automata]
+
+See also: [glushkov_automaton]
+
+Aliases: thompson's automaton, TNFA, TNFAs
diff --git a/three_variable_per_inequality b/three_variable_per_inequality
@@ -0,0 +1,5 @@
+# Three variable per inequality
+
+[hochbaum2002solving]
+
+Up: [two_variable_per_inequality]
diff --git a/topk b/topk
@@ -0,0 +1,5 @@
+# Topk
+
+- [ranking_function]
+
+See also: [ranked_access], [enumeration_ordered]
diff --git a/topological_minor b/topological_minor
@@ -0,0 +1,11 @@
+# Topological minor
+
+[graph_minor] with a [topological_embedding]
+
+[graph_minor] and topological minors are equivalent if the minor is [graph_cubic]
+
+Up: [graph_minor]
+
+See also: [excluded_topological_minor], [subdivision]
+
+Aliases: topological minors
diff --git a/total_dominating_set b/total_dominating_set
@@ -0,0 +1,7 @@
+# Total dominating set
+
+Subset of a graph such that every vertex is adjacent to a vertex of the set
+
+Does not always exist.
+
+Up: [dominating_set]
diff --git a/total_variation_distance b/total_variation_distance
@@ -0,0 +1,6 @@
+# Total variation distance
+
+For two distributions mu1 and mu2 over Omega, the total variation distance is
+||mu1 - mu2||_{TV} = (1/2) \sum_{X in Omega} |mu1(X) - mu2(X)|
+
+Up: [probability]
diff --git a/transition b/transition
@@ -0,0 +1,9 @@
+# Transition
+
+A transition in an [automaton] goes from a [state] to another and is labeled by a [letter]. For [transducers], the transition can be labeled with an [input_letter] and an [output_letter]
+
+- [epsilon_transition]
+
+Up: [automata_concepts]
+
+Aliases: transitions
diff --git a/transitivity b/transitivity
@@ -0,0 +1,6 @@
+# Transitivity
+
+- [transitivity_tgds]
+- [transitive_closure]
+
+Up: [mathematics]
diff --git a/transitivity_tgds b/transitivity_tgds
@@ -0,0 +1,10 @@
+# Transitivity TGDs
+
+Results on transitivity:
+
+- amarilli2018query
+- andrew2021guarded, which discusses amarilli2018query in detail
+- baget2015combining, problem with a weird condition for transitivity plus [linear_rules] ([existential_rule])
+ - question: link to feller2022finite?
+
+Up: [transitivity] for [open_world_query_answering]
diff --git a/tree_automaton b/tree_automaton
@@ -0,0 +1,23 @@
+# Tree automaton
+
+Defines [regular_tree_language]
+
+## Types
+
+- [tree_automaton_bottom_up]
+- [tree_automaton_top_down]:
+ - [automata_deterministic] leads to a weaker class of languages
+ - [unambiguous]: is the same as unambiguous bottom-up (the unambiguity condition is symmetric)
+
+## Variants
+
+Also [dag_automaton] DAG-automaton
+https://codeberg.org/yvomeeres/pubs/raw/branch/draft/dag-draft.pdf
+and [jumping_automata_on_graphs] jumping automata on graphs
+
+- [tree_automaton_infinite]
+- [counter_automata_trees]
+
+Up: [automata] on [tree]
+
+See also: [dtd], [xml]
diff --git a/tree_decomposition b/tree_decomposition
@@ -0,0 +1,9 @@
+# Tree decomposition
+
+- [tree_decomposition_computing]
+- [tree_decomposition_updating]
+- [balancing_tree_decomposition]
+
+See also: [treewidth]
+
+Up: [tree]
diff --git a/tree_language b/tree_language
@@ -0,0 +1,7 @@
+# Tree language
+
+- [regular_tree_language]
+
+Up: [formal_language] of [tree]
+
+Aliases: tree languages
diff --git a/treelike b/treelike
@@ -0,0 +1,11 @@
+# Treelike
+
+"of bounded [treewidth]"
+
+- [treelike_data]
+
+## Generalization
+
+- [treelike_modulo_homomorphic_equivalence]
+
+Up: [treewidth]
diff --git a/treelike_modulo_homomorphic_equivalence b/treelike_modulo_homomorphic_equivalence
@@ -0,0 +1,7 @@
+# Treelike modulo homomorphic equivalence
+
+Means having bounded [treewidth] modulo [homomorphic_equivalence]
+
+Up: [treelike]
+
+See also: [grohe2007complexity]
diff --git a/treewidth_directed b/treewidth_directed
@@ -0,0 +1,10 @@
+# Treewidth (directed)
+
+directed treewidth, when it is bounded then the k-[disjoint_paths] problem is tractable, cf [kawarabayashi2022directed]
+
+[kawarabayashi2022directed] shows that a [graph_directed] with high directed treewdith contains a [directed_grid] as [butterfly_minor]
+- polynomial bounds known [hatzel2019polynomial]
+
+Up: [treewidth]
+
+See also: [pathwidth_directed], [grid_minor_directed]
diff --git a/treewidth_practical b/treewidth_practical
@@ -0,0 +1,7 @@
+# Treewidth practical
+
+- [senellart], [silviu]: [silviu2019experimental]
+- [marx2020four]
+- practical works such as [goharshady2020efficient]
+
+Up: [treewidth]
diff --git a/triangle b/triangle
@@ -0,0 +1,18 @@
+# Triangle
+
+- [triangle_detection]
+ - unbalanced triangle detection
+- [triangle_listing]
+- [triangle_counting]
+ - [triangle_counting_incremental]
+- [provenance_triangle]
+
+Variante: single-source triangle counting ?
+
+- [sparse_triangle]
+
+See also: [matrix_multiplication], [ov_conjecture], [negative_triangle], [exact_triangle], [triangle_free_graph], [triangle_inequality]
+
+Up: [graph]
+
+Aliases: triangles
diff --git a/triangle_counting b/triangle_counting
@@ -0,0 +1,5 @@
+# Triangle counting
+
+- [triangle_counting_incremental]
+
+Up: [graph_pattern_counting] of [triangle]
diff --git a/triangle_detection_conjecture b/triangle_detection_conjecture
@@ -0,0 +1,6 @@
+# Triangle detection conjecture
+
+- [sparse_triangle_hypothesis]: asserts that for [graph_sparse] you cannot do O(m^{4/3-delta}) for any delta>0
+- [dense_triangle_hypothesis]: asserts that for [graph_dense] you cannot do O(n^{omega-delta}) for any delta>0
+
+Up: [computational_hypothesis] on [triangle_detection]
diff --git a/triangle_free_graph b/triangle_free_graph
@@ -0,0 +1,9 @@
+# Triangle free graph
+
+They are known to have unbounded [chromatic_number]
+
+[Mantel's_theorem] gives bounds on their size
+
+[computational_problem] of recognizing them: see [triangle_detection]
+
+Up: [triangle], [graph]
diff --git a/triangle_inequality_strong b/triangle_inequality_strong
@@ -0,0 +1,5 @@
+# Triangle inequality strong
+
+forall xyz, d(x,y) <= max(d(x,z), d(z,y))
+
+Up: [triangle_inequality]
diff --git a/trio b/trio
@@ -0,0 +1,5 @@
+# Trio
+
+Like [universal_semiring] but without exponents
+
+Up: [semiring_list]
diff --git a/tuple_generating_dependency_sticky b/tuple_generating_dependency_sticky
@@ -0,0 +1,7 @@
+# Sticky TGDs
+
+introduced in [cali2010advanced]
+
+Up: [tuple_generating_dependency]
+
+Aliases: sticky TGD, sticky TGDs, TGD sticky, TGDs sticky
diff --git a/turan_theorem b/turan_theorem
@@ -0,0 +1,11 @@
+# Turan theorem
+
+https://en.wikipedia.org/wiki/Tur%C3%A1n%27s_theorem
+
+Maximal number of edges in [graph_undirected] without having a [clique] of a given size
+
+Special case: [mantels_theorem]
+
+Proof seems rather elementary
+
+Up: [ramsey_turan_theory]
diff --git a/turing_machine b/turing_machine
@@ -0,0 +1,24 @@
+# Turing machine
+
+## Complexity of problems in this [machine_model]
+
+[petersen2008sorting]: bounds on complexity of [sorting]
+- [turing_machine_deterministic] vs [turing_machine_nondeterministic]
+- one or more work [tape]s (and read-only input)
+
+## Types
+
+- [turing_machine_nondeterministic]
+- [turing_machine_deterministic]
+
+## Variants
+
+- [turing_machine_symmetric]
+
+## Resources
+
+- turingmachinesimulator.com by [martin_ugarte]
+
+Up: [theoretical_computer_science]
+
+See also: [ram_model], [church_turing_thesis], [alan_turing], [pushdown_automaton], [turing_complete], [decidability], [recursively_enumerable], [kolmogorov_complexity]
diff --git a/turing_machine_nondeterministic b/turing_machine_nondeterministic
@@ -0,0 +1,7 @@
+# Turing machine nondeterministic
+
+- [nptime]: [nondeterministic_ptime_turing_machine]
+
+Up: [turing_machine]
+
+Aliases: nondeterministic Turing machine
diff --git a/turing_reduction b/turing_reduction
@@ -0,0 +1,11 @@
+# Turing reduction
+
+[reduction] which uses target problem as [oracle]
+
+- "Cook reduction" : Turing reduction which is [ptime_reduction]
+
+Not always very different from [many_one_reduction] for [counting_problem], cf argument https://dbt.zulipchat.com/#narrow/stream/417238-Dagstuhl-24032/topic/Open.20problems/near/425331364
+
+Up: [reduction]
+
+See also: [alan_turing], [many_one_reduction]
diff --git a/tuzas_conjecture b/tuzas_conjecture
@@ -0,0 +1,7 @@
+# Tuza's conjecture
+
+https://en.wikipedia.org/wiki/Tuza%27s_conjecture
+
+[Conjecture] about [graph_packing] of [triangle]s
+
+Up: [graph_packing]
diff --git a/twin_width b/twin_width
@@ -0,0 +1,27 @@
+# Twin width
+
+[twin_width_definition]
+
+Recent generalization (2023-02): [flip_width]
+
+- for [model_counting]: [ganian2022weighted]
+
+- for [enumeration]: [gajarsky2022twin]
+
+- recognition:
+ - deciding whether the twin-width is at most 4 is [np_hard]
+ - graphs of twin-width 0 or 1 can be identified i [ptime]
+
+- [tree] has twin-width at most 2
+ - so twin-width is at most 2 plus the [feedback_edge_number]
+
+- incomparable with [nowhere_dense]
+- capture [excluded_minor] and bounded [cliquewidth]
+
+guarantees that [first_order_model_checking] is [fixed_parameter_tractable] if the merge sequence is provided
+
+[twin_width_ordered]
+
+Up: [width_measure]
+
+See also: [nowhere_dense]
diff --git a/two_variable_per_inequality b/two_variable_per_inequality
@@ -0,0 +1,12 @@
+# Two variable per inequality (TVPI)
+
+- [unit_two_variable_per_inequality] (UTVPI)
+- [monotone_two_variable_per_inequality] (monotone TVPI)
+
+[ILP] is [np_complete] for this class according to [devlas2024complexity]
+
+Generalization: [three_variable_per_inequality]
+
+Up: [integer_linear_programming]
+
+Aliases: TVPI
diff --git a/two_way_string_matching b/two_way_string_matching
@@ -0,0 +1,7 @@
+# Two-way string matching
+
+https://en.wikipedia.org/wiki/Two-way_string-matching_algorithm
+
+Up: [algorithm] for [pattern_matching]
+
+Aliases: Crochemore-Perrin algorithm, Crochemore Perrin algorithm, two way string matching algorithm, two-way string matching algorithm
diff --git a/uc2rpq b/uc2rpq
@@ -0,0 +1,9 @@
+# UC2RPQ
+
+union of [c2rpq]
+
+- [feier2024evaluating]: article on [treewidth]
+
+- [semantic_acyclicity]
+
+Up: [graph_query_languages], [c2rpq], [union_of_conjunctive_queries]
diff --git a/ucq_non_redundant b/ucq_non_redundant
@@ -0,0 +1,7 @@
+# UCQ non redundant
+
+A [UCQ] where no constituent [CQ] implies another [CQ]
+
+Up: [union_of_conjunctive_queries]
+
+See also: [minimization_conjunctive_query], [query_containment]
diff --git a/ultrametric b/ultrametric
@@ -0,0 +1,5 @@
+# Ultrametric
+
+[metric] satisfying [triangle_inequality_strong]
+
+Up: [distance]
diff --git a/unambiguity b/unambiguity
@@ -0,0 +1,35 @@
+# Unambiguity
+
+An [automata] is unambiguous if every word that it accepts has at most one accepting run. In particular see [word_automaton_unambiguous]
+
+## Generalization
+
+- [k_ambiguous] [automata]
+ - comparison between different types of ambiguity: [ravikumar1989relating]
+- [unambiguity_alternating]
+
+## Variants
+
+- "strongly unambiguous" automaton: an automaton that can be used both an as unambiguous automaton for the language and as an unambiguous automaton for the [complement]: defined in [colcombet2012forms]
+
+## Separation
+
+- Exponential separation between unambiguous automaton and [automata_nondeterministic]: section 3 of [leung2005descriptional] ([communication_complexity] method)
+
+pas de conversion polynomiale de 2-UFA vers [unambiguous_finite_automaton] par [goos2021lower]
+- mais on peut compter les mots acceptés par un k-UFA à k constant par
+ [stearns1985equivalence]
+
+## Types
+
+- [unambiguous_star_free_language]
+
+## For [context_free_language]
+
+- [context_free_grammar_unambiguous]
+
+## For other problems
+
+- [satisfiability_unambiguous]
+
+See also: [ddnnf], [unambiguous]
diff --git a/unambiguity_alternating b/unambiguity_alternating
@@ -0,0 +1,7 @@
+# Unambiguity for alternating automata
+
+https://cstheory.stackexchange.com/questions/54575/definition-of-unambiguity-in-alternating-finite-automata
+
+Some notions are in [jantsch2021from]
+
+Up: [unambiguity], [automata_alternating]
diff --git a/unambiguous b/unambiguous
@@ -0,0 +1,10 @@
+# Unambiguous
+
+- [unambiguous_language]
+- [unambiguous_complement]
+- [unambiguous_polynomial]
+- [unambiguous_marked_product]
+- [unambiguous_star_free_language]
+- [word_automaton_unambiguous]
+
+See also: [unambiguity]
diff --git a/unambiguous_marked_product b/unambiguous_marked_product
@@ -0,0 +1,7 @@
+# Unambiguous_marked_product
+
+A [marked_product] which is [unambiguity] in the sense that there is a unique decomposition
+
+[unambiguous_language] formed of these
+
+Up: [marked_product], [unambiguity]
diff --git a/unambiguous_star_free_language b/unambiguous_star_free_language
@@ -0,0 +1,12 @@
+# Unambiguous star-free language
+
+Described in [mathematical_foundations_of_automata_theory]
+
+- Base case: languages B^* for B a subalphabet of the alphabet
+- Closed under [union] and [unambiguous_marked_product]
+
+Algebraic characterizations
+
+Up: [star_free_language], [unambiguity]
+
+See also: [generalized_star_height]
diff --git a/unambiguous_word_automaton_complementation b/unambiguous_word_automaton_complementation
@@ -0,0 +1,9 @@
+# Unambiguous word automaton complementation
+
+[raskin2018superpolynomial], [goos2021lower]
+
+problem of finding assignment of maximal weight that satisfies complement of UFA https://cstheory.stackexchange.com/questions/48815/is-this-problem-on-unambiguous-finite-automata-np-complete
+
+Up: [word_automaton_unambiguous], [automata_complementation]
+
+See also: [disjuntive_normal_form_orthogonal_negation]
diff --git a/union b/union
@@ -0,0 +1,6 @@
+# Union
+
+- [union_trick]
+- [disjoint_union]
+
+Up: [set_theory], [boolean_operator]
diff --git a/union_of_conjunctive_queries b/union_of_conjunctive_queries
@@ -0,0 +1,15 @@
+# Union of conjunctive queries (UCQ)
+
+[disjunction] of [conjunctive_query] that all have the same [free_variables]
+
+[ucq_to_cq]: techniques to replace UCQs by CQs in hardness proofs
+
+special case: [hk_queries]
+
+[UCQ_non_redundant]
+
+Up: [query_language]
+
+See also: [uc2rpq]
+
+Aliases: union of conjunctive query, UCQ, UCQs
diff --git a/universal_semiring b/universal_semiring
@@ -0,0 +1,10 @@
+# Universal semiring
+
+N[X], [semiring] of [polynomial]s with [variable]s X
+
+- [universality_property]
+- [commutation_under_homomorphism]s
+
+Up: [semiring_list]
+
+See also: [power_series]
diff --git a/universal_word b/universal_word
@@ -0,0 +1,7 @@
+# Universal word
+
+[chen2017universal]
+
+[word] containing all words of length n exactly once as contiguous [subword]
+
+See also: [superpermutation], [random_universal_word], [de_bruijn_sequence], [universal_tree]
diff --git a/universality_automata b/universality_automata
@@ -0,0 +1,13 @@
+# Universality automata
+
+[computational_problem]: test if [automata] accepts every possible [word]
+
+- [universality_automata_nondeterministic]: [conp_complete]
+- [universality_automata_deterministic]: [ptime]
+
+- [factor_universal]
+- [subword_universal]
+
+Up: [computational_problem], [automata]
+
+See also: [totality], [validity], [taulology]
diff --git a/universality_automata_deterministic b/universality_automata_deterministic
@@ -0,0 +1,7 @@
+# Universality automata deterministic
+
+in [ptime] via [automaton_complementation]
+
+Up: [universality_automata], [automaton_deterministic]
+
+Aliases: DFA universality
diff --git a/universality_automata_nondeterministic b/universality_automata_nondeterministic
@@ -0,0 +1,8 @@
+# Universality automata nondeterministic
+
+[conp_complete] even on [unary_alphabet]:
+- https://cs.stackexchange.com/a/97751
+
+Up: [universality_automata], [automata_nondeterministic]
+
+Aliases: NFA universality
diff --git a/up b/up
@@ -0,0 +1,12 @@
+# UP
+
+https://complexityzoo.net/Complexity_Zoo:U#up
+
+[unambiguous] [nondeterministic] [ptime], i.e., there is a [nondeterministic_ptime_turing_machine] such that:
+
+- on negative instances, all [runs] are rejecting
+- on positive instances, exactly one [run] accepts
+
+Generalization: [FewP]
+
+Up: [nptime], [unambiguity], [complexity_class]
diff --git a/update b/update
@@ -0,0 +1,21 @@
+# Update
+
+Kinds of updates supported for [dynamic_data]:
+
+- For [dynamic_data_tree]: [update_tree]
+- For [dynamic_data_word]: [update_word]
+ - [substitution]
+ - [insertion]
+ - [deletion]
+- For [dynamic_data_graph]: [update_graph]
+ - [edge_addition]
+ - [edge_deletion]
+- In general
+ - [relabeling]
+ - [insertion]
+ - [deletion]
+ - [fully_dynamic]
+
+See also: [batch_updates]
+
+Up: [dynamic_data]
diff --git a/update_word b/update_word
@@ -0,0 +1,12 @@
+# Update word
+
+- [insertion]
+- [substitution]
+- [deletion]
+- [push_pop], cf [deque]
+- [push_operation] on one side and [pop_operation] on the other
+ - cf [queue]
+ - cf [sliding_window]
+- [word_split]: related to [cut_and_paste]
+
+Up: [update] for [word]
diff --git a/van_emde_boas_tree b/van_emde_boas_tree
@@ -0,0 +1,9 @@
+# Van Emde Boas tree
+
+[fully_persistent] and generalization
+https://dl.acm.org/doi/abs/10.1145/2483699.2483702?casa_token=ev35wNcpOZkAAAAA:yriGm4Tcy1xmJeiSZcCg6WToRRv2rtA0htk15dAuzAhJkNpFkAGQ0aAYZpWG17gz-KYcOWD1sOgiCg
+- used for [twin_width] in [gajarsky2022twin]
+
+- used for [predecessor_problem] and [colored_predecessor]
+
+Up: [tree]
diff --git a/vardi1989note b/vardi1989note
@@ -0,0 +1,7 @@
+# Vardi1989note
+
+Explains [conversion_automata] of [automata_two_way] into a one-way [automata_nondeterministic]
+
+Up: [academic_paper] about [automata_two_way]
+
+See also: [vardi]
diff --git a/variety b/variety
@@ -0,0 +1,35 @@
+# Variety
+
+## Variety of formal language
+
+Variety of [formal_language]s is closed under:
+- [Derivative]
+- [Boolean_operator]s ([union], [intersection], [complementation])
+ - maybe not [complementation] in which case it is a [positive_variety]
+- and [inverse_morphism]
+
+## Variety of [monoid]
+
+Variety of [monoid] is closed under [direct_product], [quotient], and [submonoid]
+
+## Variety of [semigroup]
+
+We can impose that some elements in [equation]s are not mapped to the [neutral_element]
+- cf [non_erasing_morphism]
+
+## Variety of [stamp]s
+
+- cf [length_preserving_morphism]
+
+## Examples
+
+- [da]
+
+## Types of variety
+
+- [Positive_variety]
+- [Variety_Li]
+
+Up: [algebraic_automata_theory]
+
+Aliases: varieties
diff --git a/vector_addition_tree_automata b/vector_addition_tree_automata
@@ -0,0 +1,5 @@
+# Vector addition tree automata
+
+Defined in [degroote2004vector]
+
+Up: [vector_addition_system], [tree_automaton]
diff --git a/vector_space b/vector_space
@@ -0,0 +1,6 @@
+# Vector space
+
+- [subspace]
+- [dimension]
+
+Up: [algebra]
diff --git a/vertex b/vertex
@@ -0,0 +1,9 @@
+# Vertex
+
+Also called a "node"
+
+Up: [graph_basic_notions]
+
+Aliases: vertices
+
+See also: [edge]
diff --git a/vertex_cover b/vertex_cover
@@ -0,0 +1,33 @@
+# Vertex cover
+
+A vertex cover in a [graph] is a subset of vertices such that every edge is incident to at least one vertex of the subset.
+
+[linear_relaxation]: [fractional_vertex_cover]
+- and [dual]: [fractional_edge_packing]
+
+## Variants
+
+- [minimum_vertex_cover]
+- [minimal_vertex_cover]
+
+## [approximation]
+
+- [vertex_cover_approximation]
+
+## [computational_problem]
+
+- [minimum_vertex_cover]
+
+## [theorem]s
+
+- [koenigs_theorem] in [graph_bipartite]
+
+## Connections
+
+- A vertex cover is at least as large as a [maximum_matching], because each edge in the matching must be covered by a vertex and these vertices must be different for each edge.
+ - [koenigs_theorem]: on [graph_bipartite] they are equal
+- The [complement] of a vertex cover is an [independent_set] so [minimum_vertex_cover] corresponds to [maximal_independent_set]
+
+See also: [edge_cover], [vertex_packing], [independent_set], [hitting_set], [set_cover]
+
+Up: [graph_substructure]
diff --git a/vertex_unbalanced_triangle_listing b/vertex_unbalanced_triangle_listing
@@ -0,0 +1,9 @@
+# Vertex unbalanced triangle listing
+
+in [bringmann2022unbalanced]
+
+Implied by [3sum_conjecture]
+
+Up: [triangle_listing]
+
+Aliases: VUTL
diff --git a/visibly_pushdown_automaton b/visibly_pushdown_automaton
@@ -0,0 +1,9 @@
+# Visibly pushdown automaton
+
+[dymond1988input]
+
+Up: [pushdown_automaton]
+
+See also: [tree_automaton]
+
+Aliases: VPA, VPAs, visibly pushdown automata, input driven automaton, input driven automata, input-driven automaton, input-driven automata
diff --git a/vizings_theorem b/vizings_theorem
@@ -0,0 +1,9 @@
+# Vizing's theorem
+
+https://en.wikipedia.org/wiki/Vizing%27s_theorem
+
+If a [graph_undirected] has [maximal_degree] d then it can be [edge_colored] with at most d+1 colors
+
+Up: [theorem] on [edge_coloring]
+
+See also: [graph_coloring_greedy]
diff --git a/walk b/walk
@@ -0,0 +1,13 @@
+# Walk
+
+A [path] where [vertices] and [edges] can freely repeat
+
+- [walk_length]
+- [random_walk]
+- [no_meet]
+
+Up: [graph_basic_notions]
+
+See also: [tree_walking_automaton]
+
+Aliases: walks
diff --git a/walk_length b/walk_length
@@ -0,0 +1,17 @@
+# Walk length
+
+Given [graph_directed], G, [source] s, [sink] t, length l, decide if there is a [walk] from s to t with length exactly l
+
+- if l is constant then the problem is clearly tractable
+- if l is given as input in unary, the problem is tractable by creating l copies of G
+ - O(l |G|)
+ - [fine_grained_complexity] bounds, cf [nfa_unary_lengths]
+- if l is given in binary, the problem is [ptime] by [fast_exponentiation] to get the possible lengths of [walk]s in log l
+ - O(log l |G|)
+- if the edges of G can be annotated with lengths also written in binary
+ - [np_hard] by reduction from [subset_sum]
+ - in [np] by [basagni1997difficulty] using [eulerian_path]
+
+See also: [path_length], [nfa_unary_lengths]
+
+Up: [computational_problem] on [graph]
diff --git a/wang2024sampling b/wang2024sampling
@@ -0,0 +1,9 @@
+# Wang2024sampling
+
+uses [degree_constraints]
+
+for [sampling_subgraph], [preprocessing] on the [graph], independently on the pattern to sample
+
+algorithm for [optimal_joins_sampling] with [degree_constraints_acyclic] recaptured by [capelli2024simple]
+
+Up: [academic_paper] on [sampling_subgraph] and [optimal_joins_sampling]
diff --git a/weft b/weft
@@ -0,0 +1,7 @@
+# Weft
+
+largest number of "large gates" ([fanin] at least 3) from any path from a variable gate to the output gate https://simonrey.fr/static/talks/PCT_Hardness.pdf
+
+Up: [circuit_parameter]
+
+See also: [height], [depth], [w1]
diff --git a/wiles_theorem b/wiles_theorem
@@ -0,0 +1,19 @@
+# Wiles's theorem
+
+also "Fermat's last theorem"
+
+Stated with positive integers, but can also be shown for negative integers
+
+Variant with polygonal/polyhedral numbers:
+- https://en.m.wikipedia.org/wiki/Fermat_polygonal_number_theorem
+- https://en.m.wikipedia.org/wiki/Pollock%27s_conjectures
+
+Generalizations:
+- https://en.m.wikipedia.org/wiki/Beal_conjecture
+- https://en.m.wikipedia.org/wiki/Fermat%E2%80%93Catalan_conjecture
+- https://en.m.wikipedia.org/wiki/Lander,_Parkin,_and_Selfridge_conjecture
+- https://en.m.wikipedia.org/wiki/Euler%27s_sum_of_powers_conjecture#k_=_3
+
+Up: [mathematics], [number_theory]
+
+See also: [sum_of_powers]
diff --git a/word b/word
@@ -0,0 +1,24 @@
+# Word
+
+Finite [sequence] of [letter]
+
+- [primitive_word]
+- [twin]
+
+generalization:
+- [data_word]
+
+operation:
+- [concatenation]
+- [primitive_root]
+- [mirror]
+
+type:
+- [palindrome]
+- [square_word]
+
+Up: [formal_language_theory]
+
+See also: [update_word], [empty_word], [sequence], [dynamic_word]
+
+Aliases: words
diff --git a/word_automaton b/word_automaton
@@ -0,0 +1,28 @@
+# Word automata
+
+- [word_automaton_unambiguous]
+ - [word_automaton_self_verifying]
+- [automata_nondeterministic]
+- [automata_bideterministic]
+ - [automata_reversible]
+- [automata_probabilistic]
+- [counter_automata]
+- [automata_weighted]
+
+conciseness bounds between [automata_two_way] 2NFA and 1NFA, [automata_alternating] alternating or not, etc?
+
+[word_automata_taxonomy]
+
+problems:
+
+- [automaton_minimization]
+- [language_inclusion]
+- [language_equivalence]
+- [universality_automata]
+- [formal_language_separation]
+
+Up: [automata]
+
+See also: [word_problem]
+
+Aliases: word automata
diff --git a/word_automaton_exclusive_unary b/word_automaton_exclusive_unary
@@ -0,0 +1,5 @@
+# Word automaton exclusive unary
+
+cf [kutrib2024complexity]
+
+Up: [word_automaton_exclusive], [automata_unary]
diff --git a/word_automaton_unambiguous b/word_automaton_unambiguous
@@ -0,0 +1,16 @@
+# Unambiguous word automata
+
+[inclusion], [equivalence] are in P [ptime] (even NC [nc]?) whereas they are [pspace] PSPACE-c for
+[word_automaton_nondeterministic]
+
+More restricted definition: [word_automaton_self_verifying]
+
+Variant: [word_automaton_exclusive]
+
+[unambiguous_word_automaton_complementation]
+
+Up: [word_automaton], [unambiguity]
+
+See also: [word_automaton_finitely_ambiguous], [word_automaton_polynomially_ambiguous]
+
+Aliases: UFA, UFAs, unambiguous word automaton
diff --git a/word_combinatorics b/word_combinatorics
@@ -0,0 +1,10 @@
+# Word combinatorics
+
+- [fine_wilf_theorem]
+- [superpermutation]
+- [universal_word]
+- [de_bruijn_sequence]
+
+Up: [combinatorics] on [word]
+
+See also: [stringology], [formal_language_theory]
diff --git a/word_problem b/word_problem
@@ -0,0 +1,6 @@
+# Word problem
+
+Word problem for [group]
+- interesting special cases, e.g., for [coxeter_groups]
+
+Up: [computational_problem] on [group]
diff --git a/word_query b/word_query
@@ -0,0 +1,7 @@
+# Word query
+
+[regular_path_query] corresponding to a finite word
+
+a restricted case of [union_of_conjunctive_queries] over [graph_database]
+
+Up: [regular_path_query]
diff --git a/yaos_principle b/yaos_principle
@@ -0,0 +1,5 @@
+# Yao's principle
+
+https://en.wikipedia.org/wiki/Yao's_principle
+
+Up: [algorithm_randomized]
diff --git a/zero_clique b/zero_clique
@@ -0,0 +1,13 @@
+# Zero clique
+
+[exact_triangle] but for [clique]
+
+[negative_clique]
+
+the correspondence with [3sum] or with [all_pairs_shortest_path] no longer works
+
+- [zero_clique_conjecture]
+
+See also: [hyperclique]
+
+Up: [exact_triangle], [clique], [fine_grained_complexity_problems]
diff --git a/zhao2024evaluating b/zhao2024evaluating
@@ -0,0 +1,9 @@
+# Zhao2024evaluating
+
+[computational_complexity] of [datalog_semiring_query_evaluation] under [naturally_ordered_semiring]
+
+- uses [grounding]
+- has [lower_bounds] but still over a class of programs, not over a specific program
+ - reduction from [clique]
+
+Up: [academic_paper] on [datalog_semiring_query_evaluation]
diff --git a/zpp b/zpp
@@ -0,0 +1,10 @@
+# ZPP
+
+ZPP (zero-error probabilistic PTIME) = [rp] cap [corp]
+- you can give the correct answer or "don't know", with at most proba 1/2
+
+Corresponding algorithms for [ptime]: "Las Vegas" algorithm
+
+Up: [complexity_random]
+
+See also: [bpp], [rp], [automaton_las_vegas]
