JT004C

jordan_enumeration_position_match_from_entries

Actual outer beta functionality transports chosen tuple equality to every decoding at the same two positions.

Alpha v35 checked-use · first admitted v35 · independently kernel and Lean verified; not Stable

95 new Alpha admissions come from 96 source lemmas: tuple equality reflexivity reuses an already-admitted theorem and is not counted twice. All counts use actual finite beta-coded enumerations. G008 multiplicativity is proved; the general prime-power count and distinct-prime product formula are further goals. General prime-power fields (G091) remain open. Stable is unchanged.

Exact theorem in conservative defined notation

∀ k. ∀ A. ∀ B. ∀ C. ∀ D. ∀ E. ∀ F. ∀ G. ∀ H. ∀ i. ∀ j. ∀ b. ∀ c. ∀ d. ∀ e. BetaAt(A,B,i,b) ∧ BetaAt(C,D,i,c) → BetaAt(E,F,j,d) ∧ BetaAt(G,H,j,e) → IntegerVectorZero(b,c,d,e,k) → ∀ x. ∀ y. ∀ z. ∀ n. BetaAt(A,B,i,x) ∧ BetaAt(C,D,i,y) → BetaAt(E,F,j,z) ∧ BetaAt(G,H,j,n) → IntegerVectorZero(x,y,z,n,k)

Every linked abbreviation expands hygienically to the identical original native formula.

Definition DAG

Actual proof prerequisites

Original expanded first-order statement
forall k A B C D E F G H i j b c d e. (((((exists fs_h_jt_position_leftcode. fs_h_jt_position_leftcode + S (b) = S ((S (i)) * B)) /\ exists fs_q_jt_position_leftcode. A = fs_q_jt_position_leftcode * S ((S (i)) * B) + (b))) /\ (((exists fs_h_jt_position_leftscale. fs_h_jt_position_leftscale + S (c) = S ((S (i)) * D)) /\ exists fs_q_jt_position_leftscale. C = fs_q_jt_position_leftscale * S ((S (i)) * D) + (c))))) -> (((((exists fs_h_jt_position_rightcode. fs_h_jt_position_rightcode + S (d) = S ((S (j)) * F)) /\ exists fs_q_jt_position_rightcode. E = fs_q_jt_position_rightcode * S ((S (j)) * F) + (d))) /\ (((exists fs_h_jt_position_rightscale. fs_h_jt_position_rightscale + S (e) = S ((S (j)) * H)) /\ exists fs_q_jt_position_rightscale. G = fs_q_jt_position_rightscale * S ((S (j)) * H) + (e))))) -> (forall jt_index_position_equal jt_left_position_equal jt_right_position_equal. (exists jt_gap_position_equalindex. jt_gap_position_equalindex+S (jt_index_position_equal)=(k)) -> (((exists fs_h_jt_position_equalleft. fs_h_jt_position_equalleft + S (jt_left_position_equal) = S ((S (jt_index_position_equal)) * c)) /\ exists fs_q_jt_position_equalleft. b = fs_q_jt_position_equalleft * S ((S (jt_index_position_equal)) * c) + (jt_left_position_equal))) -> (((exists fs_h_jt_position_equalright. fs_h_jt_position_equalright + S (jt_right_position_equal) = S ((S (jt_index_position_equal)) * e)) /\ exists fs_q_jt_position_equalright. d = fs_q_jt_position_equalright * S ((S (jt_index_position_equal)) * e) + (jt_right_position_equal))) -> jt_left_position_equal=jt_right_position_equal) -> (forall jt_b_position_result jt_c_position_result jt_d_position_result jt_e_position_result. (((((exists fs_h_jt_position_resultleftcode. fs_h_jt_position_resultleftcode + S (jt_b_position_result) = S ((S (i)) * B)) /\ exists fs_q_jt_position_resultleftcode. A = fs_q_jt_position_resultleftcode * S ((S (i)) * B) + (jt_b_position_result))) /\ (((exists fs_h_jt_position_resultleftscale. fs_h_jt_position_resultleftscale + S (jt_c_position_result) = S ((S (i)) * D)) /\ exists fs_q_jt_position_resultleftscale. C = fs_q_jt_position_resultleftscale * S ((S (i)) * D) + (jt_c_position_result))))) -> (((((exists fs_h_jt_position_resultrightcode. fs_h_jt_position_resultrightcode + S (jt_d_position_result) = S ((S (j)) * F)) /\ exists fs_q_jt_position_resultrightcode. E = fs_q_jt_position_resultrightcode * S ((S (j)) * F) + (jt_d_position_result))) /\ (((exists fs_h_jt_position_resultrightscale. fs_h_jt_position_resultrightscale + S (jt_e_position_result) = S ((S (j)) * H)) /\ exists fs_q_jt_position_resultrightscale. G = fs_q_jt_position_resultrightscale * S ((S (j)) * H) + (jt_e_position_result))))) -> (forall jt_index_position_resultequal jt_left_position_resultequal jt_right_position_resultequal. (exists jt_gap_position_resultequalindex. jt_gap_position_resultequalindex+S (jt_index_position_resultequal)=(k)) -> (((exists fs_h_jt_position_resultequalleft. fs_h_jt_position_resultequalleft + S (jt_left_position_resultequal) = S ((S (jt_index_position_resultequal)) * jt_c_position_result)) /\ exists fs_q_jt_position_resultequalleft. jt_b_position_result = fs_q_jt_position_resultequalleft * S ((S (jt_index_position_resultequal)) * jt_c_position_result) + (jt_left_position_resultequal))) -> (((exists fs_h_jt_position_resultequalright. fs_h_jt_position_resultequalright + S (jt_right_position_resultequal) = S ((S (jt_index_position_resultequal)) * jt_e_position_result)) /\ exists fs_q_jt_position_resultequalright. jt_d_position_result = fs_q_jt_position_resultequalright * S ((S (jt_index_position_resultequal)) * jt_e_position_result) + (jt_right_position_resultequal))) -> jt_left_position_resultequal=jt_right_position_resultequal))

Complete tactic proof in conservative notation

All 71 original proof lines are preserved. Only local proposition formulas are abbreviated; every abbreviation has an exact binder-safe expansion check. The linked exact edition contains the unchanged replay script.

Read the argument

Proof checkpoints

71 script commands · 10 reading checkpoints · 4 local claims

This is a reading aid, not a new proof or a proof-tree certificate. Checkpoint groups are consecutive commands, not inferred branch boundaries. Every step links to the preserved script.

Definition notation is shown below. Open the paired exact edition for the original native formulas. Source pairing is not a new equivalence certificate.

01Fix variables and assumptionsL1–10

Work with arbitrary variables or the premises of the current implication.

  1. L1
    intro k
  2. L2
    intro A
  3. L3
    intro B
  4. L4
    intro C
  5. L5
    intro D
  6. L6
    intro E
  7. L7
    intro F
  8. L8
    intro G
  9. L9
    intro H
  10. L10
    intro i
02Fix variables and assumptionsL11–20

Work with arbitrary variables or the premises of the current implication.

  1. L11
    intro j
  2. L12
    intro b
  3. L13
    intro c
  4. L14
    intro d
  5. L15
    intro e
  6. L16
    intro hl
  7. L17
    intro hr
  8. L18
    intro he
  9. L19
    intro a0
  10. L20
    intro a1
03Fix variables and assumptionsL21–24

Work with arbitrary variables or the premises of the current implication.

  1. L21
    intro a2
  2. L22
    intro a3
  3. L23
    intro hnewl
  4. L24
    intro hnewr
04Separate the logical casesL25–28

Follow the explicit conjunction, disjunction, witness, or contradiction step recorded below.

  1. L25
    cases hl
  2. L26
    cases hr
  3. L27
    cases hnewl
  4. L28
    cases hnewr
05Establish heq_bL29–37

Establish this local claim before using it. It is not an additional assumption. The following proof commands apply beta at unique.

  1. L29
    have heq_b : b=a0
  2. L30
    specialize beta_at_unique (A)
  3. L31
    specialize beta_at_unique (B)
  4. L32
    specialize beta_at_unique (i)
  5. L33
    specialize beta_at_unique (b)
  6. L34
    specialize beta_at_unique (a0)
  7. L35
    apply beta_at_unique
  8. L36
    exact hl_left
  9. L37
    exact hnewl_left
06Establish heq_cL38–46

Establish this local claim before using it. It is not an additional assumption. The following proof commands apply beta at unique.

  1. L38
    have heq_c : c=a1
  2. L39
    specialize beta_at_unique (C)
  3. L40
    specialize beta_at_unique (D)
  4. L41
    specialize beta_at_unique (i)
  5. L42
    specialize beta_at_unique (c)
  6. L43
    specialize beta_at_unique (a1)
  7. L44
    apply beta_at_unique
  8. L45
    exact hl_right
  9. L46
    exact hnewl_right
07Establish heq_dL47–55

Establish this local claim before using it. It is not an additional assumption. The following proof commands apply beta at unique.

  1. L47
    have heq_d : d=a2
  2. L48
    specialize beta_at_unique (E)
  3. L49
    specialize beta_at_unique (F)
  4. L50
    specialize beta_at_unique (j)
  5. L51
    specialize beta_at_unique (d)
  6. L52
    specialize beta_at_unique (a2)
  7. L53
    apply beta_at_unique
  8. L54
    exact hr_left
  9. L55
    exact hnewr_left
08Establish heq_eL56–65

Establish this local claim before using it. It is not an additional assumption. The following proof commands apply beta at unique.

  1. L56
    have heq_e : e=a3
  2. L57
    specialize beta_at_unique (G)
  3. L58
    specialize beta_at_unique (H)
  4. L59
    specialize beta_at_unique (j)
  5. L60
    specialize beta_at_unique (e)
  6. L61
    specialize beta_at_unique (a3)
  7. L62
    apply beta_at_unique
  8. L63
    exact hr_right
  9. L64
    exact hnewr_right
  10. L65
    rewrite heq_b at he
09Calculate and transport equalitiesL66–70

Carry out the recorded arithmetic or equality steps; inspect the exact commands for their direction and premises.

  1. L66
    rewrite heq_c at he
  2. L67
    rewrite heq_c at he
  3. L68
    rewrite heq_d at he
  4. L69
    rewrite heq_e at he
  5. L70
    rewrite heq_e at he
10Use earlier factsL71–71

Instantiate or apply named facts and discharge the corresponding proof obligations.

  1. L71
    exact he

Library-wide reading audit

Original defined command ledger · 71 lines
  1. 0001intro k
  2. 0002intro A
  3. 0003intro B
  4. 0004intro C
  5. 0005intro D
  6. 0006intro E
  7. 0007intro F
  8. 0008intro G
  9. 0009intro H
  10. 0010intro i
  11. 0011intro j
  12. 0012intro b
  13. 0013intro c
  14. 0014intro d
  15. 0015intro e
  16. 0016intro hl
  17. 0017intro hr
  18. 0018intro he
  19. 0019intro a0
  20. 0020intro a1
  21. 0021intro a2
  22. 0022intro a3
  23. 0023intro hnewl
  24. 0024intro hnewr
  25. 0025cases hl
  26. 0026cases hr
  27. 0027cases hnewl
  28. 0028cases hnewr
  29. 0029have heq_b : b=a0
  30. 0030specialize beta_at_unique (A)
  31. 0031specialize beta_at_unique (B)
  32. 0032specialize beta_at_unique (i)
  33. 0033specialize beta_at_unique (b)
  34. 0034specialize beta_at_unique (a0)
  35. 0035apply beta_at_unique
  36. 0036exact hl_left
  37. 0037exact hnewl_left
  38. 0038have heq_c : c=a1
  39. 0039specialize beta_at_unique (C)
  40. 0040specialize beta_at_unique (D)
  41. 0041specialize beta_at_unique (i)
  42. 0042specialize beta_at_unique (c)
  43. 0043specialize beta_at_unique (a1)
  44. 0044apply beta_at_unique
  45. 0045exact hl_right
  46. 0046exact hnewl_right
  47. 0047have heq_d : d=a2
  48. 0048specialize beta_at_unique (E)
  49. 0049specialize beta_at_unique (F)
  50. 0050specialize beta_at_unique (j)
  51. 0051specialize beta_at_unique (d)
  52. 0052specialize beta_at_unique (a2)
  53. 0053apply beta_at_unique
  54. 0054exact hr_left
  55. 0055exact hnewr_left
  56. 0056have heq_e : e=a3
  57. 0057specialize beta_at_unique (G)
  58. 0058specialize beta_at_unique (H)
  59. 0059specialize beta_at_unique (j)
  60. 0060specialize beta_at_unique (e)
  61. 0061specialize beta_at_unique (a3)
  62. 0062apply beta_at_unique
  63. 0063exact hr_right
  64. 0064exact hnewr_right
  65. 0065rewrite heq_b at he
  66. 0066rewrite heq_c at he
  67. 0067rewrite heq_c at he
  68. 0068rewrite heq_d at he
  69. 0069rewrite heq_e at he
  70. 0070rewrite heq_e at he
  71. 0071exact he