Step-by-step derivation
S001 · implies
Before
source roles = [regex-boundary]
After
derived = [[mode, bound, left_bounded_language, right_bounded_language, equal_through_bound, next_bound, left_next_language, right_next_language, differs_at_next_bound, unbounded_equivalence_claim, boundary]]
Conditions: none
List the complete operation/mode field order without JavaScript or answer-shape inference;Boolean,string,null and an unclaimed result remain distinct.
Step identifiers and dependencies
Rule: source_ordered_fields_without_JS · Uses: G001
S002 · implies
Before
source roles = [Regex boundary LEFT.ast, [b], {'type': 'epsilon'}]After
derived = [{'type': 'epsilon'}, {type:"epsilon"}]Conditions: none
For EACH node qualify type,exact keys and symbol membership.A union checks raw arity>=2 BEFORE extensional deduplication,so its canonical form may have one child.Concatenation retains order and star retains its child.Do not revalidate canonical output as raw input with a new arity gate.
Step identifiers and dependencies
Rule: Regex_EACH_typed_node_exact_keys_symbol_scope_union_set_concat_order · Uses: G001, S001
S003 · implies
Before
source roles = [[b], 5]
After
derived = [6]
Conditions: none
The bounded universe has sum |alphabet|^k words,including epsilon,and source budget<=4096.This defines complete bounded enumeration,not unbounded equivalence.
Step identifiers and dependencies
Rule: Regex_COMPLETE_bounded_word_universe_not_unbounded_equivalence · Uses: G001, S002
S004 · implies
Before
source roles = [Regex boundary LEFT.language, epsilon, {'type': 'epsilon'}, 5]After
derived = [[[]]]
Conditions: none
The empty language has no words;epsilon has the single empty word;a symbol has its one token within the queried length bound.Words are token arrays,not reinterpreted character splits.
Step identifiers and dependencies
Rule: Regex_atomic_language_EMPTY_versus_EPS_versus_literal_symbol · Uses: G001, S003
S005 · implies
Before
source roles = [Regex boundary RIGHT.ast.children[0], [b], {'type': 'epsilon'}]After
derived = [{'type': 'epsilon'}, {type:"epsilon"}]Conditions: none
For EACH node qualify type,exact keys and symbol membership.A union checks raw arity>=2 BEFORE extensional deduplication,so its canonical form may have one child.Concatenation retains order and star retains its child.Do not revalidate canonical output as raw input with a new arity gate.
Step identifiers and dependencies
Rule: Regex_EACH_typed_node_exact_keys_symbol_scope_union_set_concat_order · Uses: G001, S004
S006 · implies
Before
source roles = [Regex boundary RIGHT.ast.children[1].children[0], [b], {'type': 'symbol', 'value': 'b'}]After
derived = [{'type': 'symbol', 'value': 'b'}, {type:"symbol",value:"b"}]Conditions: none
For EACH node qualify type,exact keys and symbol membership.A union checks raw arity>=2 BEFORE extensional deduplication,so its canonical form may have one child.Concatenation retains order and star retains its child.Do not revalidate canonical output as raw input with a new arity gate.
Step identifiers and dependencies
Rule: Regex_EACH_typed_node_exact_keys_symbol_scope_union_set_concat_order · Uses: G001, S005
S007 · implies
Before
source roles = [Regex boundary RIGHT.ast.children[1].children[1], [b], {'type': 'symbol', 'value': 'b'}]After
derived = [{'type': 'symbol', 'value': 'b'}, {type:"symbol",value:"b"}]Conditions: none
For EACH node qualify type,exact keys and symbol membership.A union checks raw arity>=2 BEFORE extensional deduplication,so its canonical form may have one child.Concatenation retains order and star retains its child.Do not revalidate canonical output as raw input with a new arity gate.
Step identifiers and dependencies
Rule: Regex_EACH_typed_node_exact_keys_symbol_scope_union_set_concat_order · Uses: G001, S006
S008 · implies
Before
source roles = [Regex boundary RIGHT.ast.children[1].children[2], [b], {'type': 'symbol', 'value': 'b'}]After
derived = [{'type': 'symbol', 'value': 'b'}, {type:"symbol",value:"b"}]Conditions: none
For EACH node qualify type,exact keys and symbol membership.A union checks raw arity>=2 BEFORE extensional deduplication,so its canonical form may have one child.Concatenation retains order and star retains its child.Do not revalidate canonical output as raw input with a new arity gate.
Step identifiers and dependencies
Rule: Regex_EACH_typed_node_exact_keys_symbol_scope_union_set_concat_order · Uses: G001, S007
S009 · implies
Before
source roles = [Regex boundary RIGHT.ast.children[1].children[3], [b], {'type': 'symbol', 'value': 'b'}]After
derived = [{'type': 'symbol', 'value': 'b'}, {type:"symbol",value:"b"}]Conditions: none
For EACH node qualify type,exact keys and symbol membership.A union checks raw arity>=2 BEFORE extensional deduplication,so its canonical form may have one child.Concatenation retains order and star retains its child.Do not revalidate canonical output as raw input with a new arity gate.
Step identifiers and dependencies
Rule: Regex_EACH_typed_node_exact_keys_symbol_scope_union_set_concat_order · Uses: G001, S008
S010 · implies
Before
source roles = [Regex boundary RIGHT.ast.children[1].children[4], [b], {'type': 'symbol', 'value': 'b'}]After
derived = [{'type': 'symbol', 'value': 'b'}, {type:"symbol",value:"b"}]Conditions: none
For EACH node qualify type,exact keys and symbol membership.A union checks raw arity>=2 BEFORE extensional deduplication,so its canonical form may have one child.Concatenation retains order and star retains its child.Do not revalidate canonical output as raw input with a new arity gate.
Step identifiers and dependencies
Rule: Regex_EACH_typed_node_exact_keys_symbol_scope_union_set_concat_order · Uses: G001, S009
S011 · implies
Before
source roles = [Regex boundary RIGHT.ast.children[1].children[5], [b], {'type': 'symbol', 'value': 'b'}]After
derived = [{'type': 'symbol', 'value': 'b'}, {type:"symbol",value:"b"}]Conditions: none
For EACH node qualify type,exact keys and symbol membership.A union checks raw arity>=2 BEFORE extensional deduplication,so its canonical form may have one child.Concatenation retains order and star retains its child.Do not revalidate canonical output as raw input with a new arity gate.
Step identifiers and dependencies
Rule: Regex_EACH_typed_node_exact_keys_symbol_scope_union_set_concat_order · Uses: G001, S010
S012 · implies
Before
source roles = [Regex boundary RIGHT.ast.children[1], [b], {'type': 'concat', 'children': [{'type': 'symbol', 'value': 'b'}, {'type': 'symbol', 'value': 'b'}, {'type': 'symbol', 'value': 'b'}, {'type': 'symbol', 'value': 'b'}, {'type': 'symbol', 'value': 'b'}, {'type': 'symbol', 'value': 'b'}]}]After
derived = [{'type': 'concat', 'children': [{'type': 'symbol', 'value': 'b'}, {'type': 'symbol', 'value': 'b'}, {'type': 'symbol', 'value': 'b'}, {'type': 'symbol', 'value': 'b'}, {'type': 'symbol', 'value': 'b'}, {'type': 'symbol', 'value': 'b'}]}, {children:[{type:"symbol",value:"b"},{type:"symbol",value:"b"},{type:"symbol",value:"b"},{type:"symbol",value:"b"},{type:"symbol",value:"b"},{type:"symbol",value:"b"}],type:"concat"}]Conditions: none
For EACH node qualify type,exact keys and symbol membership.A union checks raw arity>=2 BEFORE extensional deduplication,so its canonical form may have one child.Concatenation retains order and star retains its child.Do not revalidate canonical output as raw input with a new arity gate.
Step identifiers and dependencies
Rule: Regex_EACH_typed_node_exact_keys_symbol_scope_union_set_concat_order · Uses: G001, S011
S013 · implies
Before
source roles = [Regex boundary RIGHT.ast, [b], {'type': 'union', 'children': [{'type': 'epsilon'}, {'type': 'concat', 'children': [{'type': 'symbol', 'value': 'b'}, {'type': 'symbol', 'value': 'b'}, {'type': 'symbol', 'value': 'b'}, {'type': 'symbol', 'value': 'b'}, {'type': 'symbol', 'value': 'b'}, {'type': 'symbol', 'value': 'b'}]}]}]After
derived = [{'type': 'union', 'children': [{'type': 'concat', 'children': [{'type': 'symbol', 'value': 'b'}, {'type': 'symbol', 'value': 'b'}, {'type': 'symbol', 'value': 'b'}, {'type': 'symbol', 'value': 'b'}, {'type': 'symbol', 'value': 'b'}, {'type': 'symbol', 'value': 'b'}]}, {'type': 'epsilon'}]}, {children:[{children:[{type:"symbol",value:"b"},{type:"symbol",value:"b"},{type:"symbol",value:"b"},{type:"symbol",value:"b"},{type:"symbol",value:"b"},{type:"symbol",value:"b"}],type:"concat"},{type:"epsilon"}],type:"union"}]Conditions: none
For EACH node qualify type,exact keys and symbol membership.A union checks raw arity>=2 BEFORE extensional deduplication,so its canonical form may have one child.Concatenation retains order and star retains its child.Do not revalidate canonical output as raw input with a new arity gate.
Step identifiers and dependencies
Rule: Regex_EACH_typed_node_exact_keys_symbol_scope_union_set_concat_order · Uses: G001, S012
S014 · implies
Before
source roles = [[b], 5]
After
derived = [6]
Conditions: none
The bounded universe has sum |alphabet|^k words,including epsilon,and source budget<=4096.This defines complete bounded enumeration,not unbounded equivalence.
Step identifiers and dependencies
Rule: Regex_COMPLETE_bounded_word_universe_not_unbounded_equivalence · Uses: G001, S013
S015 · implies
Before
source roles = [Regex boundary RIGHT.language.union[0].concat[0], symbol, {'type': 'symbol', 'value': 'b'}, 5]After
derived = [[[b]]]
Conditions: none
The empty language has no words;epsilon has the single empty word;a symbol has its one token within the queried length bound.Words are token arrays,not reinterpreted character splits.
Step identifiers and dependencies
Rule: Regex_atomic_language_EMPTY_versus_EPS_versus_literal_symbol · Uses: G001, S014
S016 · implies
Before
source roles = [Regex boundary RIGHT.language.union[0], 0, 5, [[]], [[b]]]
After
derived = [[[b]]]
Conditions: none
In ORIGINAL concatenation order take EVERY prefix/next-child word concatenation and discard only excessive length.If total length<=m,every factor length<=m,so truncation loses no allowed combination.
Step identifiers and dependencies
Rule: Regex_EACH_ordered_concatenation_complete_cartesian_word_products · Uses: G001, S015
S017 · implies
Before
source roles = [Regex boundary RIGHT.language.union[0].concat[1], symbol, {'type': 'symbol', 'value': 'b'}, 5]After
derived = [[[b]]]
Conditions: none
The empty language has no words;epsilon has the single empty word;a symbol has its one token within the queried length bound.Words are token arrays,not reinterpreted character splits.
Step identifiers and dependencies
Rule: Regex_atomic_language_EMPTY_versus_EPS_versus_literal_symbol · Uses: G001, S016
S018 · implies
Before
source roles = [Regex boundary RIGHT.language.union[0], 1, 5, [[b]], [[b]]]
After
derived = [[[b, b]]]
Conditions: none
In ORIGINAL concatenation order take EVERY prefix/next-child word concatenation and discard only excessive length.If total length<=m,every factor length<=m,so truncation loses no allowed combination.
Step identifiers and dependencies
Rule: Regex_EACH_ordered_concatenation_complete_cartesian_word_products · Uses: G001, S017
S019 · implies
Before
source roles = [Regex boundary RIGHT.language.union[0].concat[2], symbol, {'type': 'symbol', 'value': 'b'}, 5]After
derived = [[[b]]]
Conditions: none
The empty language has no words;epsilon has the single empty word;a symbol has its one token within the queried length bound.Words are token arrays,not reinterpreted character splits.
Step identifiers and dependencies
Rule: Regex_atomic_language_EMPTY_versus_EPS_versus_literal_symbol · Uses: G001, S018
S020 · implies
Before
source roles = [Regex boundary RIGHT.language.union[0], 2, 5, [[b, b]], [[b]]]
After
derived = [[[b, b, b]]]
Conditions: none
In ORIGINAL concatenation order take EVERY prefix/next-child word concatenation and discard only excessive length.If total length<=m,every factor length<=m,so truncation loses no allowed combination.
Step identifiers and dependencies
Rule: Regex_EACH_ordered_concatenation_complete_cartesian_word_products · Uses: G001, S019
S021 · implies
Before
source roles = [Regex boundary RIGHT.language.union[0].concat[3], symbol, {'type': 'symbol', 'value': 'b'}, 5]After
derived = [[[b]]]
Conditions: none
The empty language has no words;epsilon has the single empty word;a symbol has its one token within the queried length bound.Words are token arrays,not reinterpreted character splits.
Step identifiers and dependencies
Rule: Regex_atomic_language_EMPTY_versus_EPS_versus_literal_symbol · Uses: G001, S020
S022 · implies
Before
source roles = [Regex boundary RIGHT.language.union[0], 3, 5, [[b, b, b]], [[b]]]
After
derived = [[[b, b, b, b]]]
Conditions: none
In ORIGINAL concatenation order take EVERY prefix/next-child word concatenation and discard only excessive length.If total length<=m,every factor length<=m,so truncation loses no allowed combination.
Step identifiers and dependencies
Rule: Regex_EACH_ordered_concatenation_complete_cartesian_word_products · Uses: G001, S021
S023 · implies
Before
source roles = [Regex boundary RIGHT.language.union[0].concat[4], symbol, {'type': 'symbol', 'value': 'b'}, 5]After
derived = [[[b]]]
Conditions: none
The empty language has no words;epsilon has the single empty word;a symbol has its one token within the queried length bound.Words are token arrays,not reinterpreted character splits.
Step identifiers and dependencies
Rule: Regex_atomic_language_EMPTY_versus_EPS_versus_literal_symbol · Uses: G001, S022
S024 · implies
Before
source roles = [Regex boundary RIGHT.language.union[0], 4, 5, [[b, b, b, b]], [[b]]]
After
derived = [[[b, b, b, b, b]]]
Conditions: none
In ORIGINAL concatenation order take EVERY prefix/next-child word concatenation and discard only excessive length.If total length<=m,every factor length<=m,so truncation loses no allowed combination.
Step identifiers and dependencies
Rule: Regex_EACH_ordered_concatenation_complete_cartesian_word_products · Uses: G001, S023
S025 · implies
Before
source roles = [Regex boundary RIGHT.language.union[0].concat[5], symbol, {'type': 'symbol', 'value': 'b'}, 5]After
derived = [[[b]]]
Conditions: none
The empty language has no words;epsilon has the single empty word;a symbol has its one token within the queried length bound.Words are token arrays,not reinterpreted character splits.
Step identifiers and dependencies
Rule: Regex_atomic_language_EMPTY_versus_EPS_versus_literal_symbol · Uses: G001, S024
S026 · implies
Before
source roles = [Regex boundary RIGHT.language.union[0], 5, 5, [[b, b, b, b, b]], [[b]]]
After
derived = [[]]
Conditions: none
In ORIGINAL concatenation order take EVERY prefix/next-child word concatenation and discard only excessive length.If total length<=m,every factor length<=m,so truncation loses no allowed combination.
Step identifiers and dependencies
Rule: Regex_EACH_ordered_concatenation_complete_cartesian_word_products · Uses: G001, S025
S027 · implies
Before
source roles = [Regex boundary RIGHT.language.union[1], epsilon, {'type': 'epsilon'}, 5]After
derived = [[[]]]
Conditions: none
The empty language has no words;epsilon has the single empty word;a symbol has its one token within the queried length bound.Words are token arrays,not reinterpreted character splits.
Step identifiers and dependencies
Rule: Regex_atomic_language_EMPTY_versus_EPS_versus_literal_symbol · Uses: G001, S026
S028 · implies
Before
source roles = [Regex boundary RIGHT.language, 5, [[], [[]]]]
After
derived = [[[]]]
Conditions: none
Union includes ALL child languages,retaining each word once without reordering its symbols.Structural induction accounts for inclusion/exclusion of every word within the bound.
Step identifiers and dependencies
Rule: Regex_union_ALL_child_languages_extensional_bound · Uses: G001, S027
S029 · implies
Before
source roles = [Regex boundary LEFT next.ast, [b], {'type': 'epsilon'}]After
derived = [{'type': 'epsilon'}, {type:"epsilon"}]Conditions: none
For EACH node qualify type,exact keys and symbol membership.A union checks raw arity>=2 BEFORE extensional deduplication,so its canonical form may have one child.Concatenation retains order and star retains its child.Do not revalidate canonical output as raw input with a new arity gate.
Step identifiers and dependencies
Rule: Regex_EACH_typed_node_exact_keys_symbol_scope_union_set_concat_order · Uses: G001, S028
S030 · implies
Before
source roles = [[b], 6]
After
derived = [7]
Conditions: none
The bounded universe has sum |alphabet|^k words,including epsilon,and source budget<=4096.This defines complete bounded enumeration,not unbounded equivalence.
Step identifiers and dependencies
Rule: Regex_COMPLETE_bounded_word_universe_not_unbounded_equivalence · Uses: G001, S029
S031 · implies
Before
source roles = [Regex boundary LEFT next.language, epsilon, {'type': 'epsilon'}, 6]After
derived = [[[]]]
Conditions: none
The empty language has no words;epsilon has the single empty word;a symbol has its one token within the queried length bound.Words are token arrays,not reinterpreted character splits.
Step identifiers and dependencies
Rule: Regex_atomic_language_EMPTY_versus_EPS_versus_literal_symbol · Uses: G001, S030
S032 · implies
Before
source roles = [Regex boundary RIGHT next.ast.children[0], [b], {'type': 'epsilon'}]After
derived = [{'type': 'epsilon'}, {type:"epsilon"}]Conditions: none
For EACH node qualify type,exact keys and symbol membership.A union checks raw arity>=2 BEFORE extensional deduplication,so its canonical form may have one child.Concatenation retains order and star retains its child.Do not revalidate canonical output as raw input with a new arity gate.
Step identifiers and dependencies
Rule: Regex_EACH_typed_node_exact_keys_symbol_scope_union_set_concat_order · Uses: G001, S031
S033 · implies
Before
source roles = [Regex boundary RIGHT next.ast.children[1].children[0], [b], {'type': 'symbol', 'value': 'b'}]After
derived = [{'type': 'symbol', 'value': 'b'}, {type:"symbol",value:"b"}]Conditions: none
For EACH node qualify type,exact keys and symbol membership.A union checks raw arity>=2 BEFORE extensional deduplication,so its canonical form may have one child.Concatenation retains order and star retains its child.Do not revalidate canonical output as raw input with a new arity gate.
Step identifiers and dependencies
Rule: Regex_EACH_typed_node_exact_keys_symbol_scope_union_set_concat_order · Uses: G001, S032
S034 · implies
Before
source roles = [Regex boundary RIGHT next.ast.children[1].children[1], [b], {'type': 'symbol', 'value': 'b'}]After
derived = [{'type': 'symbol', 'value': 'b'}, {type:"symbol",value:"b"}]Conditions: none
For EACH node qualify type,exact keys and symbol membership.A union checks raw arity>=2 BEFORE extensional deduplication,so its canonical form may have one child.Concatenation retains order and star retains its child.Do not revalidate canonical output as raw input with a new arity gate.
Step identifiers and dependencies
Rule: Regex_EACH_typed_node_exact_keys_symbol_scope_union_set_concat_order · Uses: G001, S033
S035 · implies
Before
source roles = [Regex boundary RIGHT next.ast.children[1].children[2], [b], {'type': 'symbol', 'value': 'b'}]After
derived = [{'type': 'symbol', 'value': 'b'}, {type:"symbol",value:"b"}]Conditions: none
For EACH node qualify type,exact keys and symbol membership.A union checks raw arity>=2 BEFORE extensional deduplication,so its canonical form may have one child.Concatenation retains order and star retains its child.Do not revalidate canonical output as raw input with a new arity gate.
Step identifiers and dependencies
Rule: Regex_EACH_typed_node_exact_keys_symbol_scope_union_set_concat_order · Uses: G001, S034
S036 · implies
Before
source roles = [Regex boundary RIGHT next.ast.children[1].children[3], [b], {'type': 'symbol', 'value': 'b'}]After
derived = [{'type': 'symbol', 'value': 'b'}, {type:"symbol",value:"b"}]Conditions: none
For EACH node qualify type,exact keys and symbol membership.A union checks raw arity>=2 BEFORE extensional deduplication,so its canonical form may have one child.Concatenation retains order and star retains its child.Do not revalidate canonical output as raw input with a new arity gate.
Step identifiers and dependencies
Rule: Regex_EACH_typed_node_exact_keys_symbol_scope_union_set_concat_order · Uses: G001, S035
S037 · implies
Before
source roles = [Regex boundary RIGHT next.ast.children[1].children[4], [b], {'type': 'symbol', 'value': 'b'}]After
derived = [{'type': 'symbol', 'value': 'b'}, {type:"symbol",value:"b"}]Conditions: none
For EACH node qualify type,exact keys and symbol membership.A union checks raw arity>=2 BEFORE extensional deduplication,so its canonical form may have one child.Concatenation retains order and star retains its child.Do not revalidate canonical output as raw input with a new arity gate.
Step identifiers and dependencies
Rule: Regex_EACH_typed_node_exact_keys_symbol_scope_union_set_concat_order · Uses: G001, S036
S038 · implies
Before
source roles = [Regex boundary RIGHT next.ast.children[1].children[5], [b], {'type': 'symbol', 'value': 'b'}]After
derived = [{'type': 'symbol', 'value': 'b'}, {type:"symbol",value:"b"}]Conditions: none
For EACH node qualify type,exact keys and symbol membership.A union checks raw arity>=2 BEFORE extensional deduplication,so its canonical form may have one child.Concatenation retains order and star retains its child.Do not revalidate canonical output as raw input with a new arity gate.
Step identifiers and dependencies
Rule: Regex_EACH_typed_node_exact_keys_symbol_scope_union_set_concat_order · Uses: G001, S037
S039 · implies
Before
source roles = [Regex boundary RIGHT next.ast.children[1], [b], {'type': 'concat', 'children': [{'type': 'symbol', 'value': 'b'}, {'type': 'symbol', 'value': 'b'}, {'type': 'symbol', 'value': 'b'}, {'type': 'symbol', 'value': 'b'}, {'type': 'symbol', 'value': 'b'}, {'type': 'symbol', 'value': 'b'}]}]After
derived = [{'type': 'concat', 'children': [{'type': 'symbol', 'value': 'b'}, {'type': 'symbol', 'value': 'b'}, {'type': 'symbol', 'value': 'b'}, {'type': 'symbol', 'value': 'b'}, {'type': 'symbol', 'value': 'b'}, {'type': 'symbol', 'value': 'b'}]}, {children:[{type:"symbol",value:"b"},{type:"symbol",value:"b"},{type:"symbol",value:"b"},{type:"symbol",value:"b"},{type:"symbol",value:"b"},{type:"symbol",value:"b"}],type:"concat"}]Conditions: none
For EACH node qualify type,exact keys and symbol membership.A union checks raw arity>=2 BEFORE extensional deduplication,so its canonical form may have one child.Concatenation retains order and star retains its child.Do not revalidate canonical output as raw input with a new arity gate.
Step identifiers and dependencies
Rule: Regex_EACH_typed_node_exact_keys_symbol_scope_union_set_concat_order · Uses: G001, S038
S040 · implies
Before
source roles = [Regex boundary RIGHT next.ast, [b], {'type': 'union', 'children': [{'type': 'epsilon'}, {'type': 'concat', 'children': [{'type': 'symbol', 'value': 'b'}, {'type': 'symbol', 'value': 'b'}, {'type': 'symbol', 'value': 'b'}, {'type': 'symbol', 'value': 'b'}, {'type': 'symbol', 'value': 'b'}, {'type': 'symbol', 'value': 'b'}]}]}]After
derived = [{'type': 'union', 'children': [{'type': 'concat', 'children': [{'type': 'symbol', 'value': 'b'}, {'type': 'symbol', 'value': 'b'}, {'type': 'symbol', 'value': 'b'}, {'type': 'symbol', 'value': 'b'}, {'type': 'symbol', 'value': 'b'}, {'type': 'symbol', 'value': 'b'}]}, {'type': 'epsilon'}]}, {children:[{children:[{type:"symbol",value:"b"},{type:"symbol",value:"b"},{type:"symbol",value:"b"},{type:"symbol",value:"b"},{type:"symbol",value:"b"},{type:"symbol",value:"b"}],type:"concat"},{type:"epsilon"}],type:"union"}]Conditions: none
For EACH node qualify type,exact keys and symbol membership.A union checks raw arity>=2 BEFORE extensional deduplication,so its canonical form may have one child.Concatenation retains order and star retains its child.Do not revalidate canonical output as raw input with a new arity gate.
Step identifiers and dependencies
Rule: Regex_EACH_typed_node_exact_keys_symbol_scope_union_set_concat_order · Uses: G001, S039
S041 · implies
Before
source roles = [[b], 6]
After
derived = [7]
Conditions: none
The bounded universe has sum |alphabet|^k words,including epsilon,and source budget<=4096.This defines complete bounded enumeration,not unbounded equivalence.
Step identifiers and dependencies
Rule: Regex_COMPLETE_bounded_word_universe_not_unbounded_equivalence · Uses: G001, S040
S042 · implies
Before
source roles = [Regex boundary RIGHT next.language.union[0].concat[0], symbol, {'type': 'symbol', 'value': 'b'}, 6]After
derived = [[[b]]]
Conditions: none
The empty language has no words;epsilon has the single empty word;a symbol has its one token within the queried length bound.Words are token arrays,not reinterpreted character splits.
Step identifiers and dependencies
Rule: Regex_atomic_language_EMPTY_versus_EPS_versus_literal_symbol · Uses: G001, S041
S043 · implies
Before
source roles = [Regex boundary RIGHT next.language.union[0], 0, 6, [[]], [[b]]]
After
derived = [[[b]]]
Conditions: none
In ORIGINAL concatenation order take EVERY prefix/next-child word concatenation and discard only excessive length.If total length<=m,every factor length<=m,so truncation loses no allowed combination.
Step identifiers and dependencies
Rule: Regex_EACH_ordered_concatenation_complete_cartesian_word_products · Uses: G001, S042
S044 · implies
Before
source roles = [Regex boundary RIGHT next.language.union[0].concat[1], symbol, {'type': 'symbol', 'value': 'b'}, 6]After
derived = [[[b]]]
Conditions: none
The empty language has no words;epsilon has the single empty word;a symbol has its one token within the queried length bound.Words are token arrays,not reinterpreted character splits.
Step identifiers and dependencies
Rule: Regex_atomic_language_EMPTY_versus_EPS_versus_literal_symbol · Uses: G001, S043
S045 · implies
Before
source roles = [Regex boundary RIGHT next.language.union[0], 1, 6, [[b]], [[b]]]
After
derived = [[[b, b]]]
Conditions: none
In ORIGINAL concatenation order take EVERY prefix/next-child word concatenation and discard only excessive length.If total length<=m,every factor length<=m,so truncation loses no allowed combination.
Step identifiers and dependencies
Rule: Regex_EACH_ordered_concatenation_complete_cartesian_word_products · Uses: G001, S044
S046 · implies
Before
source roles = [Regex boundary RIGHT next.language.union[0].concat[2], symbol, {'type': 'symbol', 'value': 'b'}, 6]After
derived = [[[b]]]
Conditions: none
The empty language has no words;epsilon has the single empty word;a symbol has its one token within the queried length bound.Words are token arrays,not reinterpreted character splits.
Step identifiers and dependencies
Rule: Regex_atomic_language_EMPTY_versus_EPS_versus_literal_symbol · Uses: G001, S045
S047 · implies
Before
source roles = [Regex boundary RIGHT next.language.union[0], 2, 6, [[b, b]], [[b]]]
After
derived = [[[b, b, b]]]
Conditions: none
In ORIGINAL concatenation order take EVERY prefix/next-child word concatenation and discard only excessive length.If total length<=m,every factor length<=m,so truncation loses no allowed combination.
Step identifiers and dependencies
Rule: Regex_EACH_ordered_concatenation_complete_cartesian_word_products · Uses: G001, S046
S048 · implies
Before
source roles = [Regex boundary RIGHT next.language.union[0].concat[3], symbol, {'type': 'symbol', 'value': 'b'}, 6]After
derived = [[[b]]]
Conditions: none
The empty language has no words;epsilon has the single empty word;a symbol has its one token within the queried length bound.Words are token arrays,not reinterpreted character splits.
Step identifiers and dependencies
Rule: Regex_atomic_language_EMPTY_versus_EPS_versus_literal_symbol · Uses: G001, S047
S049 · implies
Before
source roles = [Regex boundary RIGHT next.language.union[0], 3, 6, [[b, b, b]], [[b]]]
After
derived = [[[b, b, b, b]]]
Conditions: none
In ORIGINAL concatenation order take EVERY prefix/next-child word concatenation and discard only excessive length.If total length<=m,every factor length<=m,so truncation loses no allowed combination.
Step identifiers and dependencies
Rule: Regex_EACH_ordered_concatenation_complete_cartesian_word_products · Uses: G001, S048
S050 · implies
Before
source roles = [Regex boundary RIGHT next.language.union[0].concat[4], symbol, {'type': 'symbol', 'value': 'b'}, 6]After
derived = [[[b]]]
Conditions: none
The empty language has no words;epsilon has the single empty word;a symbol has its one token within the queried length bound.Words are token arrays,not reinterpreted character splits.
Step identifiers and dependencies
Rule: Regex_atomic_language_EMPTY_versus_EPS_versus_literal_symbol · Uses: G001, S049
S051 · implies
Before
source roles = [Regex boundary RIGHT next.language.union[0], 4, 6, [[b, b, b, b]], [[b]]]
After
derived = [[[b, b, b, b, b]]]
Conditions: none
In ORIGINAL concatenation order take EVERY prefix/next-child word concatenation and discard only excessive length.If total length<=m,every factor length<=m,so truncation loses no allowed combination.
Step identifiers and dependencies
Rule: Regex_EACH_ordered_concatenation_complete_cartesian_word_products · Uses: G001, S050
S052 · implies
Before
source roles = [Regex boundary RIGHT next.language.union[0].concat[5], symbol, {'type': 'symbol', 'value': 'b'}, 6]After
derived = [[[b]]]
Conditions: none
The empty language has no words;epsilon has the single empty word;a symbol has its one token within the queried length bound.Words are token arrays,not reinterpreted character splits.
Step identifiers and dependencies
Rule: Regex_atomic_language_EMPTY_versus_EPS_versus_literal_symbol · Uses: G001, S051
S053 · implies
Before
source roles = [Regex boundary RIGHT next.language.union[0], 5, 6, [[b, b, b, b, b]], [[b]]]
After
derived = [[[b, b, b, b, b, b]]]
Conditions: none
In ORIGINAL concatenation order take EVERY prefix/next-child word concatenation and discard only excessive length.If total length<=m,every factor length<=m,so truncation loses no allowed combination.
Step identifiers and dependencies
Rule: Regex_EACH_ordered_concatenation_complete_cartesian_word_products · Uses: G001, S052
S054 · implies
Before
source roles = [Regex boundary RIGHT next.language.union[1], epsilon, {'type': 'epsilon'}, 6]After
derived = [[[]]]
Conditions: none
The empty language has no words;epsilon has the single empty word;a symbol has its one token within the queried length bound.Words are token arrays,not reinterpreted character splits.
Step identifiers and dependencies
Rule: Regex_atomic_language_EMPTY_versus_EPS_versus_literal_symbol · Uses: G001, S053
S055 · implies
Before
source roles = [Regex boundary RIGHT next.language, 6, [[[b, b, b, b, b, b]], [[]]]]
After
derived = [[[b, b, b, b, b, b], []]]
Conditions: none
Union includes ALL child languages,retaining each word once without reordering its symbols.Structural induction accounts for inclusion/exclusion of every word within the bound.
Step identifiers and dependencies
Rule: Regex_union_ALL_child_languages_extensional_bound · Uses: G001, S054
S056 · implies
Before
source roles = [5, [[]], [[]], 6]
After
derived = [[[]], [[], [b, b, b, b, b, b]], Yes, Yes, No]
Conditions: none
First verify complete equality through the bound,then an ACTUAL difference at the next bound.This concrete distinction refutes unbounded equivalence,not nonmembership inferred from an insufficient short enumeration.
Step identifiers and dependencies
Rule: Regex_ACTUAL_equal_through_bound_AND_next_length_distinction · Uses: G001, S055