Total-Map Collisions, Ceiling Loads and Failed Size Converses
This batch has passed Schema, deduplication, source-snapshot, and independent-answer recomputation checks; it is still not marked as human-reviewed.
This question bank has corresponding bilingual step-by-step derivations. Source candidate and English ai_candidate states are retained. AI review, finite computation and Lean formal proof are labelled separately.
batch-20261014-advance-20261107-r05-pigeonhole-principle-foundations · 2026-10-14 · 100 questions
This English edition is an AI candidate and does not yet have an OCME Atlas (GPT-6) Twin closure receipt.
Field order uses a source-bound presentation supplement; canonical JSONL and mathematical answers are unchanged.
Field-order and source-binding data
1. A Complete Larger-Domain Map Has Two Distinct Sources with One Image
Use the complete total mapping=[0, 1, 2, 0] from source indices Fin(4)={0,…,3} into Fin(3)={0,…,2}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. The domain is strictly larger than the codomain. Give (domain_count, codomain_count, collision, has_collision, certificate).
View answer and explanation
(4, 3, [0, 3, 0], Yes, complete_total_map_collision)
Return the first collision [left_index,right_index,image] in increasing left/right order with left<right. The full finite map provides an exact instance witness, not a theorem derived from partial samples. The exact result, retaining the requested order, is (4, 3, [0, 3, 0], Yes, complete_total_map_collision).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-collision-witness · candidate
2. A Complete Larger-Domain Map Has Two Distinct Sources with One Image
Use the complete total mapping=[1, 3, 1, 3, 1] from source indices Fin(5)={0,…,4} into Fin(4)={0,…,3}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. The domain is strictly larger than the codomain. Give (domain_count, codomain_count, collision, has_collision, certificate).
View answer and explanation
(5, 4, [0, 2, 1], Yes, complete_total_map_collision)
Return the first collision [left_index,right_index,image] in increasing left/right order with left<right. The full finite map provides an exact instance witness, not a theorem derived from partial samples. The exact result, retaining the requested order, is (5, 4, [0, 2, 1], Yes, complete_total_map_collision).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-collision-witness · candidate
3. A Complete Larger-Domain Map Has Two Distinct Sources with One Image
Use the complete total mapping=[2, 0, 3, 1, 4, 2] from source indices Fin(6)={0,…,5} into Fin(5)={0,…,4}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. The domain is strictly larger than the codomain. Give (domain_count, codomain_count, collision, has_collision, certificate).
View answer and explanation
(6, 5, [0, 5, 2], Yes, complete_total_map_collision)
Return the first collision [left_index,right_index,image] in increasing left/right order with left<right. The full finite map provides an exact instance witness, not a theorem derived from partial samples. The exact result, retaining the requested order, is (6, 5, [0, 5, 2], Yes, complete_total_map_collision).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-collision-witness · candidate
4. A Complete Larger-Domain Map Has Two Distinct Sources with One Image
Use the complete total mapping=[3, 4, 5, 0, 1, 2, 3] from source indices Fin(7)={0,…,6} into Fin(6)={0,…,5}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. The domain is strictly larger than the codomain. Give (domain_count, codomain_count, collision, has_collision, certificate).
View answer and explanation
(7, 6, [0, 6, 3], Yes, complete_total_map_collision)
Return the first collision [left_index,right_index,image] in increasing left/right order with left<right. The full finite map provides an exact instance witness, not a theorem derived from partial samples. The exact result, retaining the requested order, is (7, 6, [0, 6, 3], Yes, complete_total_map_collision).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-collision-witness · candidate
5. A Complete Larger-Domain Map Has Two Distinct Sources with One Image
Use the complete total mapping=[4, 6, 1, 3, 5, 0, 2, 4] from source indices Fin(8)={0,…,7} into Fin(7)={0,…,6}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. The domain is strictly larger than the codomain. Give (domain_count, codomain_count, collision, has_collision, certificate).
View answer and explanation
(8, 7, [0, 7, 4], Yes, complete_total_map_collision)
Return the first collision [left_index,right_index,image] in increasing left/right order with left<right. The full finite map provides an exact instance witness, not a theorem derived from partial samples. The exact result, retaining the requested order, is (8, 7, [0, 7, 4], Yes, complete_total_map_collision).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-collision-witness · candidate
6. A Complete Larger-Domain Map Has Two Distinct Sources with One Image
Use the complete total mapping=[2, 2, 2, 2, 2] from source indices Fin(5)={0,…,4} into Fin(3)={0,…,2}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. The domain is strictly larger than the codomain. Give (domain_count, codomain_count, collision, has_collision, certificate).
View answer and explanation
(5, 3, [0, 1, 2], Yes, complete_total_map_collision)
Return the first collision [left_index,right_index,image] in increasing left/right order with left<right. The full finite map provides an exact instance witness, not a theorem derived from partial samples. The exact result, retaining the requested order, is (5, 3, [0, 1, 2], Yes, complete_total_map_collision).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-collision-witness · candidate
7. A Complete Larger-Domain Map Has Two Distinct Sources with One Image
Use the complete total mapping=[2, 3, 0, 1, 2, 3] from source indices Fin(6)={0,…,5} into Fin(4)={0,…,3}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. The domain is strictly larger than the codomain. Give (domain_count, codomain_count, collision, has_collision, certificate).
View answer and explanation
(6, 4, [0, 4, 2], Yes, complete_total_map_collision)
Return the first collision [left_index,right_index,image] in increasing left/right order with left<right. The full finite map provides an exact instance witness, not a theorem derived from partial samples. The exact result, retaining the requested order, is (6, 4, [0, 4, 2], Yes, complete_total_map_collision).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-collision-witness · candidate
8. A Complete Larger-Domain Map Has Two Distinct Sources with One Image
Use the complete total mapping=[2, 4, 1, 3, 0, 2, 4] from source indices Fin(7)={0,…,6} into Fin(5)={0,…,4}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. The domain is strictly larger than the codomain. Give (domain_count, codomain_count, collision, has_collision, certificate).
View answer and explanation
(7, 5, [0, 5, 2], Yes, complete_total_map_collision)
Return the first collision [left_index,right_index,image] in increasing left/right order with left<right. The full finite map provides an exact instance witness, not a theorem derived from partial samples. The exact result, retaining the requested order, is (7, 5, [0, 5, 2], Yes, complete_total_map_collision).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-collision-witness · candidate
9. A Complete Larger-Domain Map Has Two Distinct Sources with One Image
Use the complete total mapping=[2, 5, 2, 5, 2, 5, 2, 5] from source indices Fin(8)={0,…,7} into Fin(6)={0,…,5}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. The domain is strictly larger than the codomain. Give (domain_count, codomain_count, collision, has_collision, certificate).
View answer and explanation
(8, 6, [0, 2, 2], Yes, complete_total_map_collision)
Return the first collision [left_index,right_index,image] in increasing left/right order with left<right. The full finite map provides an exact instance witness, not a theorem derived from partial samples. The exact result, retaining the requested order, is (8, 6, [0, 2, 2], Yes, complete_total_map_collision).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-collision-witness · candidate
10. A Complete Larger-Domain Map Has Two Distinct Sources with One Image
Use the complete total mapping=[2, 3, 4, 5, 6, 0, 1, 2, 3] from source indices Fin(9)={0,…,8} into Fin(7)={0,…,6}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. The domain is strictly larger than the codomain. Give (domain_count, codomain_count, collision, has_collision, certificate).
View answer and explanation
(9, 7, [0, 7, 2], Yes, complete_total_map_collision)
Return the first collision [left_index,right_index,image] in increasing left/right order with left<right. The full finite map provides an exact instance witness, not a theorem derived from partial samples. The exact result, retaining the requested order, is (9, 7, [0, 7, 2], Yes, complete_total_map_collision).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-collision-witness · candidate
11. A Complete Larger-Domain Map Has Two Distinct Sources with One Image
Use the complete total mapping=[1, 0, 2, 1, 0, 2] from source indices Fin(6)={0,…,5} into Fin(3)={0,…,2}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. The domain is strictly larger than the codomain. Give (domain_count, codomain_count, collision, has_collision, certificate).
View answer and explanation
(6, 3, [0, 3, 1], Yes, complete_total_map_collision)
Return the first collision [left_index,right_index,image] in increasing left/right order with left<right. The full finite map provides an exact instance witness, not a theorem derived from partial samples. The exact result, retaining the requested order, is (6, 3, [0, 3, 1], Yes, complete_total_map_collision).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-collision-witness · candidate
12. A Complete Larger-Domain Map Has Two Distinct Sources with One Image
Use the complete total mapping=[3, 2, 1, 0, 3, 2, 1] from source indices Fin(7)={0,…,6} into Fin(4)={0,…,3}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. The domain is strictly larger than the codomain. Give (domain_count, codomain_count, collision, has_collision, certificate).
View answer and explanation
(7, 4, [0, 4, 3], Yes, complete_total_map_collision)
Return the first collision [left_index,right_index,image] in increasing left/right order with left<right. The full finite map provides an exact instance witness, not a theorem derived from partial samples. The exact result, retaining the requested order, is (7, 4, [0, 4, 3], Yes, complete_total_map_collision).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-collision-witness · candidate
13. A Complete Larger-Domain Map Has Two Distinct Sources with One Image
Use the complete total mapping=[2, 3, 4, 0, 1, 2, 3, 4] from source indices Fin(8)={0,…,7} into Fin(5)={0,…,4}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. The domain is strictly larger than the codomain. Give (domain_count, codomain_count, collision, has_collision, certificate).
View answer and explanation
(8, 5, [0, 5, 2], Yes, complete_total_map_collision)
Return the first collision [left_index,right_index,image] in increasing left/right order with left<right. The full finite map provides an exact instance witness, not a theorem derived from partial samples. The exact result, retaining the requested order, is (8, 5, [0, 5, 2], Yes, complete_total_map_collision).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-collision-witness · candidate
14. A Complete Larger-Domain Map Has Two Distinct Sources with One Image
Use the complete total mapping=[1, 3, 5, 1, 3, 5, 1, 3, 5] from source indices Fin(9)={0,…,8} into Fin(6)={0,…,5}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. The domain is strictly larger than the codomain. Give (domain_count, codomain_count, collision, has_collision, certificate).
View answer and explanation
(9, 6, [0, 3, 1], Yes, complete_total_map_collision)
Return the first collision [left_index,right_index,image] in increasing left/right order with left<right. The full finite map provides an exact instance witness, not a theorem derived from partial samples. The exact result, retaining the requested order, is (9, 6, [0, 3, 1], Yes, complete_total_map_collision).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-collision-witness · candidate
15. A Complete Larger-Domain Map Has Two Distinct Sources with One Image
Use the complete total mapping=[0, 3, 6, 2, 5, 1, 4, 0, 3, 6] from source indices Fin(10)={0,…,9} into Fin(7)={0,…,6}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. The domain is strictly larger than the codomain. Give (domain_count, codomain_count, collision, has_collision, certificate).
View answer and explanation
(10, 7, [0, 7, 0], Yes, complete_total_map_collision)
Return the first collision [left_index,right_index,image] in increasing left/right order with left<right. The full finite map provides an exact instance witness, not a theorem derived from partial samples. The exact result, retaining the requested order, is (10, 7, [0, 7, 0], Yes, complete_total_map_collision).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-collision-witness · candidate
16. A Complete Larger-Domain Map Has Two Distinct Sources with One Image
Use the complete total mapping=[0, 1, 2, 0, 1, 2, 0] from source indices Fin(7)={0,…,6} into Fin(3)={0,…,2}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. The domain is strictly larger than the codomain. Give (domain_count, codomain_count, collision, has_collision, certificate).
View answer and explanation
(7, 3, [0, 3, 0], Yes, complete_total_map_collision)
Return the first collision [left_index,right_index,image] in increasing left/right order with left<right. The full finite map provides an exact instance witness, not a theorem derived from partial samples. The exact result, retaining the requested order, is (7, 3, [0, 3, 0], Yes, complete_total_map_collision).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-collision-witness · candidate
17. A Complete Larger-Domain Map Has Two Distinct Sources with One Image
Use the complete total mapping=[0, 2, 0, 2, 0, 2, 0, 2] from source indices Fin(8)={0,…,7} into Fin(4)={0,…,3}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. The domain is strictly larger than the codomain. Give (domain_count, codomain_count, collision, has_collision, certificate).
View answer and explanation
(8, 4, [0, 2, 0], Yes, complete_total_map_collision)
Return the first collision [left_index,right_index,image] in increasing left/right order with left<right. The full finite map provides an exact instance witness, not a theorem derived from partial samples. The exact result, retaining the requested order, is (8, 4, [0, 2, 0], Yes, complete_total_map_collision).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-collision-witness · candidate
18. A Complete Larger-Domain Map Has Two Distinct Sources with One Image
Use the complete total mapping=[2, 0, 3, 1, 4, 2, 0, 3, 1] from source indices Fin(9)={0,…,8} into Fin(5)={0,…,4}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. The domain is strictly larger than the codomain. Give (domain_count, codomain_count, collision, has_collision, certificate).
View answer and explanation
(9, 5, [0, 5, 2], Yes, complete_total_map_collision)
Return the first collision [left_index,right_index,image] in increasing left/right order with left<right. The full finite map provides an exact instance witness, not a theorem derived from partial samples. The exact result, retaining the requested order, is (9, 5, [0, 5, 2], Yes, complete_total_map_collision).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-collision-witness · candidate
19. A Complete Larger-Domain Map Has Two Distinct Sources with One Image
Use the complete total mapping=[0, 1, 2, 3, 4, 5, 0, 1, 2, 3] from source indices Fin(10)={0,…,9} into Fin(6)={0,…,5}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. The domain is strictly larger than the codomain. Give (domain_count, codomain_count, collision, has_collision, certificate).
View answer and explanation
(10, 6, [0, 6, 0], Yes, complete_total_map_collision)
Return the first collision [left_index,right_index,image] in increasing left/right order with left<right. The full finite map provides an exact instance witness, not a theorem derived from partial samples. The exact result, retaining the requested order, is (10, 6, [0, 6, 0], Yes, complete_total_map_collision).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-collision-witness · candidate
20. A Complete Larger-Domain Map Has Two Distinct Sources with One Image
Use the complete total mapping=[5, 0, 2, 4, 6, 1, 3, 5, 0, 2, 4] from source indices Fin(11)={0,…,10} into Fin(7)={0,…,6}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. The domain is strictly larger than the codomain. Give (domain_count, codomain_count, collision, has_collision, certificate).
View answer and explanation
(11, 7, [0, 7, 5], Yes, complete_total_map_collision)
Return the first collision [left_index,right_index,image] in increasing left/right order with left<right. The full finite map provides an exact instance witness, not a theorem derived from partial samples. The exact result, retaining the requested order, is (11, 7, [0, 7, 5], Yes, complete_total_map_collision).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-collision-witness · candidate
21. A Complete Larger-Domain Map Has Two Distinct Sources with One Image
Use the complete total mapping=[2, 2, 2, 2, 2, 2, 2, 2] from source indices Fin(8)={0,…,7} into Fin(3)={0,…,2}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. The domain is strictly larger than the codomain. Give (domain_count, codomain_count, collision, has_collision, certificate).
View answer and explanation
(8, 3, [0, 1, 2], Yes, complete_total_map_collision)
Return the first collision [left_index,right_index,image] in increasing left/right order with left<right. The full finite map provides an exact instance witness, not a theorem derived from partial samples. The exact result, retaining the requested order, is (8, 3, [0, 1, 2], Yes, complete_total_map_collision).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-collision-witness · candidate
22. A Complete Larger-Domain Map Has Two Distinct Sources with One Image
Use the complete total mapping=[1, 2, 3, 0, 1, 2, 3, 0, 1] from source indices Fin(9)={0,…,8} into Fin(4)={0,…,3}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. The domain is strictly larger than the codomain. Give (domain_count, codomain_count, collision, has_collision, certificate).
View answer and explanation
(9, 4, [0, 4, 1], Yes, complete_total_map_collision)
Return the first collision [left_index,right_index,image] in increasing left/right order with left<right. The full finite map provides an exact instance witness, not a theorem derived from partial samples. The exact result, retaining the requested order, is (9, 4, [0, 4, 1], Yes, complete_total_map_collision).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-collision-witness · candidate
23. A Complete Larger-Domain Map Has Two Distinct Sources with One Image
Use the complete total mapping=[2, 4, 1, 3, 0, 2, 4, 1, 3, 0] from source indices Fin(10)={0,…,9} into Fin(5)={0,…,4}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. The domain is strictly larger than the codomain. Give (domain_count, codomain_count, collision, has_collision, certificate).
View answer and explanation
(10, 5, [0, 5, 2], Yes, complete_total_map_collision)
Return the first collision [left_index,right_index,image] in increasing left/right order with left<right. The full finite map provides an exact instance witness, not a theorem derived from partial samples. The exact result, retaining the requested order, is (10, 5, [0, 5, 2], Yes, complete_total_map_collision).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-collision-witness · candidate
24. A Complete Larger-Domain Map Has Two Distinct Sources with One Image
Use the complete total mapping=[5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5] from source indices Fin(11)={0,…,10} into Fin(6)={0,…,5}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. The domain is strictly larger than the codomain. Give (domain_count, codomain_count, collision, has_collision, certificate).
View answer and explanation
(11, 6, [0, 2, 5], Yes, complete_total_map_collision)
Return the first collision [left_index,right_index,image] in increasing left/right order with left<right. The full finite map provides an exact instance witness, not a theorem derived from partial samples. The exact result, retaining the requested order, is (11, 6, [0, 2, 5], Yes, complete_total_map_collision).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-collision-witness · candidate
25. A Complete Larger-Domain Map Has Two Distinct Sources with One Image
Use the complete total mapping=[3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 0] from source indices Fin(12)={0,…,11} into Fin(7)={0,…,6}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. The domain is strictly larger than the codomain. Give (domain_count, codomain_count, collision, has_collision, certificate).
View answer and explanation
(12, 7, [0, 7, 3], Yes, complete_total_map_collision)
Return the first collision [left_index,right_index,image] in increasing left/right order with left<right. The full finite map provides an exact instance witness, not a theorem derived from partial samples. The exact result, retaining the requested order, is (12, 7, [0, 7, 3], Yes, complete_total_map_collision).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-collision-witness · candidate
26. The Largest Fibre Is at Least the Exact Ceiling Average
Use the complete total mapping=[0, 1, 2, 0] from source indices Fin(4)={0,…,3} into Fin(3)={0,…,2}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. Give (loads, maximum_load, ceiling_lower_bound, bound_holds, certificate).
View answer and explanation
([2, 1, 1], 2, 2, Yes, generalized_pigeonhole_load_bound)
List every codomain load in target order. Compare its maximum with ceil(domain_count/codomain_count); the lower bound is not generally equal to the maximum load. The empty domain gives all loads0 and lower bound0 on a nonempty codomain. The exact result, retaining the requested order, is ([2, 1, 1], 2, 2, Yes, generalized_pigeonhole_load_bound).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-generalized-load · candidate
27. The Largest Fibre Is at Least the Exact Ceiling Average
Use the complete total mapping=[1, 3, 1, 3, 1] from source indices Fin(5)={0,…,4} into Fin(4)={0,…,3}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. Give (loads, maximum_load, ceiling_lower_bound, bound_holds, certificate).
View answer and explanation
([0, 3, 0, 2], 3, 2, Yes, generalized_pigeonhole_load_bound)
List every codomain load in target order. Compare its maximum with ceil(domain_count/codomain_count); the lower bound is not generally equal to the maximum load. The empty domain gives all loads0 and lower bound0 on a nonempty codomain. The exact result, retaining the requested order, is ([0, 3, 0, 2], 3, 2, Yes, generalized_pigeonhole_load_bound).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-generalized-load · candidate
28. The Largest Fibre Is at Least the Exact Ceiling Average
Use the complete total mapping=[2, 0, 3, 1, 4, 2] from source indices Fin(6)={0,…,5} into Fin(5)={0,…,4}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. Give (loads, maximum_load, ceiling_lower_bound, bound_holds, certificate).
View answer and explanation
([1, 1, 2, 1, 1], 2, 2, Yes, generalized_pigeonhole_load_bound)
List every codomain load in target order. Compare its maximum with ceil(domain_count/codomain_count); the lower bound is not generally equal to the maximum load. The empty domain gives all loads0 and lower bound0 on a nonempty codomain. The exact result, retaining the requested order, is ([1, 1, 2, 1, 1], 2, 2, Yes, generalized_pigeonhole_load_bound).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-generalized-load · candidate
29. The Largest Fibre Is at Least the Exact Ceiling Average
Use the complete total mapping=[3, 4, 5, 0, 1, 2, 3] from source indices Fin(7)={0,…,6} into Fin(6)={0,…,5}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. Give (loads, maximum_load, ceiling_lower_bound, bound_holds, certificate).
View answer and explanation
([1, 1, 1, 2, 1, 1], 2, 2, Yes, generalized_pigeonhole_load_bound)
List every codomain load in target order. Compare its maximum with ceil(domain_count/codomain_count); the lower bound is not generally equal to the maximum load. The empty domain gives all loads0 and lower bound0 on a nonempty codomain. The exact result, retaining the requested order, is ([1, 1, 1, 2, 1, 1], 2, 2, Yes, generalized_pigeonhole_load_bound).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-generalized-load · candidate
30. The Largest Fibre Is at Least the Exact Ceiling Average
Use the complete total mapping=[4, 6, 1, 3, 5, 0, 2, 4] from source indices Fin(8)={0,…,7} into Fin(7)={0,…,6}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. Give (loads, maximum_load, ceiling_lower_bound, bound_holds, certificate).
View answer and explanation
([1, 1, 1, 1, 2, 1, 1], 2, 2, Yes, generalized_pigeonhole_load_bound)
List every codomain load in target order. Compare its maximum with ceil(domain_count/codomain_count); the lower bound is not generally equal to the maximum load. The empty domain gives all loads0 and lower bound0 on a nonempty codomain. The exact result, retaining the requested order, is ([1, 1, 1, 1, 2, 1, 1], 2, 2, Yes, generalized_pigeonhole_load_bound).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-generalized-load · candidate
31. The Largest Fibre Is at Least the Exact Ceiling Average
Use the complete total mapping=[2, 2, 2, 2, 2] from source indices Fin(5)={0,…,4} into Fin(3)={0,…,2}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. Give (loads, maximum_load, ceiling_lower_bound, bound_holds, certificate).
View answer and explanation
([0, 0, 5], 5, 2, Yes, generalized_pigeonhole_load_bound)
List every codomain load in target order. Compare its maximum with ceil(domain_count/codomain_count); the lower bound is not generally equal to the maximum load. The empty domain gives all loads0 and lower bound0 on a nonempty codomain. The exact result, retaining the requested order, is ([0, 0, 5], 5, 2, Yes, generalized_pigeonhole_load_bound).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-generalized-load · candidate
32. The Largest Fibre Is at Least the Exact Ceiling Average
Use the complete total mapping=[2, 3, 0, 1, 2, 3] from source indices Fin(6)={0,…,5} into Fin(4)={0,…,3}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. Give (loads, maximum_load, ceiling_lower_bound, bound_holds, certificate).
View answer and explanation
([1, 1, 2, 2], 2, 2, Yes, generalized_pigeonhole_load_bound)
List every codomain load in target order. Compare its maximum with ceil(domain_count/codomain_count); the lower bound is not generally equal to the maximum load. The empty domain gives all loads0 and lower bound0 on a nonempty codomain. The exact result, retaining the requested order, is ([1, 1, 2, 2], 2, 2, Yes, generalized_pigeonhole_load_bound).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-generalized-load · candidate
33. The Largest Fibre Is at Least the Exact Ceiling Average
Use the complete total mapping=[2, 4, 1, 3, 0, 2, 4] from source indices Fin(7)={0,…,6} into Fin(5)={0,…,4}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. Give (loads, maximum_load, ceiling_lower_bound, bound_holds, certificate).
View answer and explanation
([1, 1, 2, 1, 2], 2, 2, Yes, generalized_pigeonhole_load_bound)
List every codomain load in target order. Compare its maximum with ceil(domain_count/codomain_count); the lower bound is not generally equal to the maximum load. The empty domain gives all loads0 and lower bound0 on a nonempty codomain. The exact result, retaining the requested order, is ([1, 1, 2, 1, 2], 2, 2, Yes, generalized_pigeonhole_load_bound).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-generalized-load · candidate
34. The Largest Fibre Is at Least the Exact Ceiling Average
Use the complete total mapping=[2, 5, 2, 5, 2, 5, 2, 5] from source indices Fin(8)={0,…,7} into Fin(6)={0,…,5}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. Give (loads, maximum_load, ceiling_lower_bound, bound_holds, certificate).
View answer and explanation
([0, 0, 4, 0, 0, 4], 4, 2, Yes, generalized_pigeonhole_load_bound)
List every codomain load in target order. Compare its maximum with ceil(domain_count/codomain_count); the lower bound is not generally equal to the maximum load. The empty domain gives all loads0 and lower bound0 on a nonempty codomain. The exact result, retaining the requested order, is ([0, 0, 4, 0, 0, 4], 4, 2, Yes, generalized_pigeonhole_load_bound).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-generalized-load · candidate
35. The Largest Fibre Is at Least the Exact Ceiling Average
Use the complete total mapping=[2, 3, 4, 5, 6, 0, 1, 2, 3] from source indices Fin(9)={0,…,8} into Fin(7)={0,…,6}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. Give (loads, maximum_load, ceiling_lower_bound, bound_holds, certificate).
View answer and explanation
([1, 1, 2, 2, 1, 1, 1], 2, 2, Yes, generalized_pigeonhole_load_bound)
List every codomain load in target order. Compare its maximum with ceil(domain_count/codomain_count); the lower bound is not generally equal to the maximum load. The empty domain gives all loads0 and lower bound0 on a nonempty codomain. The exact result, retaining the requested order, is ([1, 1, 2, 2, 1, 1, 1], 2, 2, Yes, generalized_pigeonhole_load_bound).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-generalized-load · candidate
36. The Largest Fibre Is at Least the Exact Ceiling Average
Use the complete total mapping=[1, 0, 2, 1, 0, 2] from source indices Fin(6)={0,…,5} into Fin(3)={0,…,2}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. Give (loads, maximum_load, ceiling_lower_bound, bound_holds, certificate).
View answer and explanation
([2, 2, 2], 2, 2, Yes, generalized_pigeonhole_load_bound)
List every codomain load in target order. Compare its maximum with ceil(domain_count/codomain_count); the lower bound is not generally equal to the maximum load. The empty domain gives all loads0 and lower bound0 on a nonempty codomain. The exact result, retaining the requested order, is ([2, 2, 2], 2, 2, Yes, generalized_pigeonhole_load_bound).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-generalized-load · candidate
37. The Largest Fibre Is at Least the Exact Ceiling Average
Use the complete total mapping=[3, 2, 1, 0, 3, 2, 1] from source indices Fin(7)={0,…,6} into Fin(4)={0,…,3}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. Give (loads, maximum_load, ceiling_lower_bound, bound_holds, certificate).
View answer and explanation
([1, 2, 2, 2], 2, 2, Yes, generalized_pigeonhole_load_bound)
List every codomain load in target order. Compare its maximum with ceil(domain_count/codomain_count); the lower bound is not generally equal to the maximum load. The empty domain gives all loads0 and lower bound0 on a nonempty codomain. The exact result, retaining the requested order, is ([1, 2, 2, 2], 2, 2, Yes, generalized_pigeonhole_load_bound).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-generalized-load · candidate
38. The Largest Fibre Is at Least the Exact Ceiling Average
Use the complete total mapping=[2, 3, 4, 0, 1, 2, 3, 4] from source indices Fin(8)={0,…,7} into Fin(5)={0,…,4}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. Give (loads, maximum_load, ceiling_lower_bound, bound_holds, certificate).
View answer and explanation
([1, 1, 2, 2, 2], 2, 2, Yes, generalized_pigeonhole_load_bound)
List every codomain load in target order. Compare its maximum with ceil(domain_count/codomain_count); the lower bound is not generally equal to the maximum load. The empty domain gives all loads0 and lower bound0 on a nonempty codomain. The exact result, retaining the requested order, is ([1, 1, 2, 2, 2], 2, 2, Yes, generalized_pigeonhole_load_bound).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-generalized-load · candidate
39. The Largest Fibre Is at Least the Exact Ceiling Average
Use the complete total mapping=[1, 3, 5, 1, 3, 5, 1, 3, 5] from source indices Fin(9)={0,…,8} into Fin(6)={0,…,5}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. Give (loads, maximum_load, ceiling_lower_bound, bound_holds, certificate).
View answer and explanation
([0, 3, 0, 3, 0, 3], 3, 2, Yes, generalized_pigeonhole_load_bound)
List every codomain load in target order. Compare its maximum with ceil(domain_count/codomain_count); the lower bound is not generally equal to the maximum load. The empty domain gives all loads0 and lower bound0 on a nonempty codomain. The exact result, retaining the requested order, is ([0, 3, 0, 3, 0, 3], 3, 2, Yes, generalized_pigeonhole_load_bound).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-generalized-load · candidate
40. The Largest Fibre Is at Least the Exact Ceiling Average
Use the complete total mapping=[0, 3, 6, 2, 5, 1, 4, 0, 3, 6] from source indices Fin(10)={0,…,9} into Fin(7)={0,…,6}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. Give (loads, maximum_load, ceiling_lower_bound, bound_holds, certificate).
View answer and explanation
([2, 1, 1, 2, 1, 1, 2], 2, 2, Yes, generalized_pigeonhole_load_bound)
List every codomain load in target order. Compare its maximum with ceil(domain_count/codomain_count); the lower bound is not generally equal to the maximum load. The empty domain gives all loads0 and lower bound0 on a nonempty codomain. The exact result, retaining the requested order, is ([2, 1, 1, 2, 1, 1, 2], 2, 2, Yes, generalized_pigeonhole_load_bound).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-generalized-load · candidate
41. The Largest Fibre Is at Least the Exact Ceiling Average
Use the complete total mapping=[0, 1, 2, 0, 1, 2, 0] from source indices Fin(7)={0,…,6} into Fin(3)={0,…,2}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. Give (loads, maximum_load, ceiling_lower_bound, bound_holds, certificate).
View answer and explanation
([3, 2, 2], 3, 3, Yes, generalized_pigeonhole_load_bound)
List every codomain load in target order. Compare its maximum with ceil(domain_count/codomain_count); the lower bound is not generally equal to the maximum load. The empty domain gives all loads0 and lower bound0 on a nonempty codomain. The exact result, retaining the requested order, is ([3, 2, 2], 3, 3, Yes, generalized_pigeonhole_load_bound).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-generalized-load · candidate
42. The Largest Fibre Is at Least the Exact Ceiling Average
Use the complete total mapping=[0, 2, 0, 2, 0, 2, 0, 2] from source indices Fin(8)={0,…,7} into Fin(4)={0,…,3}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. Give (loads, maximum_load, ceiling_lower_bound, bound_holds, certificate).
View answer and explanation
([4, 0, 4, 0], 4, 2, Yes, generalized_pigeonhole_load_bound)
List every codomain load in target order. Compare its maximum with ceil(domain_count/codomain_count); the lower bound is not generally equal to the maximum load. The empty domain gives all loads0 and lower bound0 on a nonempty codomain. The exact result, retaining the requested order, is ([4, 0, 4, 0], 4, 2, Yes, generalized_pigeonhole_load_bound).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-generalized-load · candidate
43. The Largest Fibre Is at Least the Exact Ceiling Average
Use the complete total mapping=[2, 0, 3, 1, 4, 2, 0, 3, 1] from source indices Fin(9)={0,…,8} into Fin(5)={0,…,4}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. Give (loads, maximum_load, ceiling_lower_bound, bound_holds, certificate).
View answer and explanation
([2, 2, 2, 2, 1], 2, 2, Yes, generalized_pigeonhole_load_bound)
List every codomain load in target order. Compare its maximum with ceil(domain_count/codomain_count); the lower bound is not generally equal to the maximum load. The empty domain gives all loads0 and lower bound0 on a nonempty codomain. The exact result, retaining the requested order, is ([2, 2, 2, 2, 1], 2, 2, Yes, generalized_pigeonhole_load_bound).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-generalized-load · candidate
44. The Largest Fibre Is at Least the Exact Ceiling Average
Use the complete total mapping=[0, 1, 2, 3, 4, 5, 0, 1, 2, 3] from source indices Fin(10)={0,…,9} into Fin(6)={0,…,5}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. Give (loads, maximum_load, ceiling_lower_bound, bound_holds, certificate).
View answer and explanation
([2, 2, 2, 2, 1, 1], 2, 2, Yes, generalized_pigeonhole_load_bound)
List every codomain load in target order. Compare its maximum with ceil(domain_count/codomain_count); the lower bound is not generally equal to the maximum load. The empty domain gives all loads0 and lower bound0 on a nonempty codomain. The exact result, retaining the requested order, is ([2, 2, 2, 2, 1, 1], 2, 2, Yes, generalized_pigeonhole_load_bound).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-generalized-load · candidate
45. The Largest Fibre Is at Least the Exact Ceiling Average
Use the complete total mapping=[5, 0, 2, 4, 6, 1, 3, 5, 0, 2, 4] from source indices Fin(11)={0,…,10} into Fin(7)={0,…,6}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. Give (loads, maximum_load, ceiling_lower_bound, bound_holds, certificate).
View answer and explanation
([2, 1, 2, 1, 2, 2, 1], 2, 2, Yes, generalized_pigeonhole_load_bound)
List every codomain load in target order. Compare its maximum with ceil(domain_count/codomain_count); the lower bound is not generally equal to the maximum load. The empty domain gives all loads0 and lower bound0 on a nonempty codomain. The exact result, retaining the requested order, is ([2, 1, 2, 1, 2, 2, 1], 2, 2, Yes, generalized_pigeonhole_load_bound).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-generalized-load · candidate
46. The Largest Fibre Is at Least the Exact Ceiling Average
Use the complete total mapping=[2, 2, 2, 2, 2, 2, 2, 2] from source indices Fin(8)={0,…,7} into Fin(3)={0,…,2}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. Give (loads, maximum_load, ceiling_lower_bound, bound_holds, certificate).
View answer and explanation
([0, 0, 8], 8, 3, Yes, generalized_pigeonhole_load_bound)
List every codomain load in target order. Compare its maximum with ceil(domain_count/codomain_count); the lower bound is not generally equal to the maximum load. The empty domain gives all loads0 and lower bound0 on a nonempty codomain. The exact result, retaining the requested order, is ([0, 0, 8], 8, 3, Yes, generalized_pigeonhole_load_bound).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-generalized-load · candidate
47. The Largest Fibre Is at Least the Exact Ceiling Average
Use the complete total mapping=[1, 2, 3, 0, 1, 2, 3, 0, 1] from source indices Fin(9)={0,…,8} into Fin(4)={0,…,3}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. Give (loads, maximum_load, ceiling_lower_bound, bound_holds, certificate).
View answer and explanation
([2, 3, 2, 2], 3, 3, Yes, generalized_pigeonhole_load_bound)
List every codomain load in target order. Compare its maximum with ceil(domain_count/codomain_count); the lower bound is not generally equal to the maximum load. The empty domain gives all loads0 and lower bound0 on a nonempty codomain. The exact result, retaining the requested order, is ([2, 3, 2, 2], 3, 3, Yes, generalized_pigeonhole_load_bound).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-generalized-load · candidate
48. The Largest Fibre Is at Least the Exact Ceiling Average
Use the complete total mapping=[2, 4, 1, 3, 0, 2, 4, 1, 3, 0] from source indices Fin(10)={0,…,9} into Fin(5)={0,…,4}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. Give (loads, maximum_load, ceiling_lower_bound, bound_holds, certificate).
View answer and explanation
([2, 2, 2, 2, 2], 2, 2, Yes, generalized_pigeonhole_load_bound)
List every codomain load in target order. Compare its maximum with ceil(domain_count/codomain_count); the lower bound is not generally equal to the maximum load. The empty domain gives all loads0 and lower bound0 on a nonempty codomain. The exact result, retaining the requested order, is ([2, 2, 2, 2, 2], 2, 2, Yes, generalized_pigeonhole_load_bound).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-generalized-load · candidate
49. The Largest Fibre Is at Least the Exact Ceiling Average
Use the complete total mapping=[5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5] from source indices Fin(11)={0,…,10} into Fin(6)={0,…,5}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. Give (loads, maximum_load, ceiling_lower_bound, bound_holds, certificate).
View answer and explanation
([0, 0, 5, 0, 0, 6], 6, 2, Yes, generalized_pigeonhole_load_bound)
List every codomain load in target order. Compare its maximum with ceil(domain_count/codomain_count); the lower bound is not generally equal to the maximum load. The empty domain gives all loads0 and lower bound0 on a nonempty codomain. The exact result, retaining the requested order, is ([0, 0, 5, 0, 0, 6], 6, 2, Yes, generalized_pigeonhole_load_bound).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-generalized-load · candidate
50. The Largest Fibre Is at Least the Exact Ceiling Average
Use the complete total mapping=[3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 0] from source indices Fin(12)={0,…,11} into Fin(7)={0,…,6}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. Give (loads, maximum_load, ceiling_lower_bound, bound_holds, certificate).
View answer and explanation
([2, 1, 1, 2, 2, 2, 2], 2, 2, Yes, generalized_pigeonhole_load_bound)
List every codomain load in target order. Compare its maximum with ceil(domain_count/codomain_count); the lower bound is not generally equal to the maximum load. The empty domain gives all loads0 and lower bound0 on a nonempty codomain. The exact result, retaining the requested order, is ([2, 1, 1, 2, 2, 2, 2], 2, 2, Yes, generalized_pigeonhole_load_bound).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-generalized-load · candidate
51. The Size Premise Forces a Collision but Has No General Reverse Inference
Use complete finite domain size=5≥0 and codomain size=3≥1, with a total map understood but no particular map table supplied. Give (domain_count, codomain_count, domain_larger, collision_forced_by_size, general_reverse_implication_claim, boundary).
View answer and explanation
(5, 3, Yes, Yes, No, premise_guarantees_collision_but_converse_does_not_guarantee_injectivity)
Compare domain_count>codomain_count and retain the corresponding size-forced-collision flag. The final No withholds a general reverse implication; no particular map is classified as noninjective from its failure. The exact result, retaining the requested order, is (5, 3, Yes, Yes, No, premise_guarantees_collision_but_converse_does_not_guarantee_injectivity).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-premise-audit · candidate
52. The Size Premise Forces a Collision but Has No General Reverse Inference
Use complete finite domain size=6≥0 and codomain size=4≥1, with a total map understood but no particular map table supplied. Give (domain_count, codomain_count, domain_larger, collision_forced_by_size, general_reverse_implication_claim, boundary).
View answer and explanation
(6, 4, Yes, Yes, No, premise_guarantees_collision_but_converse_does_not_guarantee_injectivity)
Compare domain_count>codomain_count and retain the corresponding size-forced-collision flag. The final No withholds a general reverse implication; no particular map is classified as noninjective from its failure. The exact result, retaining the requested order, is (6, 4, Yes, Yes, No, premise_guarantees_collision_but_converse_does_not_guarantee_injectivity).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-premise-audit · candidate
53. The Size Premise Forces a Collision but Has No General Reverse Inference
Use complete finite domain size=7≥0 and codomain size=5≥1, with a total map understood but no particular map table supplied. Give (domain_count, codomain_count, domain_larger, collision_forced_by_size, general_reverse_implication_claim, boundary).
View answer and explanation
(7, 5, Yes, Yes, No, premise_guarantees_collision_but_converse_does_not_guarantee_injectivity)
Compare domain_count>codomain_count and retain the corresponding size-forced-collision flag. The final No withholds a general reverse implication; no particular map is classified as noninjective from its failure. The exact result, retaining the requested order, is (7, 5, Yes, Yes, No, premise_guarantees_collision_but_converse_does_not_guarantee_injectivity).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-premise-audit · candidate
54. The Size Premise Forces a Collision but Has No General Reverse Inference
Use complete finite domain size=8≥0 and codomain size=6≥1, with a total map understood but no particular map table supplied. Give (domain_count, codomain_count, domain_larger, collision_forced_by_size, general_reverse_implication_claim, boundary).
View answer and explanation
(8, 6, Yes, Yes, No, premise_guarantees_collision_but_converse_does_not_guarantee_injectivity)
Compare domain_count>codomain_count and retain the corresponding size-forced-collision flag. The final No withholds a general reverse implication; no particular map is classified as noninjective from its failure. The exact result, retaining the requested order, is (8, 6, Yes, Yes, No, premise_guarantees_collision_but_converse_does_not_guarantee_injectivity).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-premise-audit · candidate
55. The Size Premise Forces a Collision but Has No General Reverse Inference
Use complete finite domain size=9≥0 and codomain size=7≥1, with a total map understood but no particular map table supplied. Give (domain_count, codomain_count, domain_larger, collision_forced_by_size, general_reverse_implication_claim, boundary).
View answer and explanation
(9, 7, Yes, Yes, No, premise_guarantees_collision_but_converse_does_not_guarantee_injectivity)
Compare domain_count>codomain_count and retain the corresponding size-forced-collision flag. The final No withholds a general reverse implication; no particular map is classified as noninjective from its failure. The exact result, retaining the requested order, is (9, 7, Yes, Yes, No, premise_guarantees_collision_but_converse_does_not_guarantee_injectivity).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-premise-audit · candidate
56. The Size Premise Forces a Collision but Has No General Reverse Inference
Use complete finite domain size=10≥0 and codomain size=8≥1, with a total map understood but no particular map table supplied. Give (domain_count, codomain_count, domain_larger, collision_forced_by_size, general_reverse_implication_claim, boundary).
View answer and explanation
(10, 8, Yes, Yes, No, premise_guarantees_collision_but_converse_does_not_guarantee_injectivity)
Compare domain_count>codomain_count and retain the corresponding size-forced-collision flag. The final No withholds a general reverse implication; no particular map is classified as noninjective from its failure. The exact result, retaining the requested order, is (10, 8, Yes, Yes, No, premise_guarantees_collision_but_converse_does_not_guarantee_injectivity).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-premise-audit · candidate
57. The Size Premise Forces a Collision but Has No General Reverse Inference
Use complete finite domain size=11≥0 and codomain size=9≥1, with a total map understood but no particular map table supplied. Give (domain_count, codomain_count, domain_larger, collision_forced_by_size, general_reverse_implication_claim, boundary).
View answer and explanation
(11, 9, Yes, Yes, No, premise_guarantees_collision_but_converse_does_not_guarantee_injectivity)
Compare domain_count>codomain_count and retain the corresponding size-forced-collision flag. The final No withholds a general reverse implication; no particular map is classified as noninjective from its failure. The exact result, retaining the requested order, is (11, 9, Yes, Yes, No, premise_guarantees_collision_but_converse_does_not_guarantee_injectivity).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-premise-audit · candidate
58. The Size Premise Forces a Collision but Has No General Reverse Inference
Use complete finite domain size=12≥0 and codomain size=10≥1, with a total map understood but no particular map table supplied. Give (domain_count, codomain_count, domain_larger, collision_forced_by_size, general_reverse_implication_claim, boundary).
View answer and explanation
(12, 10, Yes, Yes, No, premise_guarantees_collision_but_converse_does_not_guarantee_injectivity)
Compare domain_count>codomain_count and retain the corresponding size-forced-collision flag. The final No withholds a general reverse implication; no particular map is classified as noninjective from its failure. The exact result, retaining the requested order, is (12, 10, Yes, Yes, No, premise_guarantees_collision_but_converse_does_not_guarantee_injectivity).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-premise-audit · candidate
59. The Size Premise Forces a Collision but Has No General Reverse Inference
Use complete finite domain size=13≥0 and codomain size=11≥1, with a total map understood but no particular map table supplied. Give (domain_count, codomain_count, domain_larger, collision_forced_by_size, general_reverse_implication_claim, boundary).
View answer and explanation
(13, 11, Yes, Yes, No, premise_guarantees_collision_but_converse_does_not_guarantee_injectivity)
Compare domain_count>codomain_count and retain the corresponding size-forced-collision flag. The final No withholds a general reverse implication; no particular map is classified as noninjective from its failure. The exact result, retaining the requested order, is (13, 11, Yes, Yes, No, premise_guarantees_collision_but_converse_does_not_guarantee_injectivity).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-premise-audit · candidate
60. The Size Premise Forces a Collision but Has No General Reverse Inference
Use complete finite domain size=14≥0 and codomain size=12≥1, with a total map understood but no particular map table supplied. Give (domain_count, codomain_count, domain_larger, collision_forced_by_size, general_reverse_implication_claim, boundary).
View answer and explanation
(14, 12, Yes, Yes, No, premise_guarantees_collision_but_converse_does_not_guarantee_injectivity)
Compare domain_count>codomain_count and retain the corresponding size-forced-collision flag. The final No withholds a general reverse implication; no particular map is classified as noninjective from its failure. The exact result, retaining the requested order, is (14, 12, Yes, Yes, No, premise_guarantees_collision_but_converse_does_not_guarantee_injectivity).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-premise-audit · candidate
61. The Size Premise Forces a Collision but Has No General Reverse Inference
Use complete finite domain size=15≥0 and codomain size=13≥1, with a total map understood but no particular map table supplied. Give (domain_count, codomain_count, domain_larger, collision_forced_by_size, general_reverse_implication_claim, boundary).
View answer and explanation
(15, 13, Yes, Yes, No, premise_guarantees_collision_but_converse_does_not_guarantee_injectivity)
Compare domain_count>codomain_count and retain the corresponding size-forced-collision flag. The final No withholds a general reverse implication; no particular map is classified as noninjective from its failure. The exact result, retaining the requested order, is (15, 13, Yes, Yes, No, premise_guarantees_collision_but_converse_does_not_guarantee_injectivity).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-premise-audit · candidate
62. The Size Premise Forces a Collision but Has No General Reverse Inference
Use complete finite domain size=16≥0 and codomain size=14≥1, with a total map understood but no particular map table supplied. Give (domain_count, codomain_count, domain_larger, collision_forced_by_size, general_reverse_implication_claim, boundary).
View answer and explanation
(16, 14, Yes, Yes, No, premise_guarantees_collision_but_converse_does_not_guarantee_injectivity)
Compare domain_count>codomain_count and retain the corresponding size-forced-collision flag. The final No withholds a general reverse implication; no particular map is classified as noninjective from its failure. The exact result, retaining the requested order, is (16, 14, Yes, Yes, No, premise_guarantees_collision_but_converse_does_not_guarantee_injectivity).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-premise-audit · candidate
63. The Size Premise Forces a Collision but Has No General Reverse Inference
Use complete finite domain size=17≥0 and codomain size=15≥1, with a total map understood but no particular map table supplied. Give (domain_count, codomain_count, domain_larger, collision_forced_by_size, general_reverse_implication_claim, boundary).
View answer and explanation
(17, 15, Yes, Yes, No, premise_guarantees_collision_but_converse_does_not_guarantee_injectivity)
Compare domain_count>codomain_count and retain the corresponding size-forced-collision flag. The final No withholds a general reverse implication; no particular map is classified as noninjective from its failure. The exact result, retaining the requested order, is (17, 15, Yes, Yes, No, premise_guarantees_collision_but_converse_does_not_guarantee_injectivity).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-premise-audit · candidate
64. The Size Premise Forces a Collision but Has No General Reverse Inference
Use complete finite domain size=18≥0 and codomain size=16≥1, with a total map understood but no particular map table supplied. Give (domain_count, codomain_count, domain_larger, collision_forced_by_size, general_reverse_implication_claim, boundary).
View answer and explanation
(18, 16, Yes, Yes, No, premise_guarantees_collision_but_converse_does_not_guarantee_injectivity)
Compare domain_count>codomain_count and retain the corresponding size-forced-collision flag. The final No withholds a general reverse implication; no particular map is classified as noninjective from its failure. The exact result, retaining the requested order, is (18, 16, Yes, Yes, No, premise_guarantees_collision_but_converse_does_not_guarantee_injectivity).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-premise-audit · candidate
65. The Size Premise Forces a Collision but Has No General Reverse Inference
Use complete finite domain size=19≥0 and codomain size=17≥1, with a total map understood but no particular map table supplied. Give (domain_count, codomain_count, domain_larger, collision_forced_by_size, general_reverse_implication_claim, boundary).
View answer and explanation
(19, 17, Yes, Yes, No, premise_guarantees_collision_but_converse_does_not_guarantee_injectivity)
Compare domain_count>codomain_count and retain the corresponding size-forced-collision flag. The final No withholds a general reverse implication; no particular map is classified as noninjective from its failure. The exact result, retaining the requested order, is (19, 17, Yes, Yes, No, premise_guarantees_collision_but_converse_does_not_guarantee_injectivity).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-premise-audit · candidate
66. The Size Premise Forces a Collision but Has No General Reverse Inference
Use complete finite domain size=20≥0 and codomain size=18≥1, with a total map understood but no particular map table supplied. Give (domain_count, codomain_count, domain_larger, collision_forced_by_size, general_reverse_implication_claim, boundary).
View answer and explanation
(20, 18, Yes, Yes, No, premise_guarantees_collision_but_converse_does_not_guarantee_injectivity)
Compare domain_count>codomain_count and retain the corresponding size-forced-collision flag. The final No withholds a general reverse implication; no particular map is classified as noninjective from its failure. The exact result, retaining the requested order, is (20, 18, Yes, Yes, No, premise_guarantees_collision_but_converse_does_not_guarantee_injectivity).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-premise-audit · candidate
67. The Size Premise Forces a Collision but Has No General Reverse Inference
Use complete finite domain size=21≥0 and codomain size=19≥1, with a total map understood but no particular map table supplied. Give (domain_count, codomain_count, domain_larger, collision_forced_by_size, general_reverse_implication_claim, boundary).
View answer and explanation
(21, 19, Yes, Yes, No, premise_guarantees_collision_but_converse_does_not_guarantee_injectivity)
Compare domain_count>codomain_count and retain the corresponding size-forced-collision flag. The final No withholds a general reverse implication; no particular map is classified as noninjective from its failure. The exact result, retaining the requested order, is (21, 19, Yes, Yes, No, premise_guarantees_collision_but_converse_does_not_guarantee_injectivity).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-premise-audit · candidate
68. The Size Premise Forces a Collision but Has No General Reverse Inference
Use complete finite domain size=22≥0 and codomain size=20≥1, with a total map understood but no particular map table supplied. Give (domain_count, codomain_count, domain_larger, collision_forced_by_size, general_reverse_implication_claim, boundary).
View answer and explanation
(22, 20, Yes, Yes, No, premise_guarantees_collision_but_converse_does_not_guarantee_injectivity)
Compare domain_count>codomain_count and retain the corresponding size-forced-collision flag. The final No withholds a general reverse implication; no particular map is classified as noninjective from its failure. The exact result, retaining the requested order, is (22, 20, Yes, Yes, No, premise_guarantees_collision_but_converse_does_not_guarantee_injectivity).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-premise-audit · candidate
69. The Size Premise Forces a Collision but Has No General Reverse Inference
Use complete finite domain size=23≥0 and codomain size=21≥1, with a total map understood but no particular map table supplied. Give (domain_count, codomain_count, domain_larger, collision_forced_by_size, general_reverse_implication_claim, boundary).
View answer and explanation
(23, 21, Yes, Yes, No, premise_guarantees_collision_but_converse_does_not_guarantee_injectivity)
Compare domain_count>codomain_count and retain the corresponding size-forced-collision flag. The final No withholds a general reverse implication; no particular map is classified as noninjective from its failure. The exact result, retaining the requested order, is (23, 21, Yes, Yes, No, premise_guarantees_collision_but_converse_does_not_guarantee_injectivity).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-premise-audit · candidate
70. The Size Premise Forces a Collision but Has No General Reverse Inference
Use complete finite domain size=24≥0 and codomain size=22≥1, with a total map understood but no particular map table supplied. Give (domain_count, codomain_count, domain_larger, collision_forced_by_size, general_reverse_implication_claim, boundary).
View answer and explanation
(24, 22, Yes, Yes, No, premise_guarantees_collision_but_converse_does_not_guarantee_injectivity)
Compare domain_count>codomain_count and retain the corresponding size-forced-collision flag. The final No withholds a general reverse implication; no particular map is classified as noninjective from its failure. The exact result, retaining the requested order, is (24, 22, Yes, Yes, No, premise_guarantees_collision_but_converse_does_not_guarantee_injectivity).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-premise-audit · candidate
71. The Size Premise Forces a Collision but Has No General Reverse Inference
Use complete finite domain size=25≥0 and codomain size=23≥1, with a total map understood but no particular map table supplied. Give (domain_count, codomain_count, domain_larger, collision_forced_by_size, general_reverse_implication_claim, boundary).
View answer and explanation
(25, 23, Yes, Yes, No, premise_guarantees_collision_but_converse_does_not_guarantee_injectivity)
Compare domain_count>codomain_count and retain the corresponding size-forced-collision flag. The final No withholds a general reverse implication; no particular map is classified as noninjective from its failure. The exact result, retaining the requested order, is (25, 23, Yes, Yes, No, premise_guarantees_collision_but_converse_does_not_guarantee_injectivity).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-premise-audit · candidate
72. The Size Premise Forces a Collision but Has No General Reverse Inference
Use complete finite domain size=26≥0 and codomain size=24≥1, with a total map understood but no particular map table supplied. Give (domain_count, codomain_count, domain_larger, collision_forced_by_size, general_reverse_implication_claim, boundary).
View answer and explanation
(26, 24, Yes, Yes, No, premise_guarantees_collision_but_converse_does_not_guarantee_injectivity)
Compare domain_count>codomain_count and retain the corresponding size-forced-collision flag. The final No withholds a general reverse implication; no particular map is classified as noninjective from its failure. The exact result, retaining the requested order, is (26, 24, Yes, Yes, No, premise_guarantees_collision_but_converse_does_not_guarantee_injectivity).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-premise-audit · candidate
73. The Size Premise Forces a Collision but Has No General Reverse Inference
Use complete finite domain size=27≥0 and codomain size=25≥1, with a total map understood but no particular map table supplied. Give (domain_count, codomain_count, domain_larger, collision_forced_by_size, general_reverse_implication_claim, boundary).
View answer and explanation
(27, 25, Yes, Yes, No, premise_guarantees_collision_but_converse_does_not_guarantee_injectivity)
Compare domain_count>codomain_count and retain the corresponding size-forced-collision flag. The final No withholds a general reverse implication; no particular map is classified as noninjective from its failure. The exact result, retaining the requested order, is (27, 25, Yes, Yes, No, premise_guarantees_collision_but_converse_does_not_guarantee_injectivity).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-premise-audit · candidate
74. The Size Premise Forces a Collision but Has No General Reverse Inference
Use complete finite domain size=28≥0 and codomain size=26≥1, with a total map understood but no particular map table supplied. Give (domain_count, codomain_count, domain_larger, collision_forced_by_size, general_reverse_implication_claim, boundary).
View answer and explanation
(28, 26, Yes, Yes, No, premise_guarantees_collision_but_converse_does_not_guarantee_injectivity)
Compare domain_count>codomain_count and retain the corresponding size-forced-collision flag. The final No withholds a general reverse implication; no particular map is classified as noninjective from its failure. The exact result, retaining the requested order, is (28, 26, Yes, Yes, No, premise_guarantees_collision_but_converse_does_not_guarantee_injectivity).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-premise-audit · candidate
75. The Size Premise Forces a Collision but Has No General Reverse Inference
Use complete finite domain size=29≥0 and codomain size=27≥1, with a total map understood but no particular map table supplied. Give (domain_count, codomain_count, domain_larger, collision_forced_by_size, general_reverse_implication_claim, boundary).
View answer and explanation
(29, 27, Yes, Yes, No, premise_guarantees_collision_but_converse_does_not_guarantee_injectivity)
Compare domain_count>codomain_count and retain the corresponding size-forced-collision flag. The final No withholds a general reverse implication; no particular map is classified as noninjective from its failure. The exact result, retaining the requested order, is (29, 27, Yes, Yes, No, premise_guarantees_collision_but_converse_does_not_guarantee_injectivity).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-premise-audit · candidate
76. A Smaller Domain Does Not Generally Decide the Given Map Is Injective
Use the complete total mapping=[0, 0, 2] from source indices Fin(3)={0,…,2} into Fin(4)={0,…,3}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. Domain size is at most codomain size. Give (domain_count, codomain_count, given_map_injective, general_reverse_implication_claim, boundary).
The final No withholds a general reverse implication; the preceding flag separately checks this map. Empty or singleton domains may be injective.
View answer and explanation
(3, 4, No, No, size_condition_failure_does_not_imply_given_map_is_injective)
Check this complete map for injectivity separately, then retain No for the general reverse implication. Empty or singleton source maps are injective, while some larger sources still collide; the nonclaim is not a forced No injectivity flag. The exact result, retaining the requested order, is (3, 4, No, No, size_condition_failure_does_not_imply_given_map_is_injective).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-converse-boundary · candidate
77. A Smaller Domain Does Not Generally Decide the Given Map Is Injective
Use the complete total mapping=[0, 0, 2, 3] from source indices Fin(4)={0,…,3} into Fin(5)={0,…,4}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. Domain size is at most codomain size. Give (domain_count, codomain_count, given_map_injective, general_reverse_implication_claim, boundary).
The final No withholds a general reverse implication; the preceding flag separately checks this map. Empty or singleton domains may be injective.
View answer and explanation
(4, 5, No, No, size_condition_failure_does_not_imply_given_map_is_injective)
Check this complete map for injectivity separately, then retain No for the general reverse implication. Empty or singleton source maps are injective, while some larger sources still collide; the nonclaim is not a forced No injectivity flag. The exact result, retaining the requested order, is (4, 5, No, No, size_condition_failure_does_not_imply_given_map_is_injective).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-converse-boundary · candidate
78. A Smaller Domain Does Not Generally Decide the Given Map Is Injective
Use the complete total mapping=[0, 0, 2, 3, 4] from source indices Fin(5)={0,…,4} into Fin(6)={0,…,5}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. Domain size is at most codomain size. Give (domain_count, codomain_count, given_map_injective, general_reverse_implication_claim, boundary).
The final No withholds a general reverse implication; the preceding flag separately checks this map. Empty or singleton domains may be injective.
View answer and explanation
(5, 6, No, No, size_condition_failure_does_not_imply_given_map_is_injective)
Check this complete map for injectivity separately, then retain No for the general reverse implication. Empty or singleton source maps are injective, while some larger sources still collide; the nonclaim is not a forced No injectivity flag. The exact result, retaining the requested order, is (5, 6, No, No, size_condition_failure_does_not_imply_given_map_is_injective).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-converse-boundary · candidate
79. A Smaller Domain Does Not Generally Decide the Given Map Is Injective
Use the complete total mapping=[0, 0, 2, 3, 4, 5] from source indices Fin(6)={0,…,5} into Fin(7)={0,…,6}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. Domain size is at most codomain size. Give (domain_count, codomain_count, given_map_injective, general_reverse_implication_claim, boundary).
The final No withholds a general reverse implication; the preceding flag separately checks this map. Empty or singleton domains may be injective.
View answer and explanation
(6, 7, No, No, size_condition_failure_does_not_imply_given_map_is_injective)
Check this complete map for injectivity separately, then retain No for the general reverse implication. Empty or singleton source maps are injective, while some larger sources still collide; the nonclaim is not a forced No injectivity flag. The exact result, retaining the requested order, is (6, 7, No, No, size_condition_failure_does_not_imply_given_map_is_injective).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-converse-boundary · candidate
80. A Smaller Domain Does Not Generally Decide the Given Map Is Injective
Use the complete total mapping=[0, 0, 2, 3, 4, 5, 6] from source indices Fin(7)={0,…,6} into Fin(8)={0,…,7}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. Domain size is at most codomain size. Give (domain_count, codomain_count, given_map_injective, general_reverse_implication_claim, boundary).
The final No withholds a general reverse implication; the preceding flag separately checks this map. Empty or singleton domains may be injective.
View answer and explanation
(7, 8, No, No, size_condition_failure_does_not_imply_given_map_is_injective)
Check this complete map for injectivity separately, then retain No for the general reverse implication. Empty or singleton source maps are injective, while some larger sources still collide; the nonclaim is not a forced No injectivity flag. The exact result, retaining the requested order, is (7, 8, No, No, size_condition_failure_does_not_imply_given_map_is_injective).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-converse-boundary · candidate
81. A Smaller Domain Does Not Generally Decide the Given Map Is Injective
Use the complete total mapping=[0, 0, 2] from source indices Fin(3)={0,…,2} into Fin(5)={0,…,4}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. Domain size is at most codomain size. Give (domain_count, codomain_count, given_map_injective, general_reverse_implication_claim, boundary).
The final No withholds a general reverse implication; the preceding flag separately checks this map. Empty or singleton domains may be injective.
View answer and explanation
(3, 5, No, No, size_condition_failure_does_not_imply_given_map_is_injective)
Check this complete map for injectivity separately, then retain No for the general reverse implication. Empty or singleton source maps are injective, while some larger sources still collide; the nonclaim is not a forced No injectivity flag. The exact result, retaining the requested order, is (3, 5, No, No, size_condition_failure_does_not_imply_given_map_is_injective).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-converse-boundary · candidate
82. A Smaller Domain Does Not Generally Decide the Given Map Is Injective
Use the complete total mapping=[0, 0, 2, 3] from source indices Fin(4)={0,…,3} into Fin(6)={0,…,5}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. Domain size is at most codomain size. Give (domain_count, codomain_count, given_map_injective, general_reverse_implication_claim, boundary).
The final No withholds a general reverse implication; the preceding flag separately checks this map. Empty or singleton domains may be injective.
View answer and explanation
(4, 6, No, No, size_condition_failure_does_not_imply_given_map_is_injective)
Check this complete map for injectivity separately, then retain No for the general reverse implication. Empty or singleton source maps are injective, while some larger sources still collide; the nonclaim is not a forced No injectivity flag. The exact result, retaining the requested order, is (4, 6, No, No, size_condition_failure_does_not_imply_given_map_is_injective).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-converse-boundary · candidate
83. A Smaller Domain Does Not Generally Decide the Given Map Is Injective
Use the complete total mapping=[0, 0, 2, 3, 4] from source indices Fin(5)={0,…,4} into Fin(7)={0,…,6}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. Domain size is at most codomain size. Give (domain_count, codomain_count, given_map_injective, general_reverse_implication_claim, boundary).
The final No withholds a general reverse implication; the preceding flag separately checks this map. Empty or singleton domains may be injective.
View answer and explanation
(5, 7, No, No, size_condition_failure_does_not_imply_given_map_is_injective)
Check this complete map for injectivity separately, then retain No for the general reverse implication. Empty or singleton source maps are injective, while some larger sources still collide; the nonclaim is not a forced No injectivity flag. The exact result, retaining the requested order, is (5, 7, No, No, size_condition_failure_does_not_imply_given_map_is_injective).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-converse-boundary · candidate
84. A Smaller Domain Does Not Generally Decide the Given Map Is Injective
Use the complete total mapping=[0, 0, 2, 3, 4, 5] from source indices Fin(6)={0,…,5} into Fin(8)={0,…,7}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. Domain size is at most codomain size. Give (domain_count, codomain_count, given_map_injective, general_reverse_implication_claim, boundary).
The final No withholds a general reverse implication; the preceding flag separately checks this map. Empty or singleton domains may be injective.
View answer and explanation
(6, 8, No, No, size_condition_failure_does_not_imply_given_map_is_injective)
Check this complete map for injectivity separately, then retain No for the general reverse implication. Empty or singleton source maps are injective, while some larger sources still collide; the nonclaim is not a forced No injectivity flag. The exact result, retaining the requested order, is (6, 8, No, No, size_condition_failure_does_not_imply_given_map_is_injective).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-converse-boundary · candidate
85. A Smaller Domain Does Not Generally Decide the Given Map Is Injective
Use the complete total mapping=[0, 0, 2, 3, 4, 5, 6] from source indices Fin(7)={0,…,6} into Fin(9)={0,…,8}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. Domain size is at most codomain size. Give (domain_count, codomain_count, given_map_injective, general_reverse_implication_claim, boundary).
The final No withholds a general reverse implication; the preceding flag separately checks this map. Empty or singleton domains may be injective.
View answer and explanation
(7, 9, No, No, size_condition_failure_does_not_imply_given_map_is_injective)
Check this complete map for injectivity separately, then retain No for the general reverse implication. Empty or singleton source maps are injective, while some larger sources still collide; the nonclaim is not a forced No injectivity flag. The exact result, retaining the requested order, is (7, 9, No, No, size_condition_failure_does_not_imply_given_map_is_injective).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-converse-boundary · candidate
86. A Smaller Domain Does Not Generally Decide the Given Map Is Injective
Use the complete total mapping=[0, 0, 2] from source indices Fin(3)={0,…,2} into Fin(6)={0,…,5}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. Domain size is at most codomain size. Give (domain_count, codomain_count, given_map_injective, general_reverse_implication_claim, boundary).
The final No withholds a general reverse implication; the preceding flag separately checks this map. Empty or singleton domains may be injective.
View answer and explanation
(3, 6, No, No, size_condition_failure_does_not_imply_given_map_is_injective)
Check this complete map for injectivity separately, then retain No for the general reverse implication. Empty or singleton source maps are injective, while some larger sources still collide; the nonclaim is not a forced No injectivity flag. The exact result, retaining the requested order, is (3, 6, No, No, size_condition_failure_does_not_imply_given_map_is_injective).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-converse-boundary · candidate
87. A Smaller Domain Does Not Generally Decide the Given Map Is Injective
Use the complete total mapping=[0, 0, 2, 3] from source indices Fin(4)={0,…,3} into Fin(7)={0,…,6}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. Domain size is at most codomain size. Give (domain_count, codomain_count, given_map_injective, general_reverse_implication_claim, boundary).
The final No withholds a general reverse implication; the preceding flag separately checks this map. Empty or singleton domains may be injective.
View answer and explanation
(4, 7, No, No, size_condition_failure_does_not_imply_given_map_is_injective)
Check this complete map for injectivity separately, then retain No for the general reverse implication. Empty or singleton source maps are injective, while some larger sources still collide; the nonclaim is not a forced No injectivity flag. The exact result, retaining the requested order, is (4, 7, No, No, size_condition_failure_does_not_imply_given_map_is_injective).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-converse-boundary · candidate
88. A Smaller Domain Does Not Generally Decide the Given Map Is Injective
Use the complete total mapping=[0, 0, 2, 3, 4] from source indices Fin(5)={0,…,4} into Fin(8)={0,…,7}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. Domain size is at most codomain size. Give (domain_count, codomain_count, given_map_injective, general_reverse_implication_claim, boundary).
The final No withholds a general reverse implication; the preceding flag separately checks this map. Empty or singleton domains may be injective.
View answer and explanation
(5, 8, No, No, size_condition_failure_does_not_imply_given_map_is_injective)
Check this complete map for injectivity separately, then retain No for the general reverse implication. Empty or singleton source maps are injective, while some larger sources still collide; the nonclaim is not a forced No injectivity flag. The exact result, retaining the requested order, is (5, 8, No, No, size_condition_failure_does_not_imply_given_map_is_injective).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-converse-boundary · candidate
89. A Smaller Domain Does Not Generally Decide the Given Map Is Injective
Use the complete total mapping=[0, 0, 2, 3, 4, 5] from source indices Fin(6)={0,…,5} into Fin(9)={0,…,8}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. Domain size is at most codomain size. Give (domain_count, codomain_count, given_map_injective, general_reverse_implication_claim, boundary).
The final No withholds a general reverse implication; the preceding flag separately checks this map. Empty or singleton domains may be injective.
View answer and explanation
(6, 9, No, No, size_condition_failure_does_not_imply_given_map_is_injective)
Check this complete map for injectivity separately, then retain No for the general reverse implication. Empty or singleton source maps are injective, while some larger sources still collide; the nonclaim is not a forced No injectivity flag. The exact result, retaining the requested order, is (6, 9, No, No, size_condition_failure_does_not_imply_given_map_is_injective).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-converse-boundary · candidate
90. A Smaller Domain Does Not Generally Decide the Given Map Is Injective
Use the complete total mapping=[0, 0, 2, 3, 4, 5, 6] from source indices Fin(7)={0,…,6} into Fin(10)={0,…,9}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. Domain size is at most codomain size. Give (domain_count, codomain_count, given_map_injective, general_reverse_implication_claim, boundary).
The final No withholds a general reverse implication; the preceding flag separately checks this map. Empty or singleton domains may be injective.
View answer and explanation
(7, 10, No, No, size_condition_failure_does_not_imply_given_map_is_injective)
Check this complete map for injectivity separately, then retain No for the general reverse implication. Empty or singleton source maps are injective, while some larger sources still collide; the nonclaim is not a forced No injectivity flag. The exact result, retaining the requested order, is (7, 10, No, No, size_condition_failure_does_not_imply_given_map_is_injective).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-converse-boundary · candidate
91. A Smaller Domain Does Not Generally Decide the Given Map Is Injective
Use the complete total mapping=[0, 0, 2] from source indices Fin(3)={0,…,2} into Fin(7)={0,…,6}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. Domain size is at most codomain size. Give (domain_count, codomain_count, given_map_injective, general_reverse_implication_claim, boundary).
The final No withholds a general reverse implication; the preceding flag separately checks this map. Empty or singleton domains may be injective.
View answer and explanation
(3, 7, No, No, size_condition_failure_does_not_imply_given_map_is_injective)
Check this complete map for injectivity separately, then retain No for the general reverse implication. Empty or singleton source maps are injective, while some larger sources still collide; the nonclaim is not a forced No injectivity flag. The exact result, retaining the requested order, is (3, 7, No, No, size_condition_failure_does_not_imply_given_map_is_injective).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-converse-boundary · candidate
92. A Smaller Domain Does Not Generally Decide the Given Map Is Injective
Use the complete total mapping=[0, 0, 2, 3] from source indices Fin(4)={0,…,3} into Fin(8)={0,…,7}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. Domain size is at most codomain size. Give (domain_count, codomain_count, given_map_injective, general_reverse_implication_claim, boundary).
The final No withholds a general reverse implication; the preceding flag separately checks this map. Empty or singleton domains may be injective.
View answer and explanation
(4, 8, No, No, size_condition_failure_does_not_imply_given_map_is_injective)
Check this complete map for injectivity separately, then retain No for the general reverse implication. Empty or singleton source maps are injective, while some larger sources still collide; the nonclaim is not a forced No injectivity flag. The exact result, retaining the requested order, is (4, 8, No, No, size_condition_failure_does_not_imply_given_map_is_injective).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-converse-boundary · candidate
93. A Smaller Domain Does Not Generally Decide the Given Map Is Injective
Use the complete total mapping=[0, 0, 2, 3, 4] from source indices Fin(5)={0,…,4} into Fin(9)={0,…,8}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. Domain size is at most codomain size. Give (domain_count, codomain_count, given_map_injective, general_reverse_implication_claim, boundary).
The final No withholds a general reverse implication; the preceding flag separately checks this map. Empty or singleton domains may be injective.
View answer and explanation
(5, 9, No, No, size_condition_failure_does_not_imply_given_map_is_injective)
Check this complete map for injectivity separately, then retain No for the general reverse implication. Empty or singleton source maps are injective, while some larger sources still collide; the nonclaim is not a forced No injectivity flag. The exact result, retaining the requested order, is (5, 9, No, No, size_condition_failure_does_not_imply_given_map_is_injective).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-converse-boundary · candidate
94. A Smaller Domain Does Not Generally Decide the Given Map Is Injective
Use the complete total mapping=[0, 0, 2, 3, 4, 5] from source indices Fin(6)={0,…,5} into Fin(10)={0,…,9}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. Domain size is at most codomain size. Give (domain_count, codomain_count, given_map_injective, general_reverse_implication_claim, boundary).
The final No withholds a general reverse implication; the preceding flag separately checks this map. Empty or singleton domains may be injective.
View answer and explanation
(6, 10, No, No, size_condition_failure_does_not_imply_given_map_is_injective)
Check this complete map for injectivity separately, then retain No for the general reverse implication. Empty or singleton source maps are injective, while some larger sources still collide; the nonclaim is not a forced No injectivity flag. The exact result, retaining the requested order, is (6, 10, No, No, size_condition_failure_does_not_imply_given_map_is_injective).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-converse-boundary · candidate
95. A Smaller Domain Does Not Generally Decide the Given Map Is Injective
Use the complete total mapping=[0, 0, 2, 3, 4, 5, 6] from source indices Fin(7)={0,…,6} into Fin(11)={0,…,10}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. Domain size is at most codomain size. Give (domain_count, codomain_count, given_map_injective, general_reverse_implication_claim, boundary).
The final No withholds a general reverse implication; the preceding flag separately checks this map. Empty or singleton domains may be injective.
View answer and explanation
(7, 11, No, No, size_condition_failure_does_not_imply_given_map_is_injective)
Check this complete map for injectivity separately, then retain No for the general reverse implication. Empty or singleton source maps are injective, while some larger sources still collide; the nonclaim is not a forced No injectivity flag. The exact result, retaining the requested order, is (7, 11, No, No, size_condition_failure_does_not_imply_given_map_is_injective).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-converse-boundary · candidate
96. A Smaller Domain Does Not Generally Decide the Given Map Is Injective
Use the complete total mapping=[0, 0, 2] from source indices Fin(3)={0,…,2} into Fin(8)={0,…,7}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. Domain size is at most codomain size. Give (domain_count, codomain_count, given_map_injective, general_reverse_implication_claim, boundary).
The final No withholds a general reverse implication; the preceding flag separately checks this map. Empty or singleton domains may be injective.
View answer and explanation
(3, 8, No, No, size_condition_failure_does_not_imply_given_map_is_injective)
Check this complete map for injectivity separately, then retain No for the general reverse implication. Empty or singleton source maps are injective, while some larger sources still collide; the nonclaim is not a forced No injectivity flag. The exact result, retaining the requested order, is (3, 8, No, No, size_condition_failure_does_not_imply_given_map_is_injective).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-converse-boundary · candidate
97. A Smaller Domain Does Not Generally Decide the Given Map Is Injective
Use the complete total mapping=[0, 0, 2, 3] from source indices Fin(4)={0,…,3} into Fin(9)={0,…,8}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. Domain size is at most codomain size. Give (domain_count, codomain_count, given_map_injective, general_reverse_implication_claim, boundary).
The final No withholds a general reverse implication; the preceding flag separately checks this map. Empty or singleton domains may be injective.
View answer and explanation
(4, 9, No, No, size_condition_failure_does_not_imply_given_map_is_injective)
Check this complete map for injectivity separately, then retain No for the general reverse implication. Empty or singleton source maps are injective, while some larger sources still collide; the nonclaim is not a forced No injectivity flag. The exact result, retaining the requested order, is (4, 9, No, No, size_condition_failure_does_not_imply_given_map_is_injective).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-converse-boundary · candidate
98. A Smaller Domain Does Not Generally Decide the Given Map Is Injective
Use the complete total mapping=[0, 0, 2, 3, 4] from source indices Fin(5)={0,…,4} into Fin(10)={0,…,9}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. Domain size is at most codomain size. Give (domain_count, codomain_count, given_map_injective, general_reverse_implication_claim, boundary).
The final No withholds a general reverse implication; the preceding flag separately checks this map. Empty or singleton domains may be injective.
View answer and explanation
(5, 10, No, No, size_condition_failure_does_not_imply_given_map_is_injective)
Check this complete map for injectivity separately, then retain No for the general reverse implication. Empty or singleton source maps are injective, while some larger sources still collide; the nonclaim is not a forced No injectivity flag. The exact result, retaining the requested order, is (5, 10, No, No, size_condition_failure_does_not_imply_given_map_is_injective).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-converse-boundary · candidate
99. A Smaller Domain Does Not Generally Decide the Given Map Is Injective
Use the complete total mapping=[0, 0, 2, 3, 4, 5] from source indices Fin(6)={0,…,5} into Fin(11)={0,…,10}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. Domain size is at most codomain size. Give (domain_count, codomain_count, given_map_injective, general_reverse_implication_claim, boundary).
The final No withholds a general reverse implication; the preceding flag separately checks this map. Empty or singleton domains may be injective.
View answer and explanation
(6, 11, No, No, size_condition_failure_does_not_imply_given_map_is_injective)
Check this complete map for injectivity separately, then retain No for the general reverse implication. Empty or singleton source maps are injective, while some larger sources still collide; the nonclaim is not a forced No injectivity flag. The exact result, retaining the requested order, is (6, 11, No, No, size_condition_failure_does_not_imply_given_map_is_injective).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-converse-boundary · candidate
100. A Smaller Domain Does Not Generally Decide the Given Map Is Injective
Use the complete total mapping=[0, 0, 2, 3, 4, 5, 6] from source indices Fin(7)={0,…,6} into Fin(12)={0,…,11}. The codomain is nonempty; every source has exactly one in-range image. Compute full fibre loads and collisions, not a sample. Domain size is at most codomain size. Give (domain_count, codomain_count, given_map_injective, general_reverse_implication_claim, boundary).
The final No withholds a general reverse implication; the preceding flag separately checks this map. Empty or singleton domains may be injective.
View answer and explanation
(7, 12, No, No, size_condition_failure_does_not_imply_given_map_is_injective)
Check this complete map for injectivity separately, then retain No for the general reverse implication. Empty or singleton source maps are injective, while some larger sources still collide; the nonclaim is not a forced No injectivity flag. The exact result, retaining the requested order, is (7, 12, No, No, size_condition_failure_does_not_imply_given_map_is_injective).
Reviewed step-by-step derivation
Pigeonhole principle · qf-mod38-pigeon-converse-boundary · candidate
Canonical question JSONL · English JSONL · Validation report