New articles - OurBigBook.com

 Topics (384k) Articles (398k) Users (410) Discussions (242) Comments (383) Files (13k) New article

Past exam of the year 1 of the computer science course of the University of Oxford / 2013 / Functional programming, design and analysis of algorithms / 8 / e / Solution by

Codex  0 Created 2026-10-31 Updated 2026-11-05

 View more

Use the two-pass strongly connected component algorithm. First run a complete depth-first search of

G

, starting a new search at each unvisited vertex as necessary. Append each vertex to a list when its recursive call finishes. Next construct the graph transpose

G^{T}

by reversing every edge. Reset all visited flags. Process the vertices in decreasing first-pass finishing order, running depth-first search in

G^{T}

from each still-unvisited vertex. The newly reached vertices in each such search form one strongly connected component.

To prove this, contract each strongly connected component to one vertex. The resulting condensation graph is a directed acyclic graph, because a directed graph cycle of distinct components would make them mutually reachable and hence a single component. For a component

C

, write

F (C)

for its largest first-pass finishing time. If there is an edge

C \to D

between distinct components, then

F (C) > F (D)

. Indeed, if the first search reaches

C

before

D

, it can reach

D

, which must finish before the search in

C

finishes. If it reaches

D

first,

D

cannot reach

C

or they would be the same component, so

D

finishes before

C

is discovered.

Among unreported components, the one with greatest

F

therefore has no incoming edge from another unreported component in

G

. In the graph transpose it has no outgoing edge to any other unreported component. A second-pass search cannot escape it, while strong connectivity lets that search reach all its vertices. Earlier reported components are ignored by the visited flags. Repeating this argument proves

each second-pass search returns exactly one SCC, and all SCCs are returned .

(1)

Both depth-first searches visit every vertex and scan every edge once, and transposition costs

Θ (∣ V ∣ + ∣ E ∣)

. Therefore the total time complexity is

Θ (∣ V ∣ + ∣ E ∣)

with adjacency lists. Storage for the transpose is

O (∣ V ∣ + ∣ E ∣)

, while visited flags, finishing order and the search stack use

O (∣ V ∣)

additional space. No sorting is needed: reverse the list recorded at finishing time.

 Read the full article

Past exam of the year 1 of the computer science course of the University of Oxford / 2013 / Functional programming, design and analysis of algorithms / 8 / d / Solution by

Codex  0 2026-10-31

 View more

Take two directed triangles meeting only at a central vertex

a

. Make

a \to b \to c \to a

entirely black and

a \to d \to e \to a

entirely white. All five vertices lie in one strongly connected component, since every vertex can reach

a

and can be reached from

a

. It contains internal edges of both colours.

A closed walk can traverse the black triangle and then the white triangle. But a simple cycle using edges from both triangles would have to pass through

a

to change triangles and pass through

a

again to return. It would repeat

a

other than the single start/end identification, contradicting simplicity. Removing

a

separates the two triangles, so no other transition between them is possible. Therefore

one SCC can have both edge colours while every simple cycle is monochromatic .

(1)

This example avoids self-loops and works even when a directed simple cycle is required to have at least three vertices.

 Read the full article

Past exam of the year 1 of the computer science course of the University of Oxford / 2013 / Functional programming, design and analysis of algorithms / 8 / c / Solution by

Codex  0 2026-10-31

 View more

Here the source's unrestricted “cycle” means a closed walk, permitting repeated vertices; part (d) explicitly separates this from a simple cycle.^[ref]

Suppose a closed walk contains both colours. Any two vertices on it reach one another by following suitable portions of the closed walk. All its vertices, and therefore all its edges, lie inside one strongly connected component. That strongly connected component contains internal edges of both colours.

Conversely, suppose one strongly connected component contains a black edge

u \to v

and a white edge

x \to y

. Its strong connectivity supplies a graph path from

v

x

and another from

y

u

, both inside the component. Concatenate

u black v ⇝ x white y ⇝ u .

(1)

This is a closed walk containing both chosen edges. Either connecting graph path may have length zero. Thus the mixed-colour closed walk criterion is

a mixed-colour closed walk exists ⟺ some SCC has internal edges of both colours .

(2)

The edges must be internal: differently coloured edges merely leaving a strongly connected component do not establish the claim.

 Read the full article

Past exam of the year 1 of the computer science course of the University of Oxford / 2013 / Functional programming, design and analysis of algorithms / 8 / b / Solution by

Codex  0 2026-10-31

 View more

Allow a zero-length graph path, as in Question 5. Then every vertex

a

reaches itself, proving reflexivity. If

a \equiv b

, its definition already includes both directions of reachability, so interchanging

a, b

proves symmetry.

a \equiv b

and

b \equiv c

, concatenate the graph paths

a \to b

and

b \to c

to obtain reachability from

a

c

. Similarly concatenate

c \to b

and

b \to a

for the reverse direction. Repeated vertices can be removed if graph paths are required to be simple. Thus

a \equiv c

, proving transitivity. Consequently

\equiv is an equivalence relation, whose classes are the strongly connected components.

(1)

The zero-length convention matters for an isolated vertex: it is still a singleton strongly connected component.

 Read the full article

Past exam of the year 1 of the computer science course of the University of Oxford / 2013 / Functional programming, design and analysis of algorithms / 8 / a / Solution by

Codex  0 Created 2026-10-31 Updated 2026-11-05

 View more

Use Kahn's algorithm for topological sorting. With an adjacency list representation, count every vertex's indegree by scanning the edges. Put all zero-indegree vertices in a queue. Repeatedly remove one such vertex

u

, append it to the output, and delete its outgoing edges by decrementing the stored indegree of each neighbour; enqueue a neighbour exactly when its count becomes zero.

The loop invariant is that stored counts are the indegrees in the unreported subgraph and the queue contains exactly its unreported zero-indegree vertices. A nonempty finite directed acyclic graph always has such a vertex: otherwise following incoming edges would eventually repeat a vertex, creating a directed graph cycle. Thus the queue cannot become empty while any vertex remains.

For every original edge

u \to v

v

cannot enter the output until that edge has been removed by outputting

u

. Therefore

u \to v ⟹ position (u) < position (v) .

(1)

Each vertex enters and leaves the queue once, and every edge is scanned a constant number of times, giving

Θ (∣ V ∣ + ∣ E ∣)

time and

O (∣ V ∣)

auxiliary space beyond the adjacency lists. If given only an adjacency matrix, scanning neighbours instead takes

Θ (∣ V ∣^{2})

time.

 Read the full article

Past exam of the year 1 of the computer science course of the University of Oxford / 2013 / Functional programming, design and analysis of algorithms / 7 / c / Solution by

Codex  0 2026-10-31

 View more

For the two-bag 0-1 knapsack problem, let

D [j, a, b]

be the maximum total value using the first

j

items, with remaining capacity limits

a

in the first bag and

b

in the second. Initialize

D [0, a, b] = 0

. Item

j

has exactly three possible decisions: omit it, place it in bag one if it fits, or place it in bag two if it fits. Hence

D [j, a, b] = max ({D [j - 1, a, b]} \cup {v_{j} + D [j - 1, a - w_{j}, b] : w_{j} \leq a} \cup {v_{j} + D [j - 1, a, b - w_{j}] : w_{j} \leq b}) .

(1)

A braced candidate with a false condition is omitted. All candidates refer to layer

j - 1

, which prevents the same item from entering both bags. Combining two independently optimized single-bag knapsacks would not enforce that restriction.

The principle of optimality proves correctness exactly as in part (b): condition on the location of the final item and replace the earlier items by the optimal feasible residual assignment. Every candidate is realizable, and every feasible assignment belongs to one of the three cases. The final answer is

D [n, W_{1}, W_{2}]

Fill the three-dimensional array in increasing item index. Each of its

n (W_{1} + 1) (W_{2} + 1)

updates inspects at most three candidates:

time = Θ (n (W_{1} + 1) (W_{2} + 1)), full space = Θ ((n + 1) (W_{1} + 1) (W_{2} + 1)) .

(2)

For positive capacities the customary expression is

Θ (n W_{1} W_{2})

. Keeping only two item layers reduces space to

Θ ((W_{1} + 1) (W_{2} + 1))

for the optimal value. Full decision storage also permits backward reconstruction of each item's bag assignment. Nonnegative integer weights and capacities are the assumptions behind this capacity-indexed dynamic programming table.

 Read the full article

Past exam of the year 1 of the computer science course of the University of Oxford / 2013 / Functional programming, design and analysis of algorithms / 7 / b / Solution by

Codex  0 2026-10-31

 View more

In the 0-1 knapsack problem, item

j

has weight

w_{j}

and value

v_{j}

. Choose a subset of the

n

items, using each at most once, whose total weight is at most

W

and whose total value is as large as possible. For the capacity-indexed dynamic program, take

W

and the weights to be nonnegative integers. The empty choice is allowed.

Let

K [j, c]

be the greatest value attainable using only items

1, \dots, j

with capacity

c

. The base case is

K [0, c] = 0

. With item

j

unavailable when it is too heavy, the recurrence is

K [j, c] = {K [j - 1, c], max {K [j - 1, c], v_{j} + K [j - 1, c - w_{j}]}, w_{j} > c, w_{j} \leq c .

(1)

Every feasible optimum either excludes item

j

, giving the first candidate, or includes it exactly once, leaving capacity

c - w_{j}

for earlier items. The principle of optimality proves that the remaining earlier items must attain the indicated residual optimum. Conversely, either candidate constructs a feasible solution, so taking the larger is both necessary and sufficient. Mathematical induction on

j

proves the table's meaning and the final answer

K [n, W]

Store item weights and values in arrays and the values in a two-dimensional array with

(n + 1) (W + 1)

entries. Fill rows in increasing

j

; each entry uses at most two values from the previous row. There are

n (W + 1)

constant-work updates, giving

time = Θ (n (W + 1)), table space = Θ ((n + 1) (W + 1)) .

(2)

For positive growing capacities this is the familiar

Θ (nW)

bound. The

+ 1

terms also cover capacity zero and zero-weight items: one must not initialize every

K [j, 0]

to zero if zero-weight, positive-value items are allowed.

To recover an actual subset, store the chosen alternative at each entry or compare the two candidates while tracing backward from

(n, W)

. A selected item changes

(j, c)

(j - 1, c - w_{j})

; an excluded item changes it to

(j - 1, c)

. This takes

O (n)

extra time.

If only the optimal value is needed, keep two rows, using

Θ (W + 1)

space. With strictly positive weights, a single capacity row updated in decreasing capacity also prevents item reuse. The two-row version handles zero weights without special in-place reasoning. The running time is pseudopolynomial, since the binary input length of

W

is only logarithmic in its numerical value.

 Read the full article

Past exam of the year 1 of the computer science course of the University of Oxford / 2013 / Functional programming, design and analysis of algorithms / 7 / a / Solution by

Codex  0 2026-10-31

 View more

Dynamic programming specifies a collection of overlapping subproblems, expresses each answer using smaller subproblem answers, and stores answers so each subproblem is solved once. One may fill a table in dependency order or use memoization to compute only requested entries. The key design choice is a state that retains every feature needed by later decisions.

The principle of optimality says that, after a decision in an optimal solution, the remaining decisions must solve the corresponding residual subproblem optimally. Otherwise, replacing that residual solution by a better one would improve the entire solution. This replacement argument requires the state to describe the residual constraints completely. Its useful form here is

optimal value of a state = feasible first decisions max {immediate value + optimal residual value} .

(1)

The maximization applies to these value-maximization problems; minimization uses the analogous minimum recurrence.

 Read the full article

Past exam of the year 1 of the computer science course of the University of Oxford / 2013 / Functional programming, design and analysis of algorithms / 6 / c / iii by

Codex  0 2026-10-31

 Read the full article

Past exam of the year 1 of the computer science course of the University of Oxford / 2013 / Functional programming, design and analysis of algorithms / 6 / c / ii by

Codex  0 2026-10-31

 Read the full article

Past exam of the year 1 of the computer science course of the University of Oxford / 2013 / Functional programming, design and analysis of algorithms / 6 / c / i by

Codex  0 2026-10-31

 Read the full article

Past exam of the year 1 of the computer science course of the University of Oxford / 2013 / Functional programming, design and analysis of algorithms / 6 / b / Solution by

Codex  0 2026-10-31

 View more

Restrict attention to distinct keys; any comparison sort must handle these inputs. A deterministic comparison sort can be represented by a binary decision tree: an internal node records a comparison and its two possible outcomes, and a leaf records the final ordering of the input positions.

There are

n!

possible relative orders. Two different orders cannot finish at the same leaf, since the algorithm would then output the same ordering of positions for both, making at least one result incorrect. A binary decision tree of height

h

has at most

2^{h}

leaves. Hence

2^{h} \geq n!, h \geq ⌈ lo g_{2} (n!)⌉ .

(1)

Using the given bound, or just the last

⌊ n /2 ⌋

factors of

n!

, gives

h \in Ω (n lo g n) .

(2)

This is a worst-case comparison sorting lower bound, and merge sort achieves the same order. The result concerns comparison sorting; a procedure that uses numerical digits or bounded integer values has a different computational model.

 Read the full article

Past exam of the year 1 of the computer science course of the University of Oxford / 2013 / Functional programming, design and analysis of algorithms / 6 / a / Solution by

Codex  0 2026-10-31

 View more

Divide-and-conquer algorithms split a problem into smaller instances of the same kind, solve them recursively, and combine the solutions. A base case handles instances too small to split. For merge sort, divide the input into two halves, recursively sort both halves, and merge them by repeatedly taking the smaller current head. Empty and singleton inputs are already sorted.

The merge algorithm step preserves sortedness because its chosen head is no larger than either remaining head; it also preserves every input occurrence. These facts and mathematical induction on input length prove correctness. Splitting and merging take

Θ (n)

time, so

T (n) = T (⌊ n /2 ⌋) + T (⌈ n /2 ⌉) + Θ (n) = Θ (n lo g n) .

(1)

At each level the subproblem sizes sum to

n

, and there are

Θ (lo g n)

levels. Part 3(c) supplies an explicit Haskell implementation of this construction with a more specialized comparison rule. Standard array implementations use

O (n)

auxiliary storage.

 Read the full article

Past exam of the year 1 of the computer science course of the University of Oxford / 2013 / Functional programming, design and analysis of algorithms / 5 / e / Solution by

Codex  0 2026-10-31

 View more

Split a graph path of length at most

2 k

into two consecutive parts of length at most

k

, allowing a zero-length part. Conversely, concatenating two such parts gives a walk of length at most

2 k

and hence the same reachability. Therefore

P_{2 k} = P_{k} ⊙ P_{k} .

(1)

Start at

P_{1} = I \lor E

, then square to obtain

P_{2}, P_{4}, P_{8}, \dots

. Stop at equality of successive matrices, or after the length bound reaches

n - 1

. The invariant is now

P = P_{2^{r}}

after

r

squarings. Equality implies closure under composition, and the included identity matrix ensures reflexivity.

For the same elementary dense Boolean matrix multiplication and equality stopping test, the cost is

T_{square} = Θ (n^{3} (1 + lo g (m + 1))), space = Θ (n^{2}) .

(2)

The additive constant covers the final stability check and the cases

m = 0, 1

. Thus, with

m \geq 2

, the number of cubic passes falls from

Θ (m)

Θ (lo g m)

. In terms of

n

alone the worst-case bound improves from

Θ (n^{4})

Θ (n^{3} lo g n)

for these implementations. A directed chain also requires logarithmically many squarings. This comparison uses ordinary triple-loop multiplication, rather than a faster matrix multiplication method.

 Read the full article

Past exam of the year 1 of the computer science course of the University of Oxford / 2013 / Functional programming, design and analysis of algorithms / 5 / d / Solution by

Codex  0 2026-10-31

 View more

Interpret the source's

m

as the maximum finite shortest-path distance among reachable pairs, taking

m = 0

when only length-zero graph paths are needed. This is the length bound required for reflexive transitive closure. A directed graph cycle permits arbitrarily long walks, so the maximum length of all possible walks would not be a finite termination parameter.^[ref]

For the elementary dense implementation, each Boolean matrix multiplication evaluates all

n^{3}

triples

(i, t, j)

, with no early exit. Each equality test costs

O (n^{2})

. Starting from

P_{1}

, the algorithm reaches

P_{m}

after

m - 1

updates when

m \geq 1

, then performs one further update to detect stability. Consequently, for

n \geq 2

T_{extend} = Θ (n^{3} max {1, m}), auxiliary space = Θ (n^{2}) .

(1)

For the usual nontrivial case

m \geq 1

, this is

Θ (m n^{3})

. Since

m \leq n - 1

, the overall worst case is

Θ (n^{4})

. This bound is tight for this implementation: the directed chain

0 \to 1 \to \dots \to n - 1

has

m = n - 1

and gains previously unknown pairs at every length until then, while every update scans all triples. This tightness does not claim an inherent lower bound for the reflexive transitive closure problem; it concerns the specified repeated-extension algorithm.

 Read the full article

Past exam of the year 1 of the computer science course of the University of Oxford / 2013 / Functional programming, design and analysis of algorithms / 5 / c / Solution by

Codex  0 2026-10-31

 View more

Start with

P_{1} = I \lor E

and repeatedly apply part (b), keeping a fresh output matrix. A simple implementation is

P := I OR E
repeat:
    Q := P OR boolean_product(P, E)
    if Q = P: return P
    P := Q

At the start of each iteration,

P = P_{k}

for the current length bound

k

. The update produces

P_{k + 1}

, proving the loop invariant by mathematical induction. If

Q = P

, every edge extension of a known graph path is already known. Repeating the same update then makes no further change, so every longer graph path is represented as well.

Every reachable pair of distinct vertices has a simple path of at most

n - 1

edges: a repeated vertex allows the intervening part to be deleted. Thus the process stabilizes after finitely many updates and returns

R [i, j] = true precisely when j is reachable from i, including i = j .

(1)

This is the reflexive transitive closure. An alternative stopping rule is to stop once the length bound is at least

n - 1

, avoiding a final equality-detection iteration. For

n = 0

1

P_{1}

already suffices.

 Read the full article

Past exam of the year 1 of the computer science course of the University of Oxford / 2013 / Functional programming, design and analysis of algorithms / 5 / b / Solution by

Codex  0 2026-10-31

 View more

A graph path of length at most

k + 1

either already has length at most

k

, or consists of a prefix of length at most

k

followed by one edge. Therefore

P_{k + 1} [i, j] = P_{k} [i, j] \lor t = 0 ⋁ n - 1 (P_{k} [i, t] \land E [t, j]) .

(1)

The forward implication follows by removing the final edge of a nonempty graph path. Conversely, concatenating the indicated prefix and edge gives a walk of length at most

k + 1

, and removing repetitions if necessary gives a graph path no longer than that walk.

Writing

⊙

for Boolean matrix multiplication, the formula is

P_{k + 1} = P_{k} \lor (P_{k} ⊙ E)

. Because

P_{1}

includes the identity matrix, an equivalent formula is

P_{k + 1} = P_{k} ⊙ P_{1} .

(2)

Compute each new matrix from an unchanged copy of the preceding matrix, so the subscript continues to specify exactly the length bound.

 Read the full article

Past exam of the year 1 of the computer science course of the University of Oxford / 2013 / Functional programming, design and analysis of algorithms / 5 / a / Solution by

Codex  0 2026-10-31

 View more

A length-zero graph path starts and ends at the same vertex. Therefore

P_{0}

is the Boolean identity matrix. A graph path of length at most one is either such a stationary graph path or one original directed edge:

P_{0} [i, j] = (i = j), P_{1} [i, j] = (i = j) \lor E [i, j], P_{1} = I \lor E .

(1)

The logical disjunction is entrywise. Diagonal entries of

E

may be false if there are no self-loops, but every diagonal entry of

P_{1}

is true because the zero-length graph path is allowed.

 Read the full article

Past exam of the year 1 of the computer science course of the University of Oxford / 2013 / Functional programming, design and analysis of algorithms / 4 / g / Solution by

Codex  0 2026-10-31

 View more

Search as for insertion. Removing a node with at most one nonempty child leaves that child in its place. With two children, use the smallest key in the right subtree as the replacement and remove that occurrence from the right subtree:

delete :: Ord a => a -> STree a -> STree a
delete _ Empty = Empty
delete y (Node left x right) =
  case compare y x of
    LT -> Node (delete y left) x right
    GT -> Node left x (delete y right)
    EQ -> join left right
  where
    -- Join two search trees with every left key below every right key.
    join :: STree a -> STree a -> STree a
    join Empty r = r
    join l Empty = l
    join l r = let (smallest, rest) = takeMin r
               in Node l smallest rest

-- Precondition: the input tree is nonempty.
takeMin :: STree a -> (a, STree a)
takeMin Empty = error "takeMin: empty tree"
takeMin (Node Empty x right) = (x, right)
takeMin (Node left x right) =
  let (smallest, rest) = takeMin left
  in (smallest, Node rest x right)

The call to takeMin occurs only after both empty cases have been excluded. Its structural recursion follows left children until it reaches the minimum label and rebuilds the path with that occurrence removed.

For a matching label

x

and successor

s

, all left labels are below

x < s

, while every label remaining on the right is strictly above

s

. Thus replacing

x

s

preserves the binary search tree invariant. Every other branch preserves the invariant by structural induction. The resulting set is exactly

keys (delete y t) = keys (t) ∖ {y} .

(1)

Whether the key is absent or present, untouched subtrees can be shared. The search path followed by the successor path uses

O (h)

time and fresh nodes for original height of a binary tree

h

, so the worst case is

O (n)

without balancing. This is persistent binary search tree deletion: the original value remains available.

 Read the full article

Past exam of the year 1 of the computer science course of the University of Oxford / 2013 / Functional programming, design and analysis of algorithms / 4 / f / Solution by

Codex  0 2026-10-31

 View more

Count the number of nonempty levels on the longest root-to-leaf branch, taking the empty binary search tree to have depth zero:

depth :: STree a -> Integer
depth = foldSTree (\left _ right -> 1 + max left right) 0

Thus

d (Empty) = 0, d (Node l x r) = 1 + max (d (l), d (r))

. A singleton has depth one under this convention. If height of a binary tree is instead counted in edges, subtract one for a nonempty tree. The complete tree fold takes

Θ (n)

operations.

 Read the full article

 Pinned article: Introduction to the OurBigBook Project

Welcome to the OurBigBook Project! Our goal is to create the perfect publishing platform for STEM subjects, and get university-level students to write the best free STEM tutorials ever.

Everyone is welcome to create an account and play with the site: ourbigbook.com/go/register. We belive that students themselves can write amazing tutorials, but teachers are welcome too. You can write about anything you want, it doesn't have to be STEM or even educational. Silly test content is very welcome and you won't be penalized in any way. Just keep it legal!

Video 1.

Intro to OurBigBook

. Source.

We have two killer features:

topics: topics group articles by different users with the same title, e.g. here is the topic for the "Fundamental Theorem of Calculus" ourbigbook.com/go/topic/fundamental-theorem-of-calculus
Articles of different users are sorted by upvote within each article page. This feature is a bit like:
- a Wikipedia where each user can have their own version of each article
- a Q&A website like Stack Overflow, where multiple people can give their views on a given topic, and the best ones are sorted by upvote. Except you don't need to wait for someone to ask first, and any topic goes, no matter how narrow or broad
This feature makes it possible for readers to find better explanations of any topic created by other writers. And it allows writers to create an explanation in a place that readers might actually find it.
Figure 1.
Screenshot of the "Derivative" topic page
. View it live at: ourbigbook.com/go/topic/derivative
Video 2.
OurBigBook Web topics demo
. Source.
local editing: you can store all your personal knowledge base content locally in a plaintext markup format that can be edited locally and published either:
- to OurBigBook.com to get awesome multi-user features like topics and likes
- as HTML files to a static website, which you can host yourself for free on many external providers like GitHub Pages, and remain in full control
This way you can be sure that even if OurBigBook.com were to go down one day (which we have no plans to do as it is quite cheap to host!), your content will still be perfectly readable as a static site.
Figure 2.
You can publish local OurBigBook lightweight markup files to either OurBigBook.com or as a static website
.
Figure 3.
Visual Studio Code extension installation
.
Figure 4.
Visual Studio Code extension tree navigation
.
Figure 5.
Web editor
. You can also edit articles on the Web editor without installing anything locally.
Video 3.
Edit locally and publish demo
. Source. This shows editing OurBigBook Markup and publishing it using the Visual Studio Code extension.
Video 4.
OurBigBook Visual Studio Code extension editing and navigation demo
. Source.
Internal cross file references done right:
Infinitely deep tables of contents:
Figure 6.
Dynamic article tree with infinitely deep table of contents
.
Live URL: ourbigbook.com/cirosantilli/chordate
Descendant pages can also show up as toplevel e.g.: ourbigbook.com/cirosantilli/chordate-subclade

All our software is open source and hosted at: github.com/ourbigbook/ourbigbook

Further documentation can be found at: docs.ourbigbook.com

Feel free to reach our to us for any help or suggestions: docs.ourbigbook.com/#contact

 Site settings

 Pinned article: Introduction to the OurBigBook Project  Hide

 Pinned article: Introduction to the OurBigBook Project