Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

forall i, j in [0, 4): first_ge(i) & first_ge(j) -> i == j

Answer: 2

the smallest index whose value reaches the threshold

import json
import sys

data = json.load(sys.stdin)
array = data["array"]
threshold = data["threshold"]
answer = -1
for index, value in enumerate(array):
    if value >= threshold:
        answer = index
        break
print(answer)

You are given a 0-indexed non-decreasing integer array A of length 4 with
2 <= A[i] <= 9, together with an integer threshold T drawn from the
elements of A itself.

Print the smallest index k such that A[k] >= T. Because the predicate is
defined by minimality there is at most one such index, and because T occurs
in A at least one exists; both facts are formally proven for this instance
with the Z3 SMT solver.

Bounded Monotonic Split (n=4, T=3)

Explanation: Canonical verified instance: Z3 proved satisfiability and blocked 1 model(s) to establish uniqueness.


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

(and (>= equilibrium_index 0)
     (< equilibrium_index 4)
     (=> (= equilibrium_index 0) (= 0 11))
     (=> (= equilibrium_index 1) (= 6 6))
     (=> (= equilibrium_index 2) (= 11 2))
     (=> (= equilibrium_index 3) (= 15 0)))

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

forall i, j in [0, 4): equilibrium(i) & equilibrium(j) -> i == j

Answer: 1

the unique equilibrium index

import json
import sys

data = json.load(sys.stdin)
array = data["array"]
total = sum(array)
prefix = 0
answer = -1
for index, value in enumerate(array):
    suffix = total - prefix - value
    if prefix == suffix:
        answer = index
        break
    prefix += value
print(answer)

You are given a 0-indexed integer array A of length 4. Every element is a
strictly positive integer with 1 <= A[i] <= 9.

An index i is an equilibrium index when the elements strictly before i sum to
the same value as the elements strictly after i:

    A[0] + ... + A[i-1]  ==  A[i+1] + ... + A[n-1]

The provided array contains exactly one equilibrium index; existence and
uniqueness are formally proven for this instance with the Z3 SMT solver.
Print that index.

Unique Equilibrium Index (n=4)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

forall i, j in [0, 5): first_ge(i) & first_ge(j) -> i == j

Answer: 0

the smallest index whose value reaches the threshold

You are given a 0-indexed non-decreasing integer array A of length 5 with
2 <= A[i] <= 9, together with an integer threshold T drawn from the
elements of A itself.

Print the smallest index k such that A[k] >= T. Because the predicate is
defined by minimality there is at most one such index, and because T occurs
in A at least one exists; both facts are formally proven for this instance
with the Z3 SMT solver.

Bounded Monotonic Split (n=5, T=2)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

(and (>= equilibrium_index 0)
     (< equilibrium_index 3)
     (=> (= equilibrium_index 0) (= 0 8))
     (=> (= equilibrium_index 1) (= 4 4))
     (=> (= equilibrium_index 2) (= 8 0)))

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

forall i, j in [0, 3): equilibrium(i) & equilibrium(j) -> i == j

Answer: 1

the unique equilibrium index

You are given a 0-indexed integer array A of length 3. Every element is a
strictly positive integer with 1 <= A[i] <= 9.

An index i is an equilibrium index when the elements strictly before i sum to
the same value as the elements strictly after i:

    A[0] + ... + A[i-1]  ==  A[i+1] + ... + A[n-1]

The provided array contains exactly one equilibrium index; existence and
uniqueness are formally proven for this instance with the Z3 SMT solver.
Print that index.

Unique Equilibrium Index (n=3)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 1

the smallest index whose value reaches the threshold

You are given a 0-indexed non-decreasing integer array A of length 4 with
0 <= A[i] <= 9, together with an integer threshold T drawn from the
elements of A itself.

Print the smallest index k such that A[k] >= T. Because the predicate is
defined by minimality there is at most one such index, and because T occurs
in A at least one exists; both facts are formally proven for this instance
with the Z3 SMT solver.

Bounded Monotonic Split (n=4, T=1)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 0

the smallest index whose value reaches the threshold

Bounded Monotonic Split (n=4, T=2)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

(and (>= equilibrium_index 0)
     (< equilibrium_index 3)
     (=> (= equilibrium_index 0) (= 0 11))
     (=> (= equilibrium_index 1) (= 2 2))
     (=> (= equilibrium_index 2) (= 11 0)))

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 1

the unique equilibrium index

Unique Equilibrium Index (n=3)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

(and (>= equilibrium_index 0)
     (< equilibrium_index 3)
     (=> (= equilibrium_index 0) (= 0 15))
     (=> (= equilibrium_index 1) (= 8 8))
     (=> (= equilibrium_index 2) (= 15 0)))

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 1

the unique equilibrium index

Unique Equilibrium Index (n=3)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

(and (>= equilibrium_index 0)
     (< equilibrium_index 3)
     (=> (= equilibrium_index 0) (= 0 12))
     (=> (= equilibrium_index 1) (= 8 8))
     (=> (= equilibrium_index 2) (= 12 0)))

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 1

the unique equilibrium index

Unique Equilibrium Index (n=3)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

(and (>= equilibrium_index 0)
     (< equilibrium_index 5)
     (=> (= equilibrium_index 0) (= 0 32))
     (=> (= equilibrium_index 1) (= 9 25))
     (=> (= equilibrium_index 2) (= 16 16))
     (=> (= equilibrium_index 3) (= 25 9))
     (=> (= equilibrium_index 4) (= 32 0)))

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

forall i, j in [0, 5): equilibrium(i) & equilibrium(j) -> i == j

Answer: 2

the unique equilibrium index

You are given a 0-indexed integer array A of length 5. Every element is a
strictly positive integer with 1 <= A[i] <= 9.

An index i is an equilibrium index when the elements strictly before i sum to
the same value as the elements strictly after i:

    A[0] + ... + A[i-1]  ==  A[i+1] + ... + A[n-1]

The provided array contains exactly one equilibrium index; existence and
uniqueness are formally proven for this instance with the Z3 SMT solver.
Print that index.

Unique Equilibrium Index (n=5)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

(and (>= equilibrium_index 0)
     (< equilibrium_index 5)
     (=> (= equilibrium_index 0) (= 0 11))
     (=> (= equilibrium_index 1) (= 7 7))
     (=> (= equilibrium_index 2) (= 11 6))
     (=> (= equilibrium_index 3) (= 12 3))
     (=> (= equilibrium_index 4) (= 15 0)))

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 1

the unique equilibrium index

Unique Equilibrium Index (n=5)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

forall i, j in [0, 3): first_ge(i) & first_ge(j) -> i == j

Answer: 2

the smallest index whose value reaches the threshold

You are given a 0-indexed non-decreasing integer array A of length 3 with
1 <= A[i] <= 9, together with an integer threshold T drawn from the
elements of A itself.

Print the smallest index k such that A[k] >= T. Because the predicate is
defined by minimality there is at most one such index, and because T occurs
in A at least one exists; both facts are formally proven for this instance
with the Z3 SMT solver.

Bounded Monotonic Split (n=3, T=5)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 3

the smallest index whose value reaches the threshold

Bounded Monotonic Split (n=4, T=6)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

(and (>= equilibrium_index 0)
     (< equilibrium_index 3)
     (=> (= equilibrium_index 0) (= 0 16))
     (=> (= equilibrium_index 1) (= 8 8))
     (=> (= equilibrium_index 2) (= 16 0)))

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 1

the unique equilibrium index

Unique Equilibrium Index (n=3)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 2

the smallest index whose value reaches the threshold

Bounded Monotonic Split (n=5, T=3)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

(and (>= equilibrium_index 0)
     (< equilibrium_index 5)
     (=> (= equilibrium_index 0) (= 0 21))
     (=> (= equilibrium_index 1) (= 5 14))
     (=> (= equilibrium_index 2) (= 12 12))
     (=> (= equilibrium_index 3) (= 14 5))
     (=> (= equilibrium_index 4) (= 21 0)))

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 2

the unique equilibrium index

Unique Equilibrium Index (n=5)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 1

the smallest index whose value reaches the threshold

You are given a 0-indexed non-decreasing integer array A of length 3 with
0 <= A[i] <= 9, together with an integer threshold T drawn from the
elements of A itself.

Print the smallest index k such that A[k] >= T. Because the predicate is
defined by minimality there is at most one such index, and because T occurs
in A at least one exists; both facts are formally proven for this instance
with the Z3 SMT solver.

Bounded Monotonic Split (n=3, T=2)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

(and (>= equilibrium_index 0)
     (< equilibrium_index 3)
     (=> (= equilibrium_index 0) (= 0 10))
     (=> (= equilibrium_index 1) (= 8 8))
     (=> (= equilibrium_index 2) (= 10 0)))

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 1

the unique equilibrium index

Unique Equilibrium Index (n=3)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

(and (>= equilibrium_index 0)
     (< equilibrium_index 5)
     (=> (= equilibrium_index 0) (= 0 20))
     (=> (= equilibrium_index 1) (= 6 17))
     (=> (= equilibrium_index 2) (= 9 9))
     (=> (= equilibrium_index 3) (= 17 3))
     (=> (= equilibrium_index 4) (= 23 0)))

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 2

the unique equilibrium index

Unique Equilibrium Index (n=5)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

forall i, j in [0, 4): first_ge(i) & first_ge(j) -> i == j

Answer: 0

the smallest index whose value reaches the threshold

Bounded Monotonic Split (n=4, T=2)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 2

the smallest index whose value reaches the threshold

Bounded Monotonic Split (n=3, T=3)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

(and (>= equilibrium_index 0)
     (< equilibrium_index 3)
     (=> (= equilibrium_index 0) (= 0 13))
     (=> (= equilibrium_index 1) (= 5 5))
     (=> (= equilibrium_index 2) (= 13 0)))

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 1

the unique equilibrium index

Unique Equilibrium Index (n=3)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

(and (>= equilibrium_index 0)
     (< equilibrium_index 3)
     (=> (= equilibrium_index 0) (= 0 4))
     (=> (= equilibrium_index 1) (= 2 2))
     (=> (= equilibrium_index 2) (= 4 0)))

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 1

the unique equilibrium index

Unique Equilibrium Index (n=3)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

(and (>= equilibrium_index 0)
     (< equilibrium_index 5)
     (=> (= equilibrium_index 0) (= 0 9))
     (=> (= equilibrium_index 1) (= 1 7))
     (=> (= equilibrium_index 2) (= 3 3))
     (=> (= equilibrium_index 3) (= 7 1))
     (=> (= equilibrium_index 4) (= 9 0)))

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 2

the unique equilibrium index

Unique Equilibrium Index (n=5)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

(and (>= equilibrium_index 0)
     (< equilibrium_index 5)
     (=> (= equilibrium_index 0) (= 0 19))
     (=> (= equilibrium_index 1) (= 5 13))
     (=> (= equilibrium_index 2) (= 11 11))
     (=> (= equilibrium_index 3) (= 13 5))
     (=> (= equilibrium_index 4) (= 19 0)))

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 2

the unique equilibrium index

Unique Equilibrium Index (n=5)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

forall i, j in [0, 11): first_ge(i) & first_ge(j) -> i == j

Answer: 1

the smallest index whose value reaches the threshold

You are given a 0-indexed non-decreasing integer array A of length 11 with
2 <= A[i] <= 9, together with an integer threshold T drawn from the
elements of A itself.

Print the smallest index k such that A[k] >= T. Because the predicate is
defined by minimality there is at most one such index, and because T occurs
in A at least one exists; both facts are formally proven for this instance
with the Z3 SMT solver.

Bounded Monotonic Split (n=11, T=4)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

(and (>= equilibrium_index 0)
     (< equilibrium_index 10)
     (=> (= equilibrium_index 0) (= 0 54))
     (=> (= equilibrium_index 1) (= 2 53))
     (=> (= equilibrium_index 2) (= 3 50))
     (=> (= equilibrium_index 3) (= 6 42))
     (=> (= equilibrium_index 4) (= 14 37))
     (=> (= equilibrium_index 5) (= 19 32))
     (=> (= equilibrium_index 6) (= 24 24))
     (=> (= equilibrium_index 7) (= 32 16))
     (=> (= equilibrium_index 8) (= 40 7))
     (=> (= equilibrium_index 9) (= 49 0)))

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

forall i, j in [0, 10): equilibrium(i) & equilibrium(j) -> i == j

Answer: 6

the unique equilibrium index

You are given a 0-indexed integer array A of length 10. Every element is a
strictly positive integer with 1 <= A[i] <= 9.

An index i is an equilibrium index when the elements strictly before i sum to
the same value as the elements strictly after i:

    A[0] + ... + A[i-1]  ==  A[i+1] + ... + A[n-1]

The provided array contains exactly one equilibrium index; existence and
uniqueness are formally proven for this instance with the Z3 SMT solver.
Print that index.

Unique Equilibrium Index (n=10)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

(and (>= equilibrium_index 0)
     (< equilibrium_index 7)
     (=> (= equilibrium_index 0) (= 0 11))
     (=> (= equilibrium_index 1) (= 9 9))
     (=> (= equilibrium_index 2) (= 11 5))
     (=> (= equilibrium_index 3) (= 15 3))
     (=> (= equilibrium_index 4) (= 17 2))
     (=> (= equilibrium_index 5) (= 18 1))
     (=> (= equilibrium_index 6) (= 19 0)))

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

forall i, j in [0, 7): equilibrium(i) & equilibrium(j) -> i == j

Answer: 1

the unique equilibrium index

You are given a 0-indexed integer array A of length 7. Every element is a
strictly positive integer with 1 <= A[i] <= 9.

An index i is an equilibrium index when the elements strictly before i sum to
the same value as the elements strictly after i:

    A[0] + ... + A[i-1]  ==  A[i+1] + ... + A[n-1]

The provided array contains exactly one equilibrium index; existence and
uniqueness are formally proven for this instance with the Z3 SMT solver.
Print that index.

Unique Equilibrium Index (n=7)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

(and (>= equilibrium_index 0)
     (< equilibrium_index 7)
     (=> (= equilibrium_index 0) (= 0 9))
     (=> (= equilibrium_index 1) (= 8 8))
     (=> (= equilibrium_index 2) (= 9 5))
     (=> (= equilibrium_index 3) (= 12 3))
     (=> (= equilibrium_index 4) (= 14 2))
     (=> (= equilibrium_index 5) (= 15 1))
     (=> (= equilibrium_index 6) (= 16 0)))

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 1

the unique equilibrium index

Unique Equilibrium Index (n=7)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

(and (>= equilibrium_index 0)
     (< equilibrium_index 7)
     (=> (= equilibrium_index 0) (= 0 26))
     (=> (= equilibrium_index 1) (= 1 17))
     (=> (= equilibrium_index 2) (= 10 14))
     (=> (= equilibrium_index 3) (= 13 13))
     (=> (= equilibrium_index 4) (= 14 8))
     (=> (= equilibrium_index 5) (= 19 4))
     (=> (= equilibrium_index 6) (= 23 0)))

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 3

the unique equilibrium index

Unique Equilibrium Index (n=7)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

forall i, j in [0, 9): first_ge(i) & first_ge(j) -> i == j

Answer: 5

the smallest index whose value reaches the threshold

You are given a 0-indexed non-decreasing integer array A of length 9 with
1 <= A[i] <= 9, together with an integer threshold T drawn from the
elements of A itself.

Print the smallest index k such that A[k] >= T. Because the predicate is
defined by minimality there is at most one such index, and because T occurs
in A at least one exists; both facts are formally proven for this instance
with the Z3 SMT solver.

Bounded Monotonic Split (n=9, T=5)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 0

the smallest index whose value reaches the threshold

You are given a 0-indexed non-decreasing integer array A of length 9 with
0 <= A[i] <= 9, together with an integer threshold T drawn from the
elements of A itself.

Print the smallest index k such that A[k] >= T. Because the predicate is
defined by minimality there is at most one such index, and because T occurs
in A at least one exists; both facts are formally proven for this instance
with the Z3 SMT solver.

Bounded Monotonic Split (n=9, T=0)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

forall i, j in [0, 12): first_ge(i) & first_ge(j) -> i == j

Answer: 5

the smallest index whose value reaches the threshold

You are given a 0-indexed non-decreasing integer array A of length 12 with
1 <= A[i] <= 9, together with an integer threshold T drawn from the
elements of A itself.

Print the smallest index k such that A[k] >= T. Because the predicate is
defined by minimality there is at most one such index, and because T occurs
in A at least one exists; both facts are formally proven for this instance
with the Z3 SMT solver.

Bounded Monotonic Split (n=12, T=8)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

(and (>= equilibrium_index 0)
     (< equilibrium_index 6)
     (=> (= equilibrium_index 0) (= 0 13))
     (=> (= equilibrium_index 1) (= 4 4))
     (=> (= equilibrium_index 2) (= 13 3))
     (=> (= equilibrium_index 3) (= 14 2))
     (=> (= equilibrium_index 4) (= 15 1))
     (=> (= equilibrium_index 5) (= 16 0)))

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

forall i, j in [0, 6): equilibrium(i) & equilibrium(j) -> i == j

Answer: 1

the unique equilibrium index

You are given a 0-indexed integer array A of length 6. Every element is a
strictly positive integer with 1 <= A[i] <= 9.

An index i is an equilibrium index when the elements strictly before i sum to
the same value as the elements strictly after i:

    A[0] + ... + A[i-1]  ==  A[i+1] + ... + A[n-1]

The provided array contains exactly one equilibrium index; existence and
uniqueness are formally proven for this instance with the Z3 SMT solver.
Print that index.

Unique Equilibrium Index (n=6)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

(and (>= equilibrium_index 0)
     (< equilibrium_index 11)
     (=> (= equilibrium_index 0) (= 0 36))
     (=> (= equilibrium_index 1) (= 2 33))
     (=> (= equilibrium_index 2) (= 5 29))
     (=> (= equilibrium_index 3) (= 9 23))
     (=> (= equilibrium_index 4) (= 15 20))
     (=> (= equilibrium_index 5) (= 18 18))
     (=> (= equilibrium_index 6) (= 20 14))
     (=> (= equilibrium_index 7) (= 24 12))
     (=> (= equilibrium_index 8) (= 26 11))
     (=> (= equilibrium_index 9) (= 27 5))
     (=> (= equilibrium_index 10) (= 33 0)))

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

forall i, j in [0, 11): equilibrium(i) & equilibrium(j) -> i == j

Answer: 5

the unique equilibrium index

You are given a 0-indexed integer array A of length 11. Every element is a
strictly positive integer with 1 <= A[i] <= 9.

An index i is an equilibrium index when the elements strictly before i sum to
the same value as the elements strictly after i:

    A[0] + ... + A[i-1]  ==  A[i+1] + ... + A[n-1]

The provided array contains exactly one equilibrium index; existence and
uniqueness are formally proven for this instance with the Z3 SMT solver.
Print that index.

Unique Equilibrium Index (n=11)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 8

the smallest index whose value reaches the threshold

You are given a 0-indexed non-decreasing integer array A of length 12 with
2 <= A[i] <= 9, together with an integer threshold T drawn from the
elements of A itself.

Print the smallest index k such that A[k] >= T. Because the predicate is
defined by minimality there is at most one such index, and because T occurs
in A at least one exists; both facts are formally proven for this instance
with the Z3 SMT solver.

Bounded Monotonic Split (n=12, T=9)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

(and (>= equilibrium_index 0)
     (< equilibrium_index 8)
     (=> (= equilibrium_index 0) (= 0 19))
     (=> (= equilibrium_index 1) (= 8 17))
     (=> (= equilibrium_index 2) (= 10 10))
     (=> (= equilibrium_index 3) (= 17 8))
     (=> (= equilibrium_index 4) (= 19 6))
     (=> (= equilibrium_index 5) (= 21 4))
     (=> (= equilibrium_index 6) (= 23 1))
     (=> (= equilibrium_index 7) (= 26 0)))

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

forall i, j in [0, 8): equilibrium(i) & equilibrium(j) -> i == j

Answer: 2

the unique equilibrium index

You are given a 0-indexed integer array A of length 8. Every element is a
strictly positive integer with 1 <= A[i] <= 9.

An index i is an equilibrium index when the elements strictly before i sum to
the same value as the elements strictly after i:

    A[0] + ... + A[i-1]  ==  A[i+1] + ... + A[n-1]

The provided array contains exactly one equilibrium index; existence and
uniqueness are formally proven for this instance with the Z3 SMT solver.
Print that index.

Unique Equilibrium Index (n=8)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

(and (>= equilibrium_index 0)
     (< equilibrium_index 6)
     (=> (= equilibrium_index 0) (= 0 8))
     (=> (= equilibrium_index 1) (= 5 5))
     (=> (= equilibrium_index 2) (= 8 3))
     (=> (= equilibrium_index 3) (= 10 2))
     (=> (= equilibrium_index 4) (= 11 1))
     (=> (= equilibrium_index 5) (= 12 0)))

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 1

the unique equilibrium index

Unique Equilibrium Index (n=6)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

(and (>= equilibrium_index 0)
     (< equilibrium_index 10)
     (=> (= equilibrium_index 0) (= 0 54))
     (=> (= equilibrium_index 1) (= 7 46))
     (=> (= equilibrium_index 2) (= 15 40))
     (=> (= equilibrium_index 3) (= 21 37))
     (=> (= equilibrium_index 4) (= 24 35))
     (=> (= equilibrium_index 5) (= 26 26))
     (=> (= equilibrium_index 6) (= 35 24))
     (=> (= equilibrium_index 7) (= 37 15))
     (=> (= equilibrium_index 8) (= 46 8))
     (=> (= equilibrium_index 9) (= 53 0)))

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 5

the unique equilibrium index

Unique Equilibrium Index (n=10)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

forall i, j in [0, 6): first_ge(i) & first_ge(j) -> i == j

Answer: 3

the smallest index whose value reaches the threshold

You are given a 0-indexed non-decreasing integer array A of length 6 with
0 <= A[i] <= 9, together with an integer threshold T drawn from the
elements of A itself.

Print the smallest index k such that A[k] >= T. Because the predicate is
defined by minimality there is at most one such index, and because T occurs
in A at least one exists; both facts are formally proven for this instance
with the Z3 SMT solver.

Bounded Monotonic Split (n=6, T=4)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

forall i, j in [0, 5): first_ge(i) & first_ge(j) -> i == j

Answer: 4

the smallest index whose value reaches the threshold

You are given a 0-indexed non-decreasing integer array A of length 5 with
1 <= A[i] <= 9, together with an integer threshold T drawn from the
elements of A itself.

Print the smallest index k such that A[k] >= T. Because the predicate is
defined by minimality there is at most one such index, and because T occurs
in A at least one exists; both facts are formally proven for this instance
with the Z3 SMT solver.

Bounded Monotonic Split (n=5, T=4)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

(and (>= equilibrium_index 0)
     (< equilibrium_index 11)
     (=> (= equilibrium_index 0) (= 0 12))
     (=> (= equilibrium_index 1) (= 9 11))
     (=> (= equilibrium_index 2) (= 10 10))
     (=> (= equilibrium_index 3) (= 11 9))
     (=> (= equilibrium_index 4) (= 12 7))
     (=> (= equilibrium_index 5) (= 14 5))
     (=> (= equilibrium_index 6) (= 16 4))
     (=> (= equilibrium_index 7) (= 17 3))
     (=> (= equilibrium_index 8) (= 18 2))
     (=> (= equilibrium_index 9) (= 19 1))
     (=> (= equilibrium_index 10) (= 20 0)))

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 2

the unique equilibrium index

Unique Equilibrium Index (n=11)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

(and (>= equilibrium_index 0)
     (< equilibrium_index 5)
     (=> (= equilibrium_index 0) (= 0 15))
     (=> (= equilibrium_index 1) (= 3 10))
     (=> (= equilibrium_index 2) (= 8 8))
     (=> (= equilibrium_index 3) (= 10 4))
     (=> (= equilibrium_index 4) (= 14 0)))

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

forall i, j in [0, 5): equilibrium(i) & equilibrium(j) -> i == j

Answer: 2

the unique equilibrium index

Unique Equilibrium Index (n=5)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

(and (>= equilibrium_index 0)
     (< equilibrium_index 7)
     (=> (= equilibrium_index 0) (= 0 37))
     (=> (= equilibrium_index 1) (= 9 31))
     (=> (= equilibrium_index 2) (= 15 24))
     (=> (= equilibrium_index 3) (= 22 22))
     (=> (= equilibrium_index 4) (= 24 14))
     (=> (= equilibrium_index 5) (= 32 8))
     (=> (= equilibrium_index 6) (= 38 0)))

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

forall i, j in [0, 7): equilibrium(i) & equilibrium(j) -> i == j

Answer: 3

the unique equilibrium index

Unique Equilibrium Index (n=7)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

(and (>= equilibrium_index 0)
     (< equilibrium_index 11)
     (=> (= equilibrium_index 0) (= 0 26))
     (=> (= equilibrium_index 1) (= 5 21))
     (=> (= equilibrium_index 2) (= 10 18))
     (=> (= equilibrium_index 3) (= 13 13))
     (=> (= equilibrium_index 4) (= 18 12))
     (=> (= equilibrium_index 5) (= 19 9))
     (=> (= equilibrium_index 6) (= 22 8))
     (=> (= equilibrium_index 7) (= 23 6))
     (=> (= equilibrium_index 8) (= 25 3))
     (=> (= equilibrium_index 9) (= 28 1))
     (=> (= equilibrium_index 10) (= 30 0)))

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 3

the unique equilibrium index

Unique Equilibrium Index (n=11)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 0

the smallest index whose value reaches the threshold

Bounded Monotonic Split (n=6, T=0)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

forall i, j in [0, 11): first_ge(i) & first_ge(j) -> i == j

Answer: 1

the smallest index whose value reaches the threshold

You are given a 0-indexed non-decreasing integer array A of length 11 with
0 <= A[i] <= 9, together with an integer threshold T drawn from the
elements of A itself.

Print the smallest index k such that A[k] >= T. Because the predicate is
defined by minimality there is at most one such index, and because T occurs
in A at least one exists; both facts are formally proven for this instance
with the Z3 SMT solver.

Bounded Monotonic Split (n=11, T=1)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

(and (>= equilibrium_index 0)
     (< equilibrium_index 11)
     (=> (= equilibrium_index 0) (= 0 42))
     (=> (= equilibrium_index 1) (= 1 34))
     (=> (= equilibrium_index 2) (= 9 25))
     (=> (= equilibrium_index 3) (= 18 18))
     (=> (= equilibrium_index 4) (= 25 17))
     (=> (= equilibrium_index 5) (= 26 16))
     (=> (= equilibrium_index 6) (= 27 13))
     (=> (= equilibrium_index 7) (= 30 11))
     (=> (= equilibrium_index 8) (= 32 6))
     (=> (= equilibrium_index 9) (= 37 3))
     (=> (= equilibrium_index 10) (= 40 0)))

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 3

the unique equilibrium index

Unique Equilibrium Index (n=11)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

(and (>= equilibrium_index 0)
     (< equilibrium_index 10)
     (=> (= equilibrium_index 0) (= 0 52))
     (=> (= equilibrium_index 1) (= 9 48))
     (=> (= equilibrium_index 2) (= 13 45))
     (=> (= equilibrium_index 3) (= 16 39))
     (=> (= equilibrium_index 4) (= 22 33))
     (=> (= equilibrium_index 5) (= 28 28))
     (=> (= equilibrium_index 6) (= 33 23))
     (=> (= equilibrium_index 7) (= 38 17))
     (=> (= equilibrium_index 8) (= 44 8))
     (=> (= equilibrium_index 9) (= 53 0)))

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

forall i, j in [0, 10): equilibrium(i) & equilibrium(j) -> i == j

Answer: 5

the unique equilibrium index

Unique Equilibrium Index (n=10)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

(and (>= equilibrium_index 0)
     (< equilibrium_index 12)
     (=> (= equilibrium_index 0) (= 0 45))
     (=> (= equilibrium_index 1) (= 8 39))
     (=> (= equilibrium_index 2) (= 14 32))
     (=> (= equilibrium_index 3) (= 21 29))
     (=> (= equilibrium_index 4) (= 24 24))
     (=> (= equilibrium_index 5) (= 29 19))
     (=> (= equilibrium_index 6) (= 34 15))
     (=> (= equilibrium_index 7) (= 38 11))
     (=> (= equilibrium_index 8) (= 42 7))
     (=> (= equilibrium_index 9) (= 46 2))
     (=> (= equilibrium_index 10) (= 51 1))
     (=> (= equilibrium_index 11) (= 52 0)))

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

forall i, j in [0, 12): equilibrium(i) & equilibrium(j) -> i == j

Answer: 4

the unique equilibrium index

You are given a 0-indexed integer array A of length 12. Every element is a
strictly positive integer with 1 <= A[i] <= 9.

An index i is an equilibrium index when the elements strictly before i sum to
the same value as the elements strictly after i:

    A[0] + ... + A[i-1]  ==  A[i+1] + ... + A[n-1]

The provided array contains exactly one equilibrium index; existence and
uniqueness are formally proven for this instance with the Z3 SMT solver.
Print that index.

Unique Equilibrium Index (n=12)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

forall i, j in [0, 14): first_ge(i) & first_ge(j) -> i == j

Answer: 4

the smallest index whose value reaches the threshold

You are given a 0-indexed non-decreasing integer array A of length 14 with
2 <= A[i] <= 9, together with an integer threshold T drawn from the
elements of A itself.

Print the smallest index k such that A[k] >= T. Because the predicate is
defined by minimality there is at most one such index, and because T occurs
in A at least one exists; both facts are formally proven for this instance
with the Z3 SMT solver.

Bounded Monotonic Split (n=14, T=5)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

forall i, j in [0, 13): first_ge(i) & first_ge(j) -> i == j

Answer: 5

the smallest index whose value reaches the threshold

You are given a 0-indexed non-decreasing integer array A of length 13 with
1 <= A[i] <= 9, together with an integer threshold T drawn from the
elements of A itself.

Print the smallest index k such that A[k] >= T. Because the predicate is
defined by minimality there is at most one such index, and because T occurs
in A at least one exists; both facts are formally proven for this instance
with the Z3 SMT solver.

Bounded Monotonic Split (n=13, T=9)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

(and (>= equilibrium_index 0)
     (< equilibrium_index 13)
     (=> (= equilibrium_index 0) (= 0 67))
     (=> (= equilibrium_index 1) (= 8 63))
     (=> (= equilibrium_index 2) (= 12 58))
     (=> (= equilibrium_index 3) (= 17 49))
     (=> (= equilibrium_index 4) (= 26 42))
     (=> (= equilibrium_index 5) (= 33 33))
     (=> (= equilibrium_index 6) (= 42 29))
     (=> (= equilibrium_index 7) (= 46 25))
     (=> (= equilibrium_index 8) (= 50 18))
     (=> (= equilibrium_index 9) (= 57 11))
     (=> (= equilibrium_index 10) (= 64 6))
     (=> (= equilibrium_index 11) (= 69 3))
     (=> (=...

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

forall i, j in [0, 13): equilibrium(i) & equilibrium(j) -> i == j

Answer: 5

the unique equilibrium index

You are given a 0-indexed integer array A of length 13. Every element is a
strictly positive integer with 1 <= A[i] <= 9.

An index i is an equilibrium index when the elements strictly before i sum to
the same value as the elements strictly after i:

    A[0] + ... + A[i-1]  ==  A[i+1] + ... + A[n-1]

The provided array contains exactly one equilibrium index; existence and
uniqueness are formally proven for this instance with the Z3 SMT solver.
Print that index.

Unique Equilibrium Index (n=13)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 6

the smallest index whose value reaches the threshold

You are given a 0-indexed non-decreasing integer array A of length 13 with
0 <= A[i] <= 9, together with an integer threshold T drawn from the
elements of A itself.

Print the smallest index k such that A[k] >= T. Because the predicate is
defined by minimality there is at most one such index, and because T occurs
in A at least one exists; both facts are formally proven for this instance
with the Z3 SMT solver.

Bounded Monotonic Split (n=13, T=9)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

forall i, j in [0, 12): first_ge(i) & first_ge(j) -> i == j

Answer: 1

the smallest index whose value reaches the threshold

Bounded Monotonic Split (n=12, T=3)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 4

the smallest index whose value reaches the threshold

You are given a 0-indexed non-decreasing integer array A of length 11 with
2 <= A[i] <= 9, together with an integer threshold T drawn from the
elements of A itself.

Print the smallest index k such that A[k] >= T. Because the predicate is
defined by minimality there is at most one such index, and because T occurs
in A at least one exists; both facts are formally proven for this instance
with the Z3 SMT solver.

Bounded Monotonic Split (n=11, T=8)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

forall i, j in [0, 10): first_ge(i) & first_ge(j) -> i == j

Answer: 4

the smallest index whose value reaches the threshold

You are given a 0-indexed non-decreasing integer array A of length 10 with
0 <= A[i] <= 9, together with an integer threshold T drawn from the
elements of A itself.

Print the smallest index k such that A[k] >= T. Because the predicate is
defined by minimality there is at most one such index, and because T occurs
in A at least one exists; both facts are formally proven for this instance
with the Z3 SMT solver.

Bounded Monotonic Split (n=10, T=6)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 0

the smallest index whose value reaches the threshold

You are given a 0-indexed non-decreasing integer array A of length 11 with
1 <= A[i] <= 9, together with an integer threshold T drawn from the
elements of A itself.

Print the smallest index k such that A[k] >= T. Because the predicate is
defined by minimality there is at most one such index, and because T occurs
in A at least one exists; both facts are formally proven for this instance
with the Z3 SMT solver.

Bounded Monotonic Split (n=11, T=1)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 0

the smallest index whose value reaches the threshold

You are given a 0-indexed non-decreasing integer array A of length 10 with
1 <= A[i] <= 9, together with an integer threshold T drawn from the
elements of A itself.

Print the smallest index k such that A[k] >= T. Because the predicate is
defined by minimality there is at most one such index, and because T occurs
in A at least one exists; both facts are formally proven for this instance
with the Z3 SMT solver.

Bounded Monotonic Split (n=10, T=1)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

(and (>= equilibrium_index 0)
     (< equilibrium_index 10)
     (=> (= equilibrium_index 0) (= 0 46))
     (=> (= equilibrium_index 1) (= 9 43))
     (=> (= equilibrium_index 2) (= 12 38))
     (=> (= equilibrium_index 3) (= 17 37))
     (=> (= equilibrium_index 4) (= 18 33))
     (=> (= equilibrium_index 5) (= 22 28))
     (=> (= equilibrium_index 6) (= 27 27))
     (=> (= equilibrium_index 7) (= 28 18))
     (=> (= equilibrium_index 8) (= 37 9))
     (=> (= equilibrium_index 9) (= 46 0)))

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 6

the unique equilibrium index

You are given a 0-indexed integer array A of length 10. Every element is a
strictly positive integer with 1 <= A[i] <= 9.

An index i is an equilibrium index when the elements strictly before i sum to
the same value as the elements strictly after i:

    A[0] + ... + A[i-1]  ==  A[i+1] + ... + A[n-1]

The provided array contains exactly one equilibrium index; existence and
uniqueness are formally proven for this instance with the Z3 SMT solver.
Print that index.

Unique Equilibrium Index (n=10)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

(and (>= equilibrium_index 0)
     (< equilibrium_index 10)
     (=> (= equilibrium_index 0) (= 0 32))
     (=> (= equilibrium_index 1) (= 5 30))
     (=> (= equilibrium_index 2) (= 7 22))
     (=> (= equilibrium_index 3) (= 15 19))
     (=> (= equilibrium_index 4) (= 18 18))
     (=> (= equilibrium_index 5) (= 19 16))
     (=> (= equilibrium_index 6) (= 21 13))
     (=> (= equilibrium_index 7) (= 24 8))
     (=> (= equilibrium_index 8) (= 29 5))
     (=> (= equilibrium_index 9) (= 32 0)))

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 4

the unique equilibrium index

Unique Equilibrium Index (n=10)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

(and (>= equilibrium_index 0)
     (< equilibrium_index 10)
     (=> (= equilibrium_index 0) (= 0 26))
     (=> (= equilibrium_index 1) (= 3 18))
     (=> (= equilibrium_index 2) (= 11 11))
     (=> (= equilibrium_index 3) (= 18 10))
     (=> (= equilibrium_index 4) (= 19 9))
     (=> (= equilibrium_index 5) (= 20 7))
     (=> (= equilibrium_index 6) (= 22 5))
     (=> (= equilibrium_index 7) (= 24 4))
     (=> (= equilibrium_index 8) (= 25 3))
     (=> (= equilibrium_index 9) (= 26 0)))

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 2

the unique equilibrium index

Unique Equilibrium Index (n=10)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

(and (>= equilibrium_index 0)
     (< equilibrium_index 14)
     (=> (= equilibrium_index 0) (= 0 72))
     (=> (= equilibrium_index 1) (= 3 67))
     (=> (= equilibrium_index 2) (= 8 63))
     (=> (= equilibrium_index 3) (= 12 54))
     (=> (= equilibrium_index 4) (= 21 48))
     (=> (= equilibrium_index 5) (= 27 41))
     (=> (= equilibrium_index 6) (= 34 34))
     (=> (= equilibrium_index 7) (= 41 28))
     (=> (= equilibrium_index 8) (= 47 25))
     (=> (= equilibrium_index 9) (= 50 21))
     (=> (= equilibrium_index 10) (= 54 13))
     (=> (= equilibrium_index 11) (= 62 11))
     (=> (...

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

forall i, j in [0, 14): equilibrium(i) & equilibrium(j) -> i == j

Answer: 6

the unique equilibrium index

You are given a 0-indexed integer array A of length 14. Every element is a
strictly positive integer with 1 <= A[i] <= 9.

An index i is an equilibrium index when the elements strictly before i sum to
the same value as the elements strictly after i:

    A[0] + ... + A[i-1]  ==  A[i+1] + ... + A[n-1]

The provided array contains exactly one equilibrium index; existence and
uniqueness are formally proven for this instance with the Z3 SMT solver.
Print that index.

Unique Equilibrium Index (n=14)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 11

the smallest index whose value reaches the threshold

You are given a 0-indexed non-decreasing integer array A of length 12 with
1 <= A[i] <= 9, together with an integer threshold T drawn from the
elements of A itself.

Print the smallest index k such that A[k] >= T. Because the predicate is
defined by minimality there is at most one such index, and because T occurs
in A at least one exists; both facts are formally proven for this instance
with the Z3 SMT solver.

Bounded Monotonic Split (n=12, T=9)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

(and (>= equilibrium_index 0)
     (< equilibrium_index 11)
     (=> (= equilibrium_index 0) (= 0 68))
     (=> (= equilibrium_index 1) (= 7 61))
     (=> (= equilibrium_index 2) (= 14 59))
     (=> (= equilibrium_index 3) (= 16 51))
     (=> (= equilibrium_index 4) (= 24 42))
     (=> (= equilibrium_index 5) (= 33 33))
     (=> (= equilibrium_index 6) (= 42 28))
     (=> (= equilibrium_index 7) (= 47 22))
     (=> (= equilibrium_index 8) (= 53 13))
     (=> (= equilibrium_index 9) (= 62 9))
     (=> (= equilibrium_index 10) (= 66 0)))

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

forall i, j in [0, 11): equilibrium(i) & equilibrium(j) -> i == j

Answer: 5

the unique equilibrium index

You are given a 0-indexed integer array A of length 11. Every element is a
strictly positive integer with 1 <= A[i] <= 9.

An index i is an equilibrium index when the elements strictly before i sum to
the same value as the elements strictly after i:

    A[0] + ... + A[i-1]  ==  A[i+1] + ... + A[n-1]

The provided array contains exactly one equilibrium index; existence and
uniqueness are formally proven for this instance with the Z3 SMT solver.
Print that index.

Unique Equilibrium Index (n=11)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 7

the smallest index whose value reaches the threshold

You are given a 0-indexed non-decreasing integer array A of length 12 with
0 <= A[i] <= 9, together with an integer threshold T drawn from the
elements of A itself.

Print the smallest index k such that A[k] >= T. Because the predicate is
defined by minimality there is at most one such index, and because T occurs
in A at least one exists; both facts are formally proven for this instance
with the Z3 SMT solver.

Bounded Monotonic Split (n=12, T=9)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

forall i, j in [0, 11): first_ge(i) & first_ge(j) -> i == j

Answer: 5

the smallest index whose value reaches the threshold

Bounded Monotonic Split (n=11, T=4)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 5

the smallest index whose value reaches the threshold

You are given a 0-indexed non-decreasing integer array A of length 12 with
2 <= A[i] <= 9, together with an integer threshold T drawn from the
elements of A itself.

Print the smallest index k such that A[k] >= T. Because the predicate is
defined by minimality there is at most one such index, and because T occurs
in A at least one exists; both facts are formally proven for this instance
with the Z3 SMT solver.

Bounded Monotonic Split (n=12, T=7)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

(and (>= equilibrium_index 0)
     (< equilibrium_index 12)
     (=> (= equilibrium_index 0) (= 0 56))
     (=> (= equilibrium_index 1) (= 5 52))
     (=> (= equilibrium_index 2) (= 9 46))
     (=> (= equilibrium_index 3) (= 15 39))
     (=> (= equilibrium_index 4) (= 22 37))
     (=> (= equilibrium_index 5) (= 24 35))
     (=> (= equilibrium_index 6) (= 26 34))
     (=> (= equilibrium_index 7) (= 27 27))
     (=> (= equilibrium_index 8) (= 34 20))
     (=> (= equilibrium_index 9) (= 41 11))
     (=> (= equilibrium_index 10) (= 50 6))
     (=> (= equilibrium_index 11) (= 55 0)))

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 7

the unique equilibrium index

Unique Equilibrium Index (n=12)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

(and (>= equilibrium_index 0)
     (< equilibrium_index 13)
     (=> (= equilibrium_index 0) (= 0 45))
     (=> (= equilibrium_index 1) (= 6 43))
     (=> (= equilibrium_index 2) (= 8 37))
     (=> (= equilibrium_index 3) (= 14 32))
     (=> (= equilibrium_index 4) (= 19 29))
     (=> (= equilibrium_index 5) (= 22 22))
     (=> (= equilibrium_index 6) (= 29 21))
     (=> (= equilibrium_index 7) (= 30 16))
     (=> (= equilibrium_index 8) (= 35 12))
     (=> (= equilibrium_index 9) (= 39 8))
     (=> (= equilibrium_index 10) (= 43 5))
     (=> (= equilibrium_index 11) (= 46 3))
     (=> (= e...

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 5

the unique equilibrium index

Unique Equilibrium Index (n=13)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 2

the smallest index whose value reaches the threshold

Bounded Monotonic Split (n=10, T=4)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 1

the smallest index whose value reaches the threshold

You are given a 0-indexed non-decreasing integer array A of length 14 with
1 <= A[i] <= 9, together with an integer threshold T drawn from the
elements of A itself.

Print the smallest index k such that A[k] >= T. Because the predicate is
defined by minimality there is at most one such index, and because T occurs
in A at least one exists; both facts are formally proven for this instance
with the Z3 SMT solver.

Bounded Monotonic Split (n=14, T=3)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 6

the smallest index whose value reaches the threshold

Bounded Monotonic Split (n=10, T=9)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

(and (>= equilibrium_index 0)
     (< equilibrium_index 13)
     (=> (= equilibrium_index 0) (= 0 83))
     (=> (= equilibrium_index 1) (= 8 75))
     (=> (= equilibrium_index 2) (= 16 69))
     (=> (= equilibrium_index 3) (= 22 67))
     (=> (= equilibrium_index 4) (= 24 63))
     (=> (= equilibrium_index 5) (= 28 54))
     (=> (= equilibrium_index 6) (= 37 47))
     (=> (= equilibrium_index 7) (= 44 44))
     (=> (= equilibrium_index 8) (= 47 36))
     (=> (= equilibrium_index 9) (= 55 27))
     (=> (= equilibrium_index 10) (= 64 18))
     (=> (= equilibrium_index 11) (= 73 9))
     (=> (...

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 7

the unique equilibrium index

Unique Equilibrium Index (n=13)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

forall i, j in [0, 14): first_ge(i) & first_ge(j) -> i == j

Answer: 8

the smallest index whose value reaches the threshold

Bounded Monotonic Split (n=14, T=9)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

forall i, j in [0, 15): first_ge(i) & first_ge(j) -> i == j

Answer: 6

the smallest index whose value reaches the threshold

You are given a 0-indexed non-decreasing integer array A of length 15 with
2 <= A[i] <= 9, together with an integer threshold T drawn from the
elements of A itself.

Print the smallest index k such that A[k] >= T. Because the predicate is
defined by minimality there is at most one such index, and because T occurs
in A at least one exists; both facts are formally proven for this instance
with the Z3 SMT solver.

Bounded Monotonic Split (n=15, T=9)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

forall i, j in [0, 21): first_ge(i) & first_ge(j) -> i == j

Answer: 5

the smallest index whose value reaches the threshold

You are given a 0-indexed non-decreasing integer array A of length 21 with
0 <= A[i] <= 9, together with an integer threshold T drawn from the
elements of A itself.

Print the smallest index k such that A[k] >= T. Because the predicate is
defined by minimality there is at most one such index, and because T occurs
in A at least one exists; both facts are formally proven for this instance
with the Z3 SMT solver.

Bounded Monotonic Split (n=21, T=6)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 4

the smallest index whose value reaches the threshold

Bounded Monotonic Split (n=15, T=9)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

forall i, j in [0, 24): first_ge(i) & first_ge(j) -> i == j

Answer: 8

the smallest index whose value reaches the threshold

You are given a 0-indexed non-decreasing integer array A of length 24 with
2 <= A[i] <= 9, together with an integer threshold T drawn from the
elements of A itself.

Print the smallest index k such that A[k] >= T. Because the predicate is
defined by minimality there is at most one such index, and because T occurs
in A at least one exists; both facts are formally proven for this instance
with the Z3 SMT solver.

Bounded Monotonic Split (n=24, T=9)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

forall i, j in [0, 19): first_ge(i) & first_ge(j) -> i == j

Answer: 3

the smallest index whose value reaches the threshold

You are given a 0-indexed non-decreasing integer array A of length 19 with
0 <= A[i] <= 9, together with an integer threshold T drawn from the
elements of A itself.

Print the smallest index k such that A[k] >= T. Because the predicate is
defined by minimality there is at most one such index, and because T occurs
in A at least one exists; both facts are formally proven for this instance
with the Z3 SMT solver.

Bounded Monotonic Split (n=19, T=3)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

(and (>= equilibrium_index 0)
     (< equilibrium_index 23)
     (=> (= equilibrium_index 0) (= 0 82))
     (=> (= equilibrium_index 1) (= 1 79))
     (=> (= equilibrium_index 2) (= 4 77))
     (=> (= equilibrium_index 3) (= 6 71))
     (=> (= equilibrium_index 4) (= 12 66))
     (=> (= equilibrium_index 5) (= 17 58))
     (=> (= equilibrium_index 6) (= 25 57))
     (=> (= equilibrium_index 7) (= 26 53))
     (=> (= equilibrium_index 8) (= 30 46))
     (=> (= equilibrium_index 9) (= 37 37))
     (=> (= equilibrium_index 10) (= 46 33))
     (=> (= equilibrium_index 11) (= 50 30))
     (=> (=...

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

forall i, j in [0, 23): equilibrium(i) & equilibrium(j) -> i == j

Answer: 9

the unique equilibrium index

You are given a 0-indexed integer array A of length 23. Every element is a
strictly positive integer with 1 <= A[i] <= 9.

An index i is an equilibrium index when the elements strictly before i sum to
the same value as the elements strictly after i:

    A[0] + ... + A[i-1]  ==  A[i+1] + ... + A[n-1]

The provided array contains exactly one equilibrium index; existence and
uniqueness are formally proven for this instance with the Z3 SMT solver.
Print that index.

Unique Equilibrium Index (n=23)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

forall i, j in [0, 16): first_ge(i) & first_ge(j) -> i == j

Answer: 4

the smallest index whose value reaches the threshold

You are given a 0-indexed non-decreasing integer array A of length 16 with
2 <= A[i] <= 9, together with an integer threshold T drawn from the
elements of A itself.

Print the smallest index k such that A[k] >= T. Because the predicate is
defined by minimality there is at most one such index, and because T occurs
in A at least one exists; both facts are formally proven for this instance
with the Z3 SMT solver.

Bounded Monotonic Split (n=16, T=8)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 10

the smallest index whose value reaches the threshold

You are given a 0-indexed non-decreasing integer array A of length 19 with
1 <= A[i] <= 9, together with an integer threshold T drawn from the
elements of A itself.

Print the smallest index k such that A[k] >= T. Because the predicate is
defined by minimality there is at most one such index, and because T occurs
in A at least one exists; both facts are formally proven for this instance
with the Z3 SMT solver.

Bounded Monotonic Split (n=19, T=9)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

(and (>= equilibrium_index 0)
     (< equilibrium_index 16)
     (=> (= equilibrium_index 0) (= 0 35))
     (=> (= equilibrium_index 1) (= 6 32))
     (=> (= equilibrium_index 2) (= 9 28))
     (=> (= equilibrium_index 3) (= 13 22))
     (=> (= equilibrium_index 4) (= 19 19))
     (=> (= equilibrium_index 5) (= 22 17))
     (=> (= equilibrium_index 6) (= 24 15))
     (=> (= equilibrium_index 7) (= 26 14))
     (=> (= equilibrium_index 8) (= 27 13))
     (=> (= equilibrium_index 9) (= 28 10))
     (=> (= equilibrium_index 10) (= 31 9))
     (=> (= equilibrium_index 11) (= 32 7))
     (=> (= ...

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

forall i, j in [0, 16): equilibrium(i) & equilibrium(j) -> i == j

Answer: 4

the unique equilibrium index

You are given a 0-indexed integer array A of length 16. Every element is a
strictly positive integer with 1 <= A[i] <= 9.

An index i is an equilibrium index when the elements strictly before i sum to
the same value as the elements strictly after i:

    A[0] + ... + A[i-1]  ==  A[i+1] + ... + A[n-1]

The provided array contains exactly one equilibrium index; existence and
uniqueness are formally proven for this instance with the Z3 SMT solver.
Print that index.

Unique Equilibrium Index (n=16)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

(and (>= equilibrium_index 0)
     (< equilibrium_index 21)
     (=> (= equilibrium_index 0) (= 0 68))
     (=> (= equilibrium_index 1) (= 4 61))
     (=> (= equilibrium_index 2) (= 11 54))
     (=> (= equilibrium_index 3) (= 18 49))
     (=> (= equilibrium_index 4) (= 23 42))
     (=> (= equilibrium_index 5) (= 30 40))
     (=> (= equilibrium_index 6) (= 32 39))
     (=> (= equilibrium_index 7) (= 33 33))
     (=> (= equilibrium_index 8) (= 39 31))
     (=> (= equilibrium_index 9) (= 41 26))
     (=> (= equilibrium_index 10) (= 46 24))
     (=> (= equilibrium_index 11) (= 48 21))
     (=> ...

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

forall i, j in [0, 21): equilibrium(i) & equilibrium(j) -> i == j

Answer: 7

the unique equilibrium index

You are given a 0-indexed integer array A of length 21. Every element is a
strictly positive integer with 1 <= A[i] <= 9.

An index i is an equilibrium index when the elements strictly before i sum to
the same value as the elements strictly after i:

    A[0] + ... + A[i-1]  ==  A[i+1] + ... + A[n-1]

The provided array contains exactly one equilibrium index; existence and
uniqueness are formally proven for this instance with the Z3 SMT solver.
Print that index.

Unique Equilibrium Index (n=21)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

(and (>= equilibrium_index 0)
     (< equilibrium_index 16)
     (=> (= equilibrium_index 0) (= 0 37))
     (=> (= equilibrium_index 1) (= 9 35))
     (=> (= equilibrium_index 2) (= 11 27))
     (=> (= equilibrium_index 3) (= 19 19))
     (=> (= equilibrium_index 4) (= 27 16))
     (=> (= equilibrium_index 5) (= 30 15))
     (=> (= equilibrium_index 6) (= 31 14))
     (=> (= equilibrium_index 7) (= 32 12))
     (=> (= equilibrium_index 8) (= 34 10))
     (=> (= equilibrium_index 9) (= 36 9))
     (=> (= equilibrium_index 10) (= 37 8))
     (=> (= equilibrium_index 11) (= 38 7))
     (=> (= ...

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 3

the unique equilibrium index

Unique Equilibrium Index (n=16)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

(and (>= equilibrium_index 0)
     (< equilibrium_index 19)
     (=> (= equilibrium_index 0) (= 0 32))
     (=> (= equilibrium_index 1) (= 3 26))
     (=> (= equilibrium_index 2) (= 9 20))
     (=> (= equilibrium_index 3) (= 15 15))
     (=> (= equilibrium_index 4) (= 20 14))
     (=> (= equilibrium_index 5) (= 21 13))
     (=> (= equilibrium_index 6) (= 22 12))
     (=> (= equilibrium_index 7) (= 23 11))
     (=> (= equilibrium_index 8) (= 24 10))
     (=> (= equilibrium_index 9) (= 25 9))
     (=> (= equilibrium_index 10) (= 26 8))
     (=> (= equilibrium_index 11) (= 27 7))
     (=> (= e...

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

forall i, j in [0, 19): equilibrium(i) & equilibrium(j) -> i == j

Answer: 3

the unique equilibrium index

You are given a 0-indexed integer array A of length 19. Every element is a
strictly positive integer with 1 <= A[i] <= 9.

An index i is an equilibrium index when the elements strictly before i sum to
the same value as the elements strictly after i:

    A[0] + ... + A[i-1]  ==  A[i+1] + ... + A[n-1]

The provided array contains exactly one equilibrium index; existence and
uniqueness are formally proven for this instance with the Z3 SMT solver.
Print that index.

Unique Equilibrium Index (n=19)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 8

the smallest index whose value reaches the threshold

You are given a 0-indexed non-decreasing integer array A of length 15 with
1 <= A[i] <= 9, together with an integer threshold T drawn from the
elements of A itself.

Print the smallest index k such that A[k] >= T. Because the predicate is
defined by minimality there is at most one such index, and because T occurs
in A at least one exists; both facts are formally proven for this instance
with the Z3 SMT solver.

Bounded Monotonic Split (n=15, T=9)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

(and (>= equilibrium_index 0)
     (< equilibrium_index 21)
     (=> (= equilibrium_index 0) (= 0 53))
     (=> (= equilibrium_index 1) (= 2 52))
     (=> (= equilibrium_index 2) (= 3 44))
     (=> (= equilibrium_index 3) (= 11 42))
     (=> (= equilibrium_index 4) (= 13 38))
     (=> (= equilibrium_index 5) (= 17 36))
     (=> (= equilibrium_index 6) (= 19 28))
     (=> (= equilibrium_index 7) (= 27 27))
     (=> (= equilibrium_index 8) (= 28 25))
     (=> (= equilibrium_index 9) (= 30 23))
     (=> (= equilibrium_index 10) (= 32 22))
     (=> (= equilibrium_index 11) (= 33 21))
     (=> (...

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 7

the unique equilibrium index

Unique Equilibrium Index (n=21)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

(and (>= equilibrium_index 0)
     (< equilibrium_index 24)
     (=> (= equilibrium_index 0) (= 0 76))
     (=> (= equilibrium_index 1) (= 4 70))
     (=> (= equilibrium_index 2) (= 10 63))
     (=> (= equilibrium_index 3) (= 17 56))
     (=> (= equilibrium_index 4) (= 24 50))
     (=> (= equilibrium_index 5) (= 30 49))
     (=> (= equilibrium_index 6) (= 31 43))
     (=> (= equilibrium_index 7) (= 37 37))
     (=> (= equilibrium_index 8) (= 43 36))
     (=> (= equilibrium_index 9) (= 44 33))
     (=> (= equilibrium_index 10) (= 47 31))
     (=> (= equilibrium_index 11) (= 49 29))
     (=> ...

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

forall i, j in [0, 24): equilibrium(i) & equilibrium(j) -> i == j

Answer: 7

the unique equilibrium index

You are given a 0-indexed integer array A of length 24. Every element is a
strictly positive integer with 1 <= A[i] <= 9.

An index i is an equilibrium index when the elements strictly before i sum to
the same value as the elements strictly after i:

    A[0] + ... + A[i-1]  ==  A[i+1] + ... + A[n-1]

The provided array contains exactly one equilibrium index; existence and
uniqueness are formally proven for this instance with the Z3 SMT solver.
Print that index.

Unique Equilibrium Index (n=24)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 6

the smallest index whose value reaches the threshold

You are given a 0-indexed non-decreasing integer array A of length 24 with
1 <= A[i] <= 9, together with an integer threshold T drawn from the
elements of A itself.

Print the smallest index k such that A[k] >= T. Because the predicate is
defined by minimality there is at most one such index, and because T occurs
in A at least one exists; both facts are formally proven for this instance
with the Z3 SMT solver.

Bounded Monotonic Split (n=24, T=9)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

(and (>= equilibrium_index 0)
     (< equilibrium_index 18)
     (=> (= equilibrium_index 0) (= 0 33))
     (=> (= equilibrium_index 1) (= 6 32))
     (=> (= equilibrium_index 2) (= 7 25))
     (=> (= equilibrium_index 3) (= 14 20))
     (=> (= equilibrium_index 4) (= 19 19))
     (=> (= equilibrium_index 5) (= 20 17))
     (=> (= equilibrium_index 6) (= 22 16))
     (=> (= equilibrium_index 7) (= 23 13))
     (=> (= equilibrium_index 8) (= 26 12))
     (=> (= equilibrium_index 9) (= 27 11))
     (=> (= equilibrium_index 10) (= 28 10))
     (=> (= equilibrium_index 11) (= 29 9))
     (=> (=...

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

forall i, j in [0, 18): equilibrium(i) & equilibrium(j) -> i == j

Answer: 4

the unique equilibrium index

You are given a 0-indexed integer array A of length 18. Every element is a
strictly positive integer with 1 <= A[i] <= 9.

An index i is an equilibrium index when the elements strictly before i sum to
the same value as the elements strictly after i:

    A[0] + ... + A[i-1]  ==  A[i+1] + ... + A[n-1]

The provided array contains exactly one equilibrium index; existence and
uniqueness are formally proven for this instance with the Z3 SMT solver.
Print that index.

Unique Equilibrium Index (n=18)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

(and (>= equilibrium_index 0)
     (< equilibrium_index 21)
     (=> (= equilibrium_index 0) (= 0 77))
     (=> (= equilibrium_index 1) (= 2 71))
     (=> (= equilibrium_index 2) (= 8 62))
     (=> (= equilibrium_index 3) (= 17 58))
     (=> (= equilibrium_index 4) (= 21 50))
     (=> (= equilibrium_index 5) (= 29 41))
     (=> (= equilibrium_index 6) (= 38 38))
     (=> (= equilibrium_index 7) (= 41 36))
     (=> (= equilibrium_index 8) (= 43 35))
     (=> (= equilibrium_index 9) (= 44 32))
     (=> (= equilibrium_index 10) (= 47 29))
     (=> (= equilibrium_index 11) (= 50 27))
     (=> (...

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 6

the unique equilibrium index

Unique Equilibrium Index (n=21)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

(and (>= equilibrium_index 0)
     (< equilibrium_index 19)
     (=> (= equilibrium_index 0) (= 0 108))
     (=> (= equilibrium_index 1) (= 9 104))
     (=> (= equilibrium_index 2) (= 13 103))
     (=> (= equilibrium_index 3) (= 14 100))
     (=> (= equilibrium_index 4) (= 17 94))
     (=> (= equilibrium_index 5) (= 23 85))
     (=> (= equilibrium_index 6) (= 32 79))
     (=> (= equilibrium_index 7) (= 38 70))
     (=> (= equilibrium_index 8) (= 47 61))
     (=> (= equilibrium_index 9) (= 56 56))
     (=> (= equilibrium_index 10) (= 61 47))
     (=> (= equilibrium_index 11) (= 70 42))
     ...

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 9

the unique equilibrium index

Unique Equilibrium Index (n=19)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

forall i, j in [0, 17): first_ge(i) & first_ge(j) -> i == j

Answer: 5

the smallest index whose value reaches the threshold

You are given a 0-indexed non-decreasing integer array A of length 17 with
2 <= A[i] <= 9, together with an integer threshold T drawn from the
elements of A itself.

Print the smallest index k such that A[k] >= T. Because the predicate is
defined by minimality there is at most one such index, and because T occurs
in A at least one exists; both facts are formally proven for this instance
with the Z3 SMT solver.

Bounded Monotonic Split (n=17, T=8)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

(and (>= equilibrium_index 0)
     (< equilibrium_index 20)
     (=> (= equilibrium_index 0) (= 0 58))
     (=> (= equilibrium_index 1) (= 6 51))
     (=> (= equilibrium_index 2) (= 13 42))
     (=> (= equilibrium_index 3) (= 22 37))
     (=> (= equilibrium_index 4) (= 27 36))
     (=> (= equilibrium_index 5) (= 28 28))
     (=> (= equilibrium_index 6) (= 36 23))
     (=> (= equilibrium_index 7) (= 41 20))
     (=> (= equilibrium_index 8) (= 44 19))
     (=> (= equilibrium_index 9) (= 45 18))
     (=> (= equilibrium_index 10) (= 46 17))
     (=> (= equilibrium_index 11) (= 47 15))
     (=> ...

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

forall i, j in [0, 20): equilibrium(i) & equilibrium(j) -> i == j

Answer: 5

the unique equilibrium index

You are given a 0-indexed integer array A of length 20. Every element is a
strictly positive integer with 1 <= A[i] <= 9.

An index i is an equilibrium index when the elements strictly before i sum to
the same value as the elements strictly after i:

    A[0] + ... + A[i-1]  ==  A[i+1] + ... + A[n-1]

The provided array contains exactly one equilibrium index; existence and
uniqueness are formally proven for this instance with the Z3 SMT solver.
Print that index.

Unique Equilibrium Index (n=20)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 5

the smallest index whose value reaches the threshold

You are given a 0-indexed non-decreasing integer array A of length 17 with
1 <= A[i] <= 9, together with an integer threshold T drawn from the
elements of A itself.

Print the smallest index k such that A[k] >= T. Because the predicate is
defined by minimality there is at most one such index, and because T occurs
in A at least one exists; both facts are formally proven for this instance
with the Z3 SMT solver.

Bounded Monotonic Split (n=17, T=5)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

(and (>= equilibrium_index 0)
     (< equilibrium_index 15)
     (=> (= equilibrium_index 0) (= 0 30))
     (=> (= equilibrium_index 1) (= 2 29))
     (=> (= equilibrium_index 2) (= 3 26))
     (=> (= equilibrium_index 3) (= 6 19))
     (=> (= equilibrium_index 4) (= 13 13))
     (=> (= equilibrium_index 5) (= 19 12))
     (=> (= equilibrium_index 6) (= 20 11))
     (=> (= equilibrium_index 7) (= 21 10))
     (=> (= equilibrium_index 8) (= 22 8))
     (=> (= equilibrium_index 9) (= 24 7))
     (=> (= equilibrium_index 10) (= 25 4))
     (=> (= equilibrium_index 11) (= 28 3))
     (=> (= equ...

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

forall i, j in [0, 15): equilibrium(i) & equilibrium(j) -> i == j

Answer: 4

the unique equilibrium index

You are given a 0-indexed integer array A of length 15. Every element is a
strictly positive integer with 1 <= A[i] <= 9.

An index i is an equilibrium index when the elements strictly before i sum to
the same value as the elements strictly after i:

    A[0] + ... + A[i-1]  ==  A[i+1] + ... + A[n-1]

The provided array contains exactly one equilibrium index; existence and
uniqueness are formally proven for this instance with the Z3 SMT solver.
Print that index.

Unique Equilibrium Index (n=15)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

forall i, j in [0, 16): first_ge(i) & first_ge(j) -> i == j

Answer: 5

the smallest index whose value reaches the threshold

Bounded Monotonic Split (n=16, T=8)


Every array element lies inside the declared inclusive range.

The declarative encoding of the task over the concrete array; Z3 reports this system satisfiable, so an answer exists.

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

forall i, j in [0, 18): first_ge(i) & first_ge(j) -> i == j

Answer: 12

the smallest index whose value reaches the threshold

You are given a 0-indexed non-decreasing integer array A of length 18 with
1 <= A[i] <= 9, together with an integer threshold T drawn from the
elements of A itself.

Print the smallest index k such that A[k] >= T. Because the predicate is
defined by minimality there is at most one such index, and because T occurs
in A at least one exists; both facts are formally proven for this instance
with the Z3 SMT solver.

Bounded Monotonic Split (n=18, T=9)


Label-increasing edges guarantee acyclicity by construction.

the input is a DAG: every edge (u, v) satisfies u < v, weights lie in [1, 9]

The declarative semantics of the task over the concrete graph; Z3 reports this system satisfiable.

(and member_0
     (=> member_0 member_1)
     (=> member_1 member_2)
     (=> member_1 (or member_0))
     (=> member_2 (or member_1))
     (= reachable_count
        (+ (ite member_0 1 0) (ite member_1 1 0) (ite member_2 1 0))))

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

the defining fixpoint admits exactly one value

Answer: 3

the unique verified answer

import json
import sys

data = json.load(sys.stdin)
n = data["num_vertices"]
adjacency = data["adjacency"]
source = data["source"]

seen = [0] * n
seen[source] = 1
stack = [source]
while stack:
    vertex = stack.pop()
    for nxt in adjacency[vertex]:
        if not seen[nxt]:
            seen[nxt] = 1
            stack.append(nxt)
total = 0
for flag in seen:
    if flag:
        total += 1
print(total)

You are given a directed acyclic graph with 3 vertices labelled 0 to 2,
described by adjacency lists. Starting from the source vertex s = 0, a
vertex is reachable when some directed path leads to it; the source itself is
always reachable.

Print how many vertices are reachable from s. The exact count is unique and
its uniqueness has been formally proven for this instance with the Z3 SMT
solver.

DAG Reachability Count (n=3)


Label-increasing edges guarantee acyclicity by construction.

The declarative semantics of the task over the concrete graph; Z3 reports this system satisfiable.

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 4

the unique verified answer

import json
import sys

data = json.load(sys.stdin)
n = data["num_vertices"]
edges = data["edges"]
source = data["source"]
target = data["target"]

infinity = float("inf")
dist = [infinity] * n
dist[source] = 0
for u, v, w in edges:
    if dist[u] != infinity and dist[u] + w < dist[v]:
        dist[v] = dist[u] + w
print(dist[target])

You are given a directed acyclic graph with 3 vertices labelled 0 to
2. Every edge [u, v, w] goes from a lower to a higher label and has
integer weight 1 <= w <= 9; edges are listed in ascending (u, v) order.

Print the minimum possible total weight of a path from source s = 0 to
target t = 2. The target is guaranteed reachable, the optimum is
unique, and both facts have been formally proven for this instance with the
Z3 SMT solver.

DAG Shortest Path (n=3, weight 4)


Label-increasing edges guarantee acyclicity by construction.

The declarative semantics of the task over the concrete graph; Z3 reports this system satisfiable.

(and member_0
     (=> member_0 member_1)
     (=> member_0 member_2)
     (=> member_1 (or member_0))
     (=> member_2 (or member_0))
     (= reachable_count
        (+ (ite member_0 1 0) (ite member_1 1 0) (ite member_2 1 0))))

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 3

the unique verified answer

DAG Reachability Count (n=3)


Label-increasing edges guarantee acyclicity by construction.

The declarative semantics of the task over the concrete graph; Z3 reports this system satisfiable.

(and member_0
     (=> member_0 member_1)
     (=> member_0 member_2)
     (=> member_1 member_3)
     (=> member_1 (or member_0))
     (=> member_2 (or member_0))
     (=> member_3 (or member_1))
     (= reachable_count
        (+ (ite member_0 1 0)
           (ite member_1 1 0)
           (ite member_2 1 0)
           (ite member_3 1 0))))

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 4

the unique verified answer

You are given a directed acyclic graph with 4 vertices labelled 0 to 3,
described by adjacency lists. Starting from the source vertex s = 0, a
vertex is reachable when some directed path leads to it; the source itself is
always reachable.

Print how many vertices are reachable from s. The exact count is unique and
its uniqueness has been formally proven for this instance with the Z3 SMT
solver.

DAG Reachability Count (n=4)


Label-increasing edges guarantee acyclicity by construction.

The declarative semantics of the task over the concrete graph; Z3 reports this system satisfiable.

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 1

the unique verified answer

import json
import sys

data = json.load(sys.stdin)
n = data["num_vertices"]
edges = data["edges"]
target_vertex = data["target_vertex"]

successors = [[] for _ in range(n)]
predecessors = [[] for _ in range(n)]
for u, v in edges:
    successors[u].append(v)
    predecessors[v].append(u)

indegree = [len(preds) for preds in predecessors]
order = []
ready = [vertex for vertex in range(n) if indegree[vertex] < 1]
while ready:
    ready.sort()
    current = ready.pop(0)
    order.append(current)
    if current == target_vertex:
        break
    for nxt in successors[current]:
        indegree[nxt] -= 1
        if indegree[nxt] < 1:
            ready.append(nxt)

print(order.index(target_vertex))

You are given a directed acyclic graph with 4 vertices labelled 0 to
3 and edge list [u, v].

Run Kahn's algorithm with lexicographic tie-breaking: repeatedly remove the
smallest-labelled vertex whose remaining in-degree is zero, appending it to
the removal order (rounds are numbered from 0). Print the round at which the
designated vertex 1 is removed. The resulting removal order is unique;
existence and uniqueness of the answer have been formally proven with the
Z3 SMT solver.

DAG Topological Position (n=4, vertex 1)


Label-increasing edges guarantee acyclicity by construction.

The declarative semantics of the task over the concrete graph; Z3 reports this system satisfiable.

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 9

the unique verified answer

You are given a directed acyclic graph with 4 vertices labelled 0 to
3. Every edge [u, v, w] goes from a lower to a higher label and has
integer weight 1 <= w <= 9; edges are listed in ascending (u, v) order.

Print the minimum possible total weight of a path from source s = 0 to
target t = 3. The target is guaranteed reachable, the optimum is
unique, and both facts have been formally proven for this instance with the
Z3 SMT solver.

DAG Shortest Path (n=4, weight 9)


Label-increasing edges guarantee acyclicity by construction.

The declarative semantics of the task over the concrete graph; Z3 reports this system satisfiable.

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 16

the unique verified answer

DAG Shortest Path (n=4, weight 16)


Label-increasing edges guarantee acyclicity by construction.

The declarative semantics of the task over the concrete graph; Z3 reports this system satisfiable.

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 3

the unique verified answer

DAG Reachability Count (n=3)


Label-increasing edges guarantee acyclicity by construction.

The declarative semantics of the task over the concrete graph; Z3 reports this system satisfiable.

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 10

the unique verified answer

DAG Shortest Path (n=4, weight 10)


Label-increasing edges guarantee acyclicity by construction.

The declarative semantics of the task over the concrete graph; Z3 reports this system satisfiable.

(and member_0
     (=> member_0 member_1)
     (=> member_1 member_2)
     (=> member_1 member_3)
     (=> member_1 (or member_0))
     (=> member_2 (or member_1))
     (=> member_3 (or member_1))
     (= reachable_count
        (+ (ite member_0 1 0)
           (ite member_1 1 0)
           (ite member_2 1 0)
           (ite member_3 1 0))))

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 4

the unique verified answer

DAG Reachability Count (n=4)


Label-increasing edges guarantee acyclicity by construction.

The declarative semantics of the task over the concrete graph; Z3 reports this system satisfiable.

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 3

the unique verified answer

DAG Reachability Count (n=3)


Label-increasing edges guarantee acyclicity by construction.

The declarative semantics of the task over the concrete graph; Z3 reports this system satisfiable.

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 11

the unique verified answer

DAG Shortest Path (n=3, weight 11)


Label-increasing edges guarantee acyclicity by construction.

The declarative semantics of the task over the concrete graph; Z3 reports this system satisfiable.

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 2

the unique verified answer

You are given a directed acyclic graph with 3 vertices labelled 0 to
2 and edge list [u, v].

Run Kahn's algorithm with lexicographic tie-breaking: repeatedly remove the
smallest-labelled vertex whose remaining in-degree is zero, appending it to
the removal order (rounds are numbered from 0). Print the round at which the
designated vertex 2 is removed. The resulting removal order is unique;
existence and uniqueness of the answer have been formally proven with the
Z3 SMT solver.

DAG Topological Position (n=3, vertex 2)


Label-increasing edges guarantee acyclicity by construction.

The declarative semantics of the task over the concrete graph; Z3 reports this system satisfiable.

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 1

the unique verified answer

DAG Topological Position (n=4, vertex 1)


Label-increasing edges guarantee acyclicity by construction.

The declarative semantics of the task over the concrete graph; Z3 reports this system satisfiable.

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 2

the unique verified answer

You are given a directed acyclic graph with 4 vertices labelled 0 to
3 and edge list [u, v].

Run Kahn's algorithm with lexicographic tie-breaking: repeatedly remove the
smallest-labelled vertex whose remaining in-degree is zero, appending it to
the removal order (rounds are numbered from 0). Print the round at which the
designated vertex 2 is removed. The resulting removal order is unique;
existence and uniqueness of the answer have been formally proven with the
Z3 SMT solver.

DAG Topological Position (n=4, vertex 2)


Label-increasing edges guarantee acyclicity by construction.

The declarative semantics of the task over the concrete graph; Z3 reports this system satisfiable.

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 1

the unique verified answer

DAG Topological Position (n=4, vertex 1)


Label-increasing edges guarantee acyclicity by construction.

The declarative semantics of the task over the concrete graph; Z3 reports this system satisfiable.

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 3

the unique verified answer

You are given a directed acyclic graph with 4 vertices labelled 0 to
3 and edge list [u, v].

Run Kahn's algorithm with lexicographic tie-breaking: repeatedly remove the
smallest-labelled vertex whose remaining in-degree is zero, appending it to
the removal order (rounds are numbered from 0). Print the round at which the
designated vertex 3 is removed. The resulting removal order is unique;
existence and uniqueness of the answer have been formally proven with the
Z3 SMT solver.

DAG Topological Position (n=4, vertex 3)


Label-increasing edges guarantee acyclicity by construction.

The declarative semantics of the task over the concrete graph; Z3 reports this system satisfiable.

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 2

the unique verified answer

DAG Topological Position (n=4, vertex 2)


Label-increasing edges guarantee acyclicity by construction.

The declarative semantics of the task over the concrete graph; Z3 reports this system satisfiable.

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 2

the unique verified answer

DAG Topological Position (n=3, vertex 2)


Label-increasing edges guarantee acyclicity by construction.

The declarative semantics of the task over the concrete graph; Z3 reports this system satisfiable.

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 4

the unique verified answer

DAG Shortest Path (n=3, weight 4)


Label-increasing edges guarantee acyclicity by construction.

The declarative semantics of the task over the concrete graph; Z3 reports this system satisfiable.

Proven by Z3 model exclusion: blocking the witness model makes the system unsatisfiable.

Answer: 2

the unique verified answer

DAG Topological Position (n=3, vertex 2)