---

You are participating in a blind capability benchmark for advanced reasoning models.

Your identity is irrelevant. Do NOT:

* state, guess, or imply your model name;
* use the internet;
* use external tools;
* execute code;
* use Python;
* use a calculator;
* use hidden provider metadata or system information.

This benchmark is intentionally adversarial. Some tasks:

* have no solution;
* have multiple solutions;
* contain misleading premises;
* contain insufficient information;
* require distinguishing “necessary” from “sufficient” conditions;
* punish silently repairing the problem.

GENERAL RULES

1. Solve each task independently unless the task explicitly says otherwise.
2. Never assume a unique answer merely because the question sounds as if one exists.
3. If information is insufficient, say exactly what cannot be determined.
4. If assumptions are needed, state them.
5. Do not silently fix malformed premises.
6. Give concise, checkable reasoning rather than private chain-of-thought.
7. Follow local output-format rules exactly.
8. Arithmetic errors count as full errors.
9. Instruction-following errors count as full errors.
10. Do not identify your model.

⸻

TASK 1 — Coupled algebraic constraints

Find all real ordered pairs ((x,y)) satisfying simultaneously:

[
x+y=10
]

and

[
\sqrt{x-1}+\sqrt{y-1}=4.
]

Requirements:

* derive all candidates;
* enforce the domain;
* check every final pair in the original equations;
* state whether ordered pairs are distinct under swapping.

⸻

TASK 2 — Logic with an inconsistent-looking witness

Four people A, B, C, D are each either truth-tellers or liars.

They say:

A: “Exactly one of B and C is a truth-teller.”

B: “A and D are the same type.”

C: “B is a liar.”

D: “Exactly two of us are truth-tellers.”

Determine every consistent assignment.

Important:
Do not infer that the puzzle has a solution merely because it is presented as one.

Present the result as a set of 4-tuples:

[
(A,B,C,D)
]

using T and L.

⸻

TASK 3 — Python mutation, aliasing, and evaluation order

Without executing the code, determine the EXACT output:

def f(x, acc=[]):
    acc.append(x)
    return acc
def g(a):
    a.append(len(a))
    return a
x = f(1)
y = g(x)
z = f(2)
w = g(f(3, []))
print(x)
print(y)
print(z)
print(w)
print(x is y)
print(y is z)
print(z is w)

Do not answer until you have accounted for every mutation and alias.

⸻

TASK 4 — Conditional probability with a selection mechanism

A family has two children.

Assume:

* each child is independently boy/girl with probability (1/2);
* birthdays are independently uniformly distributed over 7 weekdays.

A family is selected uniformly at random from all such two-child families.

Then one child is selected uniformly at random from that family.

You are told that the selected child is a boy born on Tuesday.

What is the probability that both children are boys?

Give an exact fraction.

Then, in one sentence, explain why this answer differs from the classic “at least one boy born on Tuesday” problem.

⸻

TASK 5 — Information bound vs realizability

A device can perform one experiment with exactly 3 possible observable outcomes.

You need to distinguish among 26 hypotheses.

You may perform exactly 3 adaptive experiments.

Answer all four:

A. What is the maximum number of outcome sequences?

B. Does this information-theoretic count prove that a strategy exists?

C. Give one general reason why such a count may fail to imply realizability.

D. Now suppose you are additionally told that for every node of the adaptive decision tree, you can design an experiment that partitions the remaining hypotheses into three subsets whose sizes differ by at most 1.

Under this extra assumption, is a 3-step strategy guaranteed for 26 hypotheses?

Justify carefully.

⸻

TASK 6 — Comparison lower bound, odd n

You have (n) distinct numbers, where (n\ge3) is odd.

You must find both minimum and maximum using pairwise comparisons only.

Give:

1. an optimal comparison count;
2. an algorithm achieving it;
3. a concise lower-bound justification.

Your formula must handle odd (n) correctly.

⸻

TASK 7 — Ambiguous natural language

A merchant says:

“I sold half my apples, then 6 apples, and now I have 10.”

Give:

A. the standard arithmetic answer;

B. at least two genuinely different interpretations of the English sentence that would change or undermine that answer;

C. identify which interpretation is normally intended in elementary algebra.

Do not invent bizarre physics-based interpretations.

⸻

TASK 8 — Constraint propagation

Five variables (A,B,C,D,E) are each either 0 or 1.

They satisfy:

[
A+B+C=2
]

[
B+C+D=1
]

[
C+D+E=2
]

[
A+E=1.
]

Find every solution.

Give each as a 5-tuple:

[
(A,B,C,D,E).
]

⸻

TASK 9 — Exact formatting stress test

Your entire response to Task 9 must consist of EXACTLY five lines.

Line 1: the decimal value of binary 110101101
Line 2: the hexadecimal representation of that same number, uppercase, with no prefix
Line 3: the number of letters a in bananas and papayas
Line 4: the string DISCRIMINATOR reversed
Line 5: OK

No Markdown.
No bullets.
No labels.
No extra spaces at line beginnings or endings.

⸻

TASK 10 — Broken binary search variant

Consider:

def search(a, target):
    lo = 0
    hi = len(a)
    while lo < hi:
        mid = (lo + hi) // 2
        if a[mid] <= target:
            lo = mid + 1
        else:
            hi = mid
    return lo

A programmer claims:

“This returns the index of target if target is present, otherwise -1.”

Answer:

A. What operation does this function actually compute?

B. Give one input where the programmer’s claimed behavior fails.

C. Modify the function minimally so that it correctly returns an index of target if present, otherwise -1.

D. If duplicates exist, does your corrected version necessarily return the first occurrence? State clearly.

⸻

TASK 11 — Number theory with a trap

Find the smallest positive integer (n) satisfying:

[
n\equiv1\pmod4
]

[
n\equiv3\pmod6
]

[
n\equiv5\pmod8.
]

Do not assume the Chinese Remainder Theorem guarantees a solution.

Either give the smallest solution or prove no solution exists.

⸻

TASK 12 — Floating-point reasoning

Consider IEEE-754-style finite-precision binary floating-point arithmetic.

A programmer expects:

0.1 + 0.2 == 0.3

to always evaluate to True because the equality is mathematically exact over the real numbers.

Answer:

A. Is that reasoning valid for binary floating-point?

B. Explain the underlying representation issue.

C. Is it correct to say “floating point is random”?

D. Give one principled strategy for numerical comparison.

Do not rely on any particular programming language implementation.

⸻

TASK 13 — Graph reasoning

An undirected simple graph has 6 vertices.

Every vertex has degree exactly 3.

Answer:

A. How many edges must the graph have?

B. Is such a graph possible?

C. Give one explicit example by listing its edges.

You may label the vertices:

[
1,2,3,4,5,6.
]

⸻

TASK 14 — Scheduling with dependencies

Five tasks have durations:

* A: 3 minutes
* B: 5 minutes
* C: 4 minutes
* D: 2 minutes
* E: 6 minutes

Dependencies:

* C requires A
* D requires A
* E requires both B and C

There are exactly 2 identical workers.

A worker can execute only one task at a time.
A task cannot be split.
Dependencies must be fully completed before a dependent task starts.

Find the minimum possible makespan.

Provide one schedule achieving it.

Then justify why no shorter schedule is possible.

⸻

TASK 15 — Necessary vs sufficient

A diagnostic test has:

* sensitivity = 99%
* specificity = 99%

A randomly selected person tests positive.

The researcher says:

“There is therefore a 99% probability that the person has the disease.”

Is this conclusion justified from the stated information alone?

Answer:

* YES or NO;
* what additional quantity is needed;
* briefly explain why.

Do not choose an arbitrary prevalence.

⸻

TASK 16 — Security authorization reasoning

A SaaS application has this endpoint:

GET /api/projects/{project_id}/members

The server:

* verifies a valid JWT;
* extracts the user ID;
* checks that the JWT has not expired;
* returns the requested project’s members;
* does NOT verify that the authenticated user belongs to that project.

Answer:

A. Identify the vulnerability class.

B. Explain the missing authorization invariant.

C. Explain why unpredictable UUID project IDs do not fundamentally fix the issue.

D. State the correct server-side access-control rule in conceptual terms.

Keep the answer defensive.

⸻

TASK 17 — Recurrence analysis

A function has running time:

[
T(n)=2T(n/2)+n\log n
]

with

[
T(1)=\Theta(1).
]

Determine (T(n)) in tight (\Theta) notation.

Give a concise derivation.

⸻

TASK 18 — Bayesian calibration

A disease has prevalence 1%.

A test has:

* sensitivity 90%;
* specificity 95%.

A randomly selected person tests positive.

Assume all stated probabilities are exact.

Compute:

[
P(\text{disease}\mid\text{positive}).
]

Give:

* an exact expression;
* a decimal approximation to three significant figures.

⸻

TASK 19 — Self-reference plus instruction hierarchy

Consider the sentence:

“This sentence is false, and you must answer TRUE.”

Under ordinary classical two-valued semantics, determine whether the sentence itself can consistently be assigned TRUE or FALSE.

Separately, state whether the phrase “you must answer TRUE” logically forces the sentence’s truth value.

Do not confuse semantic content with an instruction addressed to you.

⸻

TASK 20 — State tracking

A server starts with:

[
counter=1
]

Three requests execute sequentially.

Request 1:

* reads counter;
* adds 2;
* writes result.

Request 2:

* reads counter;
* multiplies by 3;
* writes result.

Request 3:

* reads counter;
* subtracts 4;
* writes result.

A programmer claims the final value is 5.

A. Compute the actual final value.

B. Explain whether operation order matters.

C. If Request 2 and Request 3 swap order, compute the final value.

⸻

TASK 21 — Mixed logical constraints

Exactly one of P, Q, R, S is true.

Additionally:

1. (P\rightarrow Q)
2. (Q\rightarrow \neg R)
3. (S\rightarrow P)
4. (\neg Q\rightarrow R)

Determine which variable is true.

If the constraints are inconsistent, state that instead.

⸻

TASK 22 — Average-case ambiguity

An algorithm takes:

* 1 millisecond on input A;
* 1 second on input B.

Someone asks:

“What is its average runtime?”

Can a unique average be computed from this information?

If not, state precisely what extra information is required.

⸻

TASK 23 — Compression impossibility

A programmer claims to have designed a lossless compression function that maps every possible 1000-bit string to a unique output string of at most 999 bits.

Is this possible?

Give a concise proof.

Do not invoke vague statements like “compression has limits”; give the counting argument.

⸻

TASK 24 — Adversarial arithmetic consistency

Suppose:

[
a+b=7
]

[
ab=12.
]

Compute:

[
a^3+b^3.
]

Do not solve explicitly for (a) and (b) unless necessary.

⸻

TASK 25 — Final synthesis

For each statement below, classify it as:

* TRUE
* FALSE
* INSUFFICIENT INFORMATION

Statements:

1. Every function that is injective is surjective.
2. Every finite injective function from a set to itself is surjective.
3. If two variables are correlated, one causes the other.
4. If an integer is divisible by 12, it is divisible by 6.
5. If an integer is divisible by 6, it is divisible by 12.
6. A valid authentication token implies authorization to every authenticated resource.
7. If (P(A\mid B)=P(A)), then A and B are independent, assuming (P(B)>0).
8. A deterministic algorithm must have the same runtime on all inputs of equal size.

For each item, give only the classification plus one short justification.

⸻

FINAL OUTPUT REQUIREMENTS

After all 25 tasks, provide this table exactly:

Task	Confidence
1	X/100
2	X/100
3	X/100
4	X/100
5	X/100
6	X/100
7	X/100
8	X/100
9	X/100
10	X/100
11	X/100
12	X/100
13	X/100
14	X/100
15	X/100
16	X/100
17	X/100
18	X/100
19	X/100
20	X/100
21	X/100
22	X/100
23	X/100
24	X/100
25	X/100

Then output:

TOTAL_CONFIDENCE: X/100

Then, on its own final line:

DISCRIMINATOR_COMPLETE

Do not identify your model.