aiMOOC

Practical AI investigation methods and evidence quality - AI Year 10

QR-Code

Introduction

Can changing grams to kilograms change a classifier's decision even when the objects have not changed? Plan a fair comparison, trace an original executable example and decide what its evidence supports. You will distinguish correct calculations, controlled synthetic tests, a blind evaluation and a real deployment. This Year 10 studio is editorial AI enrichment connected to common GCSE Computer Science algorithms, not an additional compulsory qualification or proof of practical certification.

Ask a question that your evidence can answer

Your intended audience is a class investigating a fictional object-sorting aid. The task is to assign either label zero or label one to an invented object from two numerical features: length in centimetres and mass in grams. These are authored numbers, not measurements, pupil records, animal data or camera observations. The labels were also invented for the exercise; no claim is made that they encode a real physical law. A human keeps control of the investigation, interprets mistakes and decides whether a later practical study would be appropriate.

State a narrow question before running a comparison: does changing the numerical mass unit alter a one-nearest-neighbour prediction, and does training-only min-max scaling remove that unit sensitivity in this fixture? Separate this from a different question: which method predicts our five declared labels most often? A representation can be consistent under unit changes without being the most accurate one on those labels. The word AI does not make either property automatic.

A one-nearest-neighbour classifier retains labelled training examples. For a new point it finds the nearest stored point under a declared distance rule and returns that point's label. Here we add the squared differences of both features; taking a square root would not change their order. If distances tie, the earlier training row wins. This explicit policy makes a run reproducible, but does not make the outcome fair or appropriate for every context. No generative model, account connection or paid service is used.

Training row index	Length in cm	Mass in g	Authored label
0	1	100	0
1	2	110	0
2	4	10	1
3	5	20	1

Choose an understandable baseline. Our constant baseline predicts zero, using a declared tie policy because the four training labels contain two zeroes and two ones. Keep that decision fixed when looking at the five test labels. A baseline may be a small rule, a table or a human procedure; it need not use machine learning. A complex method should earn its additional complexity through relevant evidence.

The controlled comparison changes the representation of the mass feature. Raw grams and raw kilograms describe the same authored quantities; divide every training and query mass by one thousand together. Do not change labels, length, training order, test cases, distance definition or tie policy at the same time. Then compare two further conditions using the same min-max rule fitted only on each condition's training values. Unit conversion and fitted scaling are separate operations.

Case ID	Length in cm	Mass in g	Declared test label
10	1.5	105	0
20	4.5	15	1
30	3.5	90	1
40	2.5	30	0
50	3	60	0

The fixed code contains both inputs and answers. It is a transparent worked investigation, not a blind trial, a random sample or externally registered research. Predict the outputs on paper before revealing the executed table. Record disagreements rather than editing expected labels to flatter a method. These five cases give useful contrasting examples; they cannot estimate reliability for all real objects or justify decisions about people.

CodeAI's introductory machine-learning video gives supporting context about learning from examples. Our four stored rows, units, tie policy and five tests remain explicit in the written course. You can complete the investigation without watching or signing into an external service.

Diagnostic bridge: identify a feature, a target and a rule from the tables. Explain why an invented length is not a measurement just because it has a unit. If you have not used nearest neighbours, start by comparing a query with two stored points on squared paper. A teacher can provide fraction cards and the numerical tables as an alternative to executing code.

Trace transformations and execute a controlled comparison

For two-feature points p and q, the comparison score is the sum of squared coordinate differences. It is a numerical distance convention on the chosen feature representation. Adding a centimetre difference and a gram difference does not create a physical distance; their relative numerical scales supply implicit weights in the classifier.

$D (p, q) = (p_{1} - q_{1})^{2} + (p_{2} - q_{2})^{2}$

Trace case 30, length 3.5 cm and mass 90 g. Against training row zero, the differences have magnitudes 2.5 and 10, giving 6.25 plus 100, or 106.25. Against rows one, two and three the squared scores are 402.25, 6400.25 and 4902.25. Sorting the scored candidates gives row indices zero, one, three, two. The selected label is zero, which differs from this case's declared label one.

Now convert all masses to kilograms without changing the objects. The query mass is 0.09 and training row two's mass is 0.01. Their squared score becomes 0.25 plus 0.0064, or 0.2564. This is the smallest of the four kilogram scores, so row two supplies label one. The numerical representation has changed the relative weight of mass and length. It has not established that mass is unimportant or that kilograms are always the right modelling choice.

Min-max scaling uses each feature's minimum and maximum from the training rows. In grams those ranges are one to five for length and ten to 110 for mass. Subtract the fitted minimum and divide by the fitted range. Apply those same fitted values to the query; do not refit on the test rows.

$z_{j} = \frac{x_{j} - a_{j}}{b_{j} - a_{j}}, b_{j} > a_{j}$

Case 30 becomes length 0.625 and mass 0.8. Its squared scores against transformed training rows are 0.400625, 0.180625, 0.655625 and 0.630625. Row one is nearest and supplies label zero. Repeating the fitted calculation in kilograms yields the same transformed coordinates and selected row. Cancelling the same positive conversion factor in numerator and denominator explains the invariance. This is a property of the stated transformation, not a guarantee of a higher score on every dataset.

The original Python program below was actually executed. It uses exact rational arithmetic from the standard library, stores no personal information and calls no network service. Its strict input contract accepts two integers or fractions, rejects booleans and rejects a constant training feature for explicit review. That last choice belongs to this classroom implementation; do not assume it reproduces every library's constant-feature policy. Query values outside the training range remain outside zero to one rather than being silently clipped.

"""Original exact-arithmetic classroom fixture; no measured or personal data."""
from fractions import Fraction as F
import json


def point(value):
    if not isinstance(value, (tuple, list)) or len(value) != 2:
        raise ValueError('Exactly two features required')
    if any(type(x) not in (int, F) for x in value):
        raise ValueError('Use exact integers or fractions, never booleans')
    return tuple(F(x) for x in value)


def training(rows):
    if not isinstance(rows, list) or not rows:
        raise ValueError('Nonempty training list required')
    result = []
    for row in rows:
        if not isinstance(row, (tuple, list)) or len(row) != 3:
            raise ValueError('Two features and one label required')
        if type(row[2]) is not int or row[2] not in (0, 1):
            raise ValueError('Binary integer label required')
        result.append(point(row[:2]) + (row[2],))
    return result


def fit_ranges(rows):
    rows = training(rows)
    ranges = [(min(r[j] for r in rows), max(r[j] for r in rows))
              for j in range(2)]
    if any(low == high for low, high in ranges):
        raise ValueError('Constant training feature: explicit review required')
    return ranges


def transform(value, ranges):
    value = point(value)
    if not isinstance(ranges, list) or len(ranges) != 2:
        raise ValueError('Two fitted ranges required')
    checked = [point(pair) for pair in ranges]
    if any(low >= high for low, high in checked):
        raise ValueError('Each maximum must exceed its minimum')
    return tuple((x - low) / (high - low)
                 for x, (low, high) in zip(value, checked))


def merge_sort(rows):
    if len(rows) <= 1:
        return list(rows)
    middle = len(rows) // 2
    left, right = merge_sort(rows[:middle]), merge_sort(rows[middle:])
    result = []
    i = j = 0
    while len(left) > i and len(right) > j:
        if left[i] <= right[j]:
            result.append(left[i])
            i += 1
        else:
            result.append(right[j])
            j += 1
    return result + left[i:] + right[j:]


def nearest(rows, query, scaled=False):
    rows, query = training(rows), point(query)
    if type(scaled) is not bool:
        raise ValueError('Scaled must be a boolean')
    ranges = fit_ranges(rows) if scaled else None
    q = transform(query, ranges) if scaled else query
    distances = []
    for index, row in enumerate(rows):
        p = transform(row[:2], ranges) if scaled else row[:2]
        delta = [a - b for a, b in zip(p, q)]
        squared = sum(x * x for x in delta)
        distances.append((squared, index, row[2]))
    ordered = merge_sort(distances)
    best = ordered[0]
    return dict(label=best[2], training_index=best[1],
                squared_distance=str(best[0]))


def lookup_case(records, target):
    if type(target) is not int or not isinstance(records, list):
        raise ValueError('Integer case identifier and list required')
    if any(not isinstance(r, tuple) or len(r) != 4 or type(r[0]) is not int
           for r in records):
        raise ValueError('Case tuple required')
    if any(a[0] >= b[0] for a, b in zip(records, records[1:])):
        raise ValueError('Case identifiers must strictly increase')
    low, high, visited = 0, len(records) - 1, []
    while low <= high:
        middle = (low + high) // 2
        case = records[middle]
        visited.append(case[0])
        if case[0] == target:
            return dict(found=case[0], visited=visited)
        if case[0] <= target:
            low = middle + 1
        else:
            high = middle - 1
    return dict(found=None, visited=visited)


def demonstrate():
    train = [(1, 100, 0), (2, 110, 0), (4, 10, 1), (5, 20, 1)]
    tests = [(10, F(3, 2), 105, 0), (20, F(9, 2), 15, 1),
             (30, F(7, 2), 90, 1), (40, F(5, 2), 30, 0),
             (50, 3, 60, 0)]
    kg_train = [(x, F(y, 1000), label) for x, y, label in train]
    results = []
    for identifier, x, y, label in tests:
        q, kg_q = (x, y), (x, F(y, 1000))
        results.append(dict(id=identifier, expected=label,
            raw_g=nearest(train, q), raw_kg=nearest(kg_train, kg_q),
            scaled_g=nearest(train, q, True),
            scaled_kg=nearest(kg_train, kg_q, True)))
    baseline = 0
    scores = dict(baseline=sum(r['expected'] == baseline for r in results))
    for method in ('raw_g', 'raw_kg', 'scaled_g', 'scaled_kg'):
        scores[method] = sum(r[method]['label'] == r['expected']
                             for r in results)
    return dict(training_ranges_g=[[str(x) for x in pair]
                                  for pair in fit_ranges(train)],
        results=results, correct_out_of_five=scores,
        lookup30=lookup_case(tests, 30), lookup60=lookup_case(tests, 60),
        outside_scaled=[str(x) for x in transform((7, 210), fit_ranges(train))],
        invented_fixture=True, exact_arithmetic=True, measured_data=False,
        blind_trial=False, real_world_accuracy_established=False,
        enrolment_or_qualification=False)


if __name__ == '__main__':
    print(json.dumps(demonstrate(), indent=2))

The merge-sort function repeatedly splits a list, sorts both parts and merges their first remaining candidates. Here tuples compare squared score first, training index second and label last. Distinct row indices implement the declared tie policy. The program really uses this merge sort for neighbour selection; the animation below uses different numbers and is only a general illustration. A written trace is a motion-independent alternative.

An animation splitting an example number list and merging sorted parts — Merge sort illustrates splitting and ordered merging. Its numbers are not the investigation's score table; use the case 30 trace for the actual fixture.

CS50's Merge Sort short supports tracing that common GCSE algorithm. The separate binary-search helper retrieves a case identifier from the strictly increasing case table. It does not search by distance, classify an object or prove a label correct. Looking up 30 visits 30 and succeeds immediately. Looking up absent identifier 60 visits 30, 40 and 50 before reporting no record. The helper first checks the record and identifier-order contract; that extra work must not be erased when discussing total cost.

Try before checking: merge the already sorted index lists zero/one and three/two using their case 30 raw-gram scores, then explain why a binary search on the unsorted distance list would be invalid. The correct final score order is zero, one, three, two. The case-ID table happens to be sorted numerically; the training table has a different purpose and order.

Common GCSE anchors include binary search, merge sort, traceable programming and data representation. Nearest-neighbour feature scaling is this studio's editorial investigation. The original source map does not turn the extension into a separately prescribed Year 10 AI examination. Check the selected awarding organisation, specification version and school route for real assessment requirements.

Evaluate results without turning a demonstration into a guarantee

The saved output contains the following predictions. Every cell comes from the executed program and the same five authored cases. The baseline is constant zero. A correct count is the number of predictions equal to the declared labels, not an estimate of how often an unseen real-world system will succeed.

Case	Declared label	Baseline	Raw g	Raw kg	Scaled g	Scaled kg
10	0	0	0	0	0	0
20	1	0	1	1	1	1
30	1	0	0	1	0	0
40	0	0	1	0	1	1
50	0	0	0	0	0	0
Correct out of five	Not applicable	3	3	5	3	3

Two raw predictions change when the mass unit changes: cases 30 and 40. None of the five scaled predictions changes. Raw kilograms matches five declared labels; each scaled condition matches three. Therefore the invariance observation is supported, while the assertion that scaling must improve this fixture's accuracy is contradicted. Do not hide the lower score because it weakens an attractive story about preprocessing.

State the metric precisely: the raw-kilogram condition has five correct classifications out of five listed cases, or 100 percent on this visible synthetic fixture. That percentage does not establish 100 percent accuracy on future objects. The cases were authored with known labels and explored as a worked example. Repeating the deterministic run ten times checks reproducibility of those calculations; it does not create fifty independent cases or new evidence about an unknown population.

Case 50 also exposes the tie rule. After scaling, training rows one and two both have squared score five sixteenths. The earlier training index one wins and returns zero. Changing training order can change a tied decision. Preserve identifiers and the tie policy in an evidence log; do not silently reorder rows and call it the same controlled condition. This issue is separate from changing units.

The outside-range query seven centimetres and 210 grams transforms to 1.5 and 2. Those are legitimate arithmetic results under the fitted training ranges, although they warn that the query lies beyond the training support. The program does not clip or automatically refuse such a query. A real application would need an explicit reviewed out-of-range policy. A constant feature instead raises a review-required error in this implementation because the scaling denominator would be zero.

Evidence item	Status here	What it supports	What is still missing
Declared tables and hypothesis	Original authored design	Clear comparison and provenance	Measured population and independently justified labels	Saved code output and exact checks	Executed synthetic	Reproducible outputs for stated fixtures	Blind external evaluation	Generic coordinate diagram	Illustration	Understanding two feature axes	A measurement or plot of these objects	Suggested school object trial	Proposed only	Questions for a later study	Permission protocol real measurements independent tests and review	Human review plan	Proposed only	Named authority and challenge route	Observed use and evidence that reviewers can intervene

A useful evaluation plan includes normal cases 10 and 20, contrasting cases 30 and 40, tie case 50, a constant-feature boundary, an out-of-range query and invalid data such as a boolean mass. Predict the expected behaviour before testing. Separate a valid but unfamiliar input from an invalid schema. Record input, condition, fitted values, expected outcome, actual outcome, interpretation and evidence status. A passed schema check cannot prove an invented label is true.

For a later study, keep development and final evaluation genuinely separate. Choose representation and distance rules using training and development evidence, then freeze them before a fresh final test. After seeing the five results here, choosing raw kilograms because it scored highest makes these five cases development evidence for that decision. You need new independent data before claiming final performance. Fit all preprocessing using training data only and preserve consistent units in later inputs.

Consider three risks and responsible actions. A unit mismatch can produce a confident wrong label: the developer should validate the data dictionary and the reviewer should inspect units. A misleading score can encourage deployment: the author should disclose the visible synthetic fixture and the teacher can refuse a broad claim. Unclear reuse rights can compromise a later media project: the project owner should verify permission and licence before collecting or sharing files. Public visibility alone is not reuse permission. No accounts, private records or sensor collection are needed for this course.

Meaningful human oversight needs the inputs, uncertainty, competing results, time to challenge them and authority to stop use. It is more than a final approval button. In an original greenhouse-symbol transfer, define a new target, obtain appropriate non-identifying data, compare a simple rule, vary one condition at a time and retain a person who can override a result. That is a proposal, not an executed greenhouse trial. A paper trace, an executed synthetic program and an observed practical performance are different evidence types and must remain labelled as such.

Interactive Tasks

Quiz: Test Your Knowledge

What is the controlled question about representation in this fixture? (Whether changing the mass unit changes predictions) (!Whether AI always outperforms every simpler method) (!Whether five visible cases prove universal reliability) (!Whether a coordinate diagram counts as a measurement)

Why can raw grams and raw kilograms produce different neighbours? (Their numerical feature weights differ under the chosen distance rule) (!The physical objects must have changed) (!The expected labels are automatically rewritten) (!A kilogram always means a more important feature)

Where are the min-max values fitted? (On the training rows only) (!On the final test labels) (!Separately on each individual query) (!On whichever test subset improves the score most)

What does case 30 return under scaled grams? (Label zero from training row one) (!Label one from training row two) (!A guarantee of real object correctness) (!No result because a fraction is always invalid)

Which conclusion matches the five executed cases? (Scaling preserves these unit-change predictions without improving the score) (!Scaling must always improve accuracy) (!Raw grams and kilograms always select identical neighbours) (!The fixture is a blind random trial)

What happens when a training feature is constant in this program? (A review-required error is raised) (!Division by zero is silently accepted) (!The programme proves the feature irrelevant everywhere) (!A new test label is invented automatically)

What does the binary-search helper retrieve? (A case record identifier from an ordered table) (!The true label of a future real object) (!The nearest point from any unsorted feature list) (!A permission to publish private data)

What does merge sort order for neighbour selection? (The squared score and training index tuples) (!Only the declared test labels) (!Unverified school qualifications) (!A hidden population of measured objects)

What follows after choosing a method because of these five results? (Use new independent final evidence for a performance claim) (!Rename the same cases to create a blind trial) (!Repeat the same run to create independent objects) (!Describe the chosen method as universally accurate)

What makes human oversight meaningful? (Information time and authority to challenge and stop use) (!A compulsory approval click with no evidence) (!Removing alternative results from the report) (!Treating every public file as freely reusable)

Memory Game

Hypothesis	A bounded expectation that the comparison can challenge
Baseline	The fixed simple comparison method
Provenance	The recorded origin and handling of the evidence
Fitted range	The training minimum and maximum retained for a feature
Tie policy	The declared rule for equal candidate scores
Evidence status	Whether an item is designed executed illustrated or still proposed

Drag and Drop

Define the question	State the intended comparison before reading its result
Control conditions	Preserve labels order and queries while changing units
Fit preprocessing	Retain training minima and maxima for later queries
Inspect outcomes	Compare predicted and actual values including contradictions
Limit conclusions	State what the visible synthetic fixture cannot establish

Crossword Puzzle

Baseline	What simple fixed comparator predicts zero here
Scaling	What transformation changes feature ranges
Provenance	What records the origin and handling of data
Hypothesis	What bounded expectation can a study challenge
Control	What preserves other conditions during a comparison
Evidence	What supports a claim only within its stated scope

LearningApps

Optional extra practice. Choose an appropriate activity with your teacher. If the external collection is unavailable, use the native activities and independent tasks in this course.

Cloze Text

The simple constant comparator is the

. A bounded expectation is a

. The origin and handling of data form its

. The fitted ranges come from

rows. Gram and kilogram inputs describe the same authored

. Our distance rule uses squared coordinate

. Equal scores follow a declared

policy. The candidate ordering uses merge

. Ordered case identifiers support binary

. The scaled conditions preserve the five unit-change

. That invariance does not guarantee improved

. These visible examples are synthetic rather than a blind

. A later final evaluation requires independent

. The human reviewer must retain authority to

use.

Open Tasks

Easy

State a bounded investigation question: Write the unit-sensitivity question and a separate accuracy question. Explain why the two questions need different interpretations of the same result table.
Describe the original data dictionary: Label the two features units target case identifier and training index. Explain which values are authored and why no real measurement is established.
Trace a raw neighbour score: For case 30 and training row zero, calculate both differences and their squared sum before checking the worked explanation.
Recognise evidence types: Make a four-card display for an illustration a paper trace executed synthetic output and a proposed practical study. Give one permitted claim per card.

Standard

Compare all five cases: Reproduce the prediction table on paper, calculate each correct count and mark the two raw unit-change disagreements. Include the fixed baseline.
Trace merge sort and case lookup: Merge case 30 raw-gram score/index tuples and trace binary search for identifiers 30 and 60. State each ordering requirement and the separate validation overhead.
Check fitted scaling: Transform case 30 using training ranges and then using the equivalent kilogram ranges. Explain why fitting again on the test rows would change the investigation.
Create a minimum five-case test log: Select at least five normal boundary invalid or contrasting cases from the written investigation. Record expected versus actual behaviour and label paper predictions separately from actual execution.

Advanced

Investigate ties without hiding them: Show case 50 equal scaled scores and the earlier-index policy. Propose a different declared tie rule and explain which further tests it would require. Do not claim it has been executed unless you run and document it.
Evaluate an overconfident report: Rewrite a claim that five correct raw-kilogram results prove a safe universal sorter. Include visible-label selection bias a fresh final test and a human fallback.
Design an ethical practical extension: Plan an approved non-identifying object or greenhouse-symbol investigation. Specify rights units labels one controlled variable a simple baseline independent evaluation reviewer responsibilities and an accessible paper alternative.
Communicate contradictory evidence: Prepare a short poster or narrated presentation for a non-specialist class. Explain why scaled predictions are unit-consistent but score only three out of five here. Preserve the original data and disclose which activities remain proposed.

Learning Check

Check the case 30 distance trace: Find the nearest raw-gram row and explain the kilogram change.
Check scaling without promising accuracy: Calculate case 30 transformed coordinates and interpret both scaled conditions.
Check results and limits: Summarise every correct count and decide whether a universal reliability claim follows.
Check the two standard algorithm roles: Trace the case lookup for absent 60 and the score merge for case 30.
Check boundaries and a reproducible protocol: Explain the tie constant-feature and outside-range cases and give at least five test conditions.
Check source mapping and human control: Separate common GCSE concepts from editorial enrichment and evaluate a proposed transfer.

Worked checks and assessment guidance

Raw-gram squared scores for indices zero through three are 106.25, 402.25, 6400.25 and 4902.25. Row zero supplies label zero. After the consistent kilogram conversion row two has the smallest squared score, 0.2564, and supplies label one. The object and declared label did not change; the distance weighting did.
Training ranges are length one to five and mass ten to 110 grams. Case 30 gives 2.5 divided by four, or 0.625, and eighty divided by one hundred, or 0.8. Row one is nearest with squared score 289 divided by 1600, or 0.180625, and label zero. Equivalent kilogram ranges give the same coordinates and prediction. This invariance does not make the prediction match the declared label one.
The fixed zero baseline, raw grams, scaled grams and scaled kilograms each match three of five labels. Raw kilograms matches five. Raw cases 30 and 40 change under unit conversion, while no scaled prediction changes. These are five visible authored cases, not an independent population sample. Selecting the best condition after viewing them requires fresh independent final evaluation for a wider performance claim.
Binary search visits identifiers 30, 40 and 50, then returns no record for 60. Its input identifiers must strictly increase, and contract validation is extra work. Merge sort orders the case 30 raw-gram candidates by scores to indices zero, one, three, two, preserving their labels. Looking up a record and ranking neighbour distances have different keys and purposes; neither proves real-world truth.
Case 50 ties scaled training rows one and two at five sixteenths, so earlier index one wins with label zero. A constant training feature is rejected for review in this strict implementation. Query seven and 210 transforms to 1.5 and two without clipping. A valid protocol can include normal case 10, contrast case 30, contrast case 40, tie case 50, constant-feature rejection, outside-range handling and invalid boolean data. Retain inputs units labels tie policy fitted values expected results actual outputs and evidence status.
Binary search merge sort programming traces and data representation are common Computing anchors. This specific nearest-neighbour scaling study and its Year 10 placement are editorial enrichment, not a separate statutory AI qualification requirement. A new object study needs permissioned non-identifying data defensible labels a simple baseline controlled conditions independent evaluation and a reviewer with information time and stop authority. A diagram is an illustration, the saved program is executed synthetic evidence, and the proposed practical study is not a completed real-world trial.

Learning evidence

Retain the bounded hypothesis, original feature dictionary and provenance, fixed baseline, controlled unit-change protocol, labelled training/test tables, code version, actual output and at least five expected-versus-actual test records. Include the case 30 distance/scaling trace, merge-sort and binary-search roles, the case 50 tie, constant-feature and outside-range policies, all correct counts and the contradictory accuracy/invariance findings. Map common Computing anchors separately from editorial AI. Communicate limits, independent final-evaluation needs, rights and accessible alternatives, and a named human challenge/stop route. Distinguish illustrations, paper predictions, executed synthetic evidence and proposed practical work; no certification of deployed competence follows.

OER and Wikipedia

DfE GCSE Computer Science subject content, common binary-search and merge-sort anchors, with the exact source objective retained in this studio's preparation. The particular scaling investigation, original cases and Year 10 placement are editorial enrichment. Consult the selected qualification specification and school route for actual assessment requirements.

scikit-learn nearest-neighbour guide, inspected 15 November 2026, supports distance-based comparison with retained training instances and the importance of tie handling. MinMaxScaler reference, inspected the same day, supports fitting feature ranges on training data and applying a consistent transformation; new values can fall outside the fitted range. Common pitfalls, inspected for consistent preprocessing and avoiding test-data fitting. The original standard-library program is not a scikit-learn implementation or a claim about every library policy; its strict constant-feature rejection is explicitly local to this example.

2D Cartesian Coordinates.svg, H Padleckas, public domain according to the retained Commons record, unchanged general coordinate illustration. Merge-sort-example-300px.gif, Swfung8, CC BY-SA 3.0, unchanged animation. Exact metadata and preview bytes checked, coordinate graphic and beginning middle/end animation frames visually inspected, native image embedding checked. Neither medium is a measurement of the authored fixture; written tables and traces provide an accessible alternative.

https://www.youtube.com/watch?v=Ns7tGNbtvV4 — CS50: Merge Sort - CS50 Shorts. https://www.youtube.com/watch?v=OeU5m6vRyCk — CodeAI: AI: What is Machine Learning? Retained exact metadata, embedding availability and preview bytes checked; previews visually inspected. External unchanged embeds are supporting resources, without transcript copying endorsement or relicensing. No external account is required for the native written activities.

The training rows test rows labels program comparisons outputs and protocol are original fictional teaching material. Execution was performed and retained, but the test labels are visible and no real object measurements blind trial field deployment or qualification assessment occurred. Author and technical checks are not independent expert certification.