JT0026

jordan_tuple_scan_append

Alpha v35 independently verified · alpha_closed; checked-use authorized; not Stable

Append an actually absent primitive tuple and prove full soundness, distinctness and prefix coverage.

Exact expanded first-order arithmetic statement

forall k n c t B C D E j. (((forall jt_i_appendinvariant. (exists jt_gap_appendinvariantsoundindex. jt_gap_appendinvariantsoundindex+S (jt_i_appendinvariant)=(j)) -> exists jt_b_appendinvariant jt_e_appendinvariant. ((((((exists fs_h_jt_appendinvariantsoundcode. fs_h_jt_appendinvariantsoundcode + S (jt_b_appendinvariant) = S ((S (jt_i_appendinvariant)) * C)) /\ exists fs_q_jt_appendinvariantsoundcode. B = fs_q_jt_appendinvariantsoundcode * S ((S (jt_i_appendinvariant)) * C) + (jt_b_appendinvariant))) /\ (((exists fs_h_jt_appendinvariantsoundscale. fs_h_jt_appendinvariantsoundscale + S (jt_e_appendinvariant) = S ((S (jt_i_appendinvariant)) * E)) /\ exists fs_q_jt_appendinvariantsoundscale. D = fs_q_jt_appendinvariantsoundscale * S ((S (jt_i_appendinvariant)) * E) + (jt_e_appendinvariant))))) /\ (((forall jt_index_appendinvariantbound. (exists jt_gap_appendinvariantboundindex. jt_gap_appendinvariantboundindex+S (jt_index_appendinvariantbound)=(k)) -> exists jt_value_appendinvariantbound. ((((exists fs_h_jt_appendinvariantboundat. fs_h_jt_appendinvariantboundat + S (jt_value_appendinvariantbound) = S ((S (jt_index_appendinvariantbound)) * jt_e_appendinvariant)) /\ exists fs_q_jt_appendinvariantboundat. jt_b_appendinvariant = fs_q_jt_appendinvariantboundat * S ((S (jt_index_appendinvariantbound)) * jt_e_appendinvariant) + (jt_value_appendinvariantbound))) /\ (exists jt_gap_appendinvariantboundvalue. jt_gap_appendinvariantboundvalue+S (jt_value_appendinvariantbound)=(n)))) /\ (forall jt_divisor_appendinvariantprimitive. (exists jt_factor_appendinvariantprimitivemodulus. (n)=(jt_divisor_appendinvariantprimitive)*jt_factor_appendinvariantprimitivemodulus) -> (forall jt_index_appendinvariantprimitivecoordinates jt_value_appendinvariantprimitivecoordinates. (exists jt_gap_appendinvariantprimitivecoordinatesindex. jt_gap_appendinvariantprimitivecoordinatesindex+S (jt_index_appendinvariantprimitivecoordinates)=(k)) -> (((exists fs_h_jt_appendinvariantprimitivecoordinatesat. fs_h_jt_appendinvariantprimitivecoordinatesat + S (jt_value_appendinvariantprimitivecoordinates) = S ((S (jt_index_appendinvariantprimitivecoordinates)) * jt_e_appendinvariant)) /\ exists fs_q_jt_appendinvariantprimitivecoordinatesat. jt_b_appendinvariant = fs_q_jt_appendinvariantprimitivecoordinatesat * S ((S (jt_index_appendinvariantprimitivecoordinates)) * jt_e_appendinvariant) + (jt_value_appendinvariantprimitivecoordinates))) -> (exists jt_factor_appendinvariantprimitivecoordinatesdivides. (jt_value_appendinvariantprimitivecoordinates)=(jt_divisor_appendinvariantprimitive)*jt_factor_appendinvariantprimitivecoordinatesdivides)) -> jt_divisor_appendinvariantprimitive=1))))) /\ (((forall jt_i_appendinvariant jt_h_appendinvariant jt_b_appendinvariant jt_e_appendinvariant jt_d_appendinvariant jt_f_appendinvariant. (exists jt_gap_appendinvariantfirstindex. jt_gap_appendinvariantfirstindex+S (jt_i_appendinvariant)=(j)) -> (exists jt_gap_appendinvariantsecondindex. jt_gap_appendinvariantsecondindex+S (jt_h_appendinvariant)=(j)) -> (((((exists fs_h_jt_appendinvariantfirstcode. fs_h_jt_appendinvariantfirstcode + S (jt_b_appendinvariant) = S ((S (jt_i_appendinvariant)) * C)) /\ exists fs_q_jt_appendinvariantfirstcode. B = fs_q_jt_appendinvariantfirstcode * S ((S (jt_i_appendinvariant)) * C) + (jt_b_appendinvariant))) /\ (((exists fs_h_jt_appendinvariantfirstscale. fs_h_jt_appendinvariantfirstscale + S (jt_e_appendinvariant) = S ((S (jt_i_appendinvariant)) * E)) /\ exists fs_q_jt_appendinvariantfirstscale. D = fs_q_jt_appendinvariantfirstscale * S ((S (jt_i_appendinvariant)) * E) + (jt_e_appendinvariant))))) -> (((((exists fs_h_jt_appendinvariantsecondcode. fs_h_jt_appendinvariantsecondcode + S (jt_d_appendinvariant) = S ((S (jt_h_appendinvariant)) * C)) /\ exists fs_q_jt_appendinvariantsecondcode. B = fs_q_jt_appendinvariantsecondcode * S ((S (jt_h_appendinvariant)) * C) + (jt_d_appendinvariant))) /\ (((exists fs_h_jt_appendinvariantsecondscale. fs_h_jt_appendinvariantsecondscale + S (jt_f_appendinvariant) = S ((S (jt_h_appendinvariant)) * E)) /\ exists fs_q_jt_appendinvariantsecondscale. D = fs_q_jt_appendinvariantsecondscale * S ((S (jt_h_appendinvariant)) * E) + (jt_f_appendinvariant))))) -> (forall jt_index_appendinvariantsame jt_left_appendinvariantsame jt_right_appendinvariantsame. (exists jt_gap_appendinvariantsameindex. jt_gap_appendinvariantsameindex+S (jt_index_appendinvariantsame)=(k)) -> (((exists fs_h_jt_appendinvariantsameleft. fs_h_jt_appendinvariantsameleft + S (jt_left_appendinvariantsame) = S ((S (jt_index_appendinvariantsame)) * jt_e_appendinvariant)) /\ exists fs_q_jt_appendinvariantsameleft. jt_b_appendinvariant = fs_q_jt_appendinvariantsameleft * S ((S (jt_index_appendinvariantsame)) * jt_e_appendinvariant) + (jt_left_appendinvariantsame))) -> (((exists fs_h_jt_appendinvariantsameright. fs_h_jt_appendinvariantsameright + S (jt_right_appendinvariantsame) = S ((S (jt_index_appendinvariantsame)) * jt_f_appendinvariant)) /\ exists fs_q_jt_appendinvariantsameright. jt_d_appendinvariant = fs_q_jt_appendinvariantsameright * S ((S (jt_index_appendinvariantsame)) * jt_f_appendinvariant) + (jt_right_appendinvariantsame))) -> jt_left_appendinvariantsame=jt_right_appendinvariantsame) -> jt_i_appendinvariant=jt_h_appendinvariant) /\ (forall jt_z_appendinvariant. (exists jt_gap_appendinvariantcodeindex. jt_gap_appendinvariantcodeindex+S (jt_z_appendinvariant)=(t)) -> (forall jt_index_appendinvariantinputbound. (exists jt_gap_appendinvariantinputboundindex. jt_gap_appendinvariantinputboundindex+S (jt_index_appendinvariantinputbound)=(k)) -> exists jt_value_appendinvariantinputbound. ((((exists fs_h_jt_appendinvariantinputboundat. fs_h_jt_appendinvariantinputboundat + S (jt_value_appendinvariantinputbound) = S ((S (jt_index_appendinvariantinputbound)) * c)) /\ exists fs_q_jt_appendinvariantinputboundat. jt_z_appendinvariant = fs_q_jt_appendinvariantinputboundat * S ((S (jt_index_appendinvariantinputbound)) * c) + (jt_value_appendinvariantinputbound))) /\ (exists jt_gap_appendinvariantinputboundvalue. jt_gap_appendinvariantinputboundvalue+S (jt_value_appendinvariantinputbound)=(n)))) -> (forall jt_divisor_appendinvariantinputprimitive. (exists jt_factor_appendinvariantinputprimitivemodulus. (n)=(jt_divisor_appendinvariantinputprimitive)*jt_factor_appendinvariantinputprimitivemodulus) -> (forall jt_index_appendinvariantinputprimitivecoordinates jt_value_appendinvariantinputprimitivecoordinates. (exists jt_gap_appendinvariantinputprimitivecoordinatesindex. jt_gap_appendinvariantinputprimitivecoordinatesindex+S (jt_index_appendinvariantinputprimitivecoordinates)=(k)) -> (((exists fs_h_jt_appendinvariantinputprimitivecoordinatesat. fs_h_jt_appendinvariantinputprimitivecoordinatesat + S (jt_value_appendinvariantinputprimitivecoordinates) = S ((S (jt_index_appendinvariantinputprimitivecoordinates)) * c)) /\ exists fs_q_jt_appendinvariantinputprimitivecoordinatesat. jt_z_appendinvariant = fs_q_jt_appendinvariantinputprimitivecoordinatesat * S ((S (jt_index_appendinvariantinputprimitivecoordinates)) * c) + (jt_value_appendinvariantinputprimitivecoordinates))) -> (exists jt_factor_appendinvariantinputprimitivecoordinatesdivides. (jt_value_appendinvariantinputprimitivecoordinates)=(jt_divisor_appendinvariantinputprimitive)*jt_factor_appendinvariantinputprimitivecoordinatesdivides)) -> jt_divisor_appendinvariantinputprimitive=1) -> (exists jt_index_appendinvariantlisted jt_code_appendinvariantlisted jt_scale_appendinvariantlisted. ((exists jt_gap_appendinvariantlistedindex. jt_gap_appendinvariantlistedindex+S (jt_index_appendinvariantlisted)=(j)) /\ (((((((exists fs_h_jt_appendinvariantlistedcode. fs_h_jt_appendinvariantlistedcode + S (jt_code_appendinvariantlisted) = S ((S (jt_index_appendinvariantlisted)) * C)) /\ exists fs_q_jt_appendinvariantlistedcode. B = fs_q_jt_appendinvariantlistedcode * S ((S (jt_index_appendinvariantlisted)) * C) + (jt_code_appendinvariantlisted))) /\ (((exists fs_h_jt_appendinvariantlistedscale. fs_h_jt_appendinvariantlistedscale + S (jt_scale_appendinvariantlisted) = S ((S (jt_index_appendinvariantlisted)) * E)) /\ exists fs_q_jt_appendinvariantlistedscale. D = fs_q_jt_appendinvariantlistedscale * S ((S (jt_index_appendinvariantlisted)) * E) + (jt_scale_appendinvariantlisted))))) /\ (forall jt_index_appendinvariantlistedequal jt_left_appendinvariantlistedequal jt_right_appendinvariantlistedequal. (exists jt_gap_appendinvariantlistedequalindex. jt_gap_appendinvariantlistedequalindex+S (jt_index_appendinvariantlistedequal)=(k)) -> (((exists fs_h_jt_appendinvariantlistedequalleft. fs_h_jt_appendinvariantlistedequalleft + S (jt_left_appendinvariantlistedequal) = S ((S (jt_index_appendinvariantlistedequal)) * c)) /\ exists fs_q_jt_appendinvariantlistedequalleft. jt_z_appendinvariant = fs_q_jt_appendinvariantlistedequalleft * S ((S (jt_index_appendinvariantlistedequal)) * c) + (jt_left_appendinvariantlistedequal))) -> (((exists fs_h_jt_appendinvariantlistedequalright. fs_h_jt_appendinvariantlistedequalright + S (jt_right_appendinvariantlistedequal) = S ((S (jt_index_appendinvariantlistedequal)) * jt_scale_appendinvariantlisted)) /\ exists fs_q_jt_appendinvariantlistedequalright. jt_code_appendinvariantlisted = fs_q_jt_appendinvariantlistedequalright * S ((S (jt_index_appendinvariantlistedequal)) * jt_scale_appendinvariantlisted) + (jt_right_appendinvariantlistedequal))) -> jt_left_appendinvariantlistedequal=jt_right_appendinvariantlistedequal)))))))))) -> (forall jt_index_appendbound. (exists jt_gap_appendboundindex. jt_gap_appendboundindex+S (jt_index_appendbound)=(k)) -> exists jt_value_appendbound. ((((exists fs_h_jt_appendboundat. fs_h_jt_appendboundat + S (jt_value_appendbound) = S ((S (jt_index_appendbound)) * c)) /\ exists fs_q_jt_appendboundat. t = fs_q_jt_appendboundat * S ((S (jt_index_appendbound)) * c) + (jt_value_appendbound))) /\ (exists jt_gap_appendboundvalue. jt_gap_appendboundvalue+S (jt_value_appendbound)=(n)))) -> (forall jt_divisor_appendprimitive. (exists jt_factor_appendprimitivemodulus. (n)=(jt_divisor_appendprimitive)*jt_factor_appendprimitivemodulus) -> (forall jt_index_appendprimitivecoordinates jt_value_appendprimitivecoordinates. (exists jt_gap_appendprimitivecoordinatesindex. jt_gap_appendprimitivecoordinatesindex+S (jt_index_appendprimitivecoordinates)=(k)) -> (((exists fs_h_jt_appendprimitivecoordinatesat. fs_h_jt_appendprimitivecoordinatesat + S (jt_value_appendprimitivecoordinates) = S ((S (jt_index_appendprimitivecoordinates)) * c)) /\ exists fs_q_jt_appendprimitivecoordinatesat. t = fs_q_jt_appendprimitivecoordinatesat * S ((S (jt_index_appendprimitivecoordinates)) * c) + (jt_value_appendprimitivecoordinates))) -> (exists jt_factor_appendprimitivecoordinatesdivides. (jt_value_appendprimitivecoordinates)=(jt_divisor_appendprimitive)*jt_factor_appendprimitivecoordinatesdivides)) -> jt_divisor_appendprimitive=1) -> ~(exists jt_index_appendfresh jt_code_appendfresh jt_scale_appendfresh. ((exists jt_gap_appendfreshindex. jt_gap_appendfreshindex+S (jt_index_appendfresh)=(j)) /\ (((((((exists fs_h_jt_appendfreshcode. fs_h_jt_appendfreshcode + S (jt_code_appendfresh) = S ((S (jt_index_appendfresh)) * C)) /\ exists fs_q_jt_appendfreshcode. B = fs_q_jt_appendfreshcode * S ((S (jt_index_appendfresh)) * C) + (jt_code_appendfresh))) /\ (((exists fs_h_jt_appendfreshscale. fs_h_jt_appendfreshscale + S (jt_scale_appendfresh) = S ((S (jt_index_appendfresh)) * E)) /\ exists fs_q_jt_appendfreshscale. D = fs_q_jt_appendfreshscale * S ((S (jt_index_appendfresh)) * E) + (jt_scale_appendfresh))))) /\ (forall jt_index_appendfreshequal jt_left_appendfreshequal jt_right_appendfreshequal. (exists jt_gap_appendfreshequalindex. jt_gap_appendfreshequalindex+S (jt_index_appendfreshequal)=(k)) -> (((exists fs_h_jt_appendfreshequalleft. fs_h_jt_appendfreshequalleft + S (jt_left_appendfreshequal) = S ((S (jt_index_appendfreshequal)) * c)) /\ exists fs_q_jt_appendfreshequalleft. t = fs_q_jt_appendfreshequalleft * S ((S (jt_index_appendfreshequal)) * c) + (jt_left_appendfreshequal))) -> (((exists fs_h_jt_appendfreshequalright. fs_h_jt_appendfreshequalright + S (jt_right_appendfreshequal) = S ((S (jt_index_appendfreshequal)) * jt_scale_appendfresh)) /\ exists fs_q_jt_appendfreshequalright. jt_code_appendfresh = fs_q_jt_appendfreshequalright * S ((S (jt_index_appendfreshequal)) * jt_scale_appendfresh) + (jt_right_appendfreshequal))) -> jt_left_appendfreshequal=jt_right_appendfreshequal))))) -> exists U V W X. ((forall jt_i_appendresult. (exists jt_gap_appendresultsoundindex. jt_gap_appendresultsoundindex+S (jt_i_appendresult)=(S j)) -> exists jt_b_appendresult jt_e_appendresult. ((((((exists fs_h_jt_appendresultsoundcode. fs_h_jt_appendresultsoundcode + S (jt_b_appendresult) = S ((S (jt_i_appendresult)) * V)) /\ exists fs_q_jt_appendresultsoundcode. U = fs_q_jt_appendresultsoundcode * S ((S (jt_i_appendresult)) * V) + (jt_b_appendresult))) /\ (((exists fs_h_jt_appendresultsoundscale. fs_h_jt_appendresultsoundscale + S (jt_e_appendresult) = S ((S (jt_i_appendresult)) * X)) /\ exists fs_q_jt_appendresultsoundscale. W = fs_q_jt_appendresultsoundscale * S ((S (jt_i_appendresult)) * X) + (jt_e_appendresult))))) /\ (((forall jt_index_appendresultbound. (exists jt_gap_appendresultboundindex. jt_gap_appendresultboundindex+S (jt_index_appendresultbound)=(k)) -> exists jt_value_appendresultbound. ((((exists fs_h_jt_appendresultboundat. fs_h_jt_appendresultboundat + S (jt_value_appendresultbound) = S ((S (jt_index_appendresultbound)) * jt_e_appendresult)) /\ exists fs_q_jt_appendresultboundat. jt_b_appendresult = fs_q_jt_appendresultboundat * S ((S (jt_index_appendresultbound)) * jt_e_appendresult) + (jt_value_appendresultbound))) /\ (exists jt_gap_appendresultboundvalue. jt_gap_appendresultboundvalue+S (jt_value_appendresultbound)=(n)))) /\ (forall jt_divisor_appendresultprimitive. (exists jt_factor_appendresultprimitivemodulus. (n)=(jt_divisor_appendresultprimitive)*jt_factor_appendresultprimitivemodulus) -> (forall jt_index_appendresultprimitivecoordinates jt_value_appendresultprimitivecoordinates. (exists jt_gap_appendresultprimitivecoordinatesindex. jt_gap_appendresultprimitivecoordinatesindex+S (jt_index_appendresultprimitivecoordinates)=(k)) -> (((exists fs_h_jt_appendresultprimitivecoordinatesat. fs_h_jt_appendresultprimitivecoordinatesat + S (jt_value_appendresultprimitivecoordinates) = S ((S (jt_index_appendresultprimitivecoordinates)) * jt_e_appendresult)) /\ exists fs_q_jt_appendresultprimitivecoordinatesat. jt_b_appendresult = fs_q_jt_appendresultprimitivecoordinatesat * S ((S (jt_index_appendresultprimitivecoordinates)) * jt_e_appendresult) + (jt_value_appendresultprimitivecoordinates))) -> (exists jt_factor_appendresultprimitivecoordinatesdivides. (jt_value_appendresultprimitivecoordinates)=(jt_divisor_appendresultprimitive)*jt_factor_appendresultprimitivecoordinatesdivides)) -> jt_divisor_appendresultprimitive=1))))) /\ (((forall jt_i_appendresult jt_h_appendresult jt_b_appendresult jt_e_appendresult jt_d_appendresult jt_f_appendresult. (exists jt_gap_appendresultfirstindex. jt_gap_appendresultfirstindex+S (jt_i_appendresult)=(S j)) -> (exists jt_gap_appendresultsecondindex. jt_gap_appendresultsecondindex+S (jt_h_appendresult)=(S j)) -> (((((exists fs_h_jt_appendresultfirstcode. fs_h_jt_appendresultfirstcode + S (jt_b_appendresult) = S ((S (jt_i_appendresult)) * V)) /\ exists fs_q_jt_appendresultfirstcode. U = fs_q_jt_appendresultfirstcode * S ((S (jt_i_appendresult)) * V) + (jt_b_appendresult))) /\ (((exists fs_h_jt_appendresultfirstscale. fs_h_jt_appendresultfirstscale + S (jt_e_appendresult) = S ((S (jt_i_appendresult)) * X)) /\ exists fs_q_jt_appendresultfirstscale. W = fs_q_jt_appendresultfirstscale * S ((S (jt_i_appendresult)) * X) + (jt_e_appendresult))))) -> (((((exists fs_h_jt_appendresultsecondcode. fs_h_jt_appendresultsecondcode + S (jt_d_appendresult) = S ((S (jt_h_appendresult)) * V)) /\ exists fs_q_jt_appendresultsecondcode. U = fs_q_jt_appendresultsecondcode * S ((S (jt_h_appendresult)) * V) + (jt_d_appendresult))) /\ (((exists fs_h_jt_appendresultsecondscale. fs_h_jt_appendresultsecondscale + S (jt_f_appendresult) = S ((S (jt_h_appendresult)) * X)) /\ exists fs_q_jt_appendresultsecondscale. W = fs_q_jt_appendresultsecondscale * S ((S (jt_h_appendresult)) * X) + (jt_f_appendresult))))) -> (forall jt_index_appendresultsame jt_left_appendresultsame jt_right_appendresultsame. (exists jt_gap_appendresultsameindex. jt_gap_appendresultsameindex+S (jt_index_appendresultsame)=(k)) -> (((exists fs_h_jt_appendresultsameleft. fs_h_jt_appendresultsameleft + S (jt_left_appendresultsame) = S ((S (jt_index_appendresultsame)) * jt_e_appendresult)) /\ exists fs_q_jt_appendresultsameleft. jt_b_appendresult = fs_q_jt_appendresultsameleft * S ((S (jt_index_appendresultsame)) * jt_e_appendresult) + (jt_left_appendresultsame))) -> (((exists fs_h_jt_appendresultsameright. fs_h_jt_appendresultsameright + S (jt_right_appendresultsame) = S ((S (jt_index_appendresultsame)) * jt_f_appendresult)) /\ exists fs_q_jt_appendresultsameright. jt_d_appendresult = fs_q_jt_appendresultsameright * S ((S (jt_index_appendresultsame)) * jt_f_appendresult) + (jt_right_appendresultsame))) -> jt_left_appendresultsame=jt_right_appendresultsame) -> jt_i_appendresult=jt_h_appendresult) /\ (forall jt_z_appendresult. (exists jt_gap_appendresultcodeindex. jt_gap_appendresultcodeindex+S (jt_z_appendresult)=(S t)) -> (forall jt_index_appendresultinputbound. (exists jt_gap_appendresultinputboundindex. jt_gap_appendresultinputboundindex+S (jt_index_appendresultinputbound)=(k)) -> exists jt_value_appendresultinputbound. ((((exists fs_h_jt_appendresultinputboundat. fs_h_jt_appendresultinputboundat + S (jt_value_appendresultinputbound) = S ((S (jt_index_appendresultinputbound)) * c)) /\ exists fs_q_jt_appendresultinputboundat. jt_z_appendresult = fs_q_jt_appendresultinputboundat * S ((S (jt_index_appendresultinputbound)) * c) + (jt_value_appendresultinputbound))) /\ (exists jt_gap_appendresultinputboundvalue. jt_gap_appendresultinputboundvalue+S (jt_value_appendresultinputbound)=(n)))) -> (forall jt_divisor_appendresultinputprimitive. (exists jt_factor_appendresultinputprimitivemodulus. (n)=(jt_divisor_appendresultinputprimitive)*jt_factor_appendresultinputprimitivemodulus) -> (forall jt_index_appendresultinputprimitivecoordinates jt_value_appendresultinputprimitivecoordinates. (exists jt_gap_appendresultinputprimitivecoordinatesindex. jt_gap_appendresultinputprimitivecoordinatesindex+S (jt_index_appendresultinputprimitivecoordinates)=(k)) -> (((exists fs_h_jt_appendresultinputprimitivecoordinatesat. fs_h_jt_appendresultinputprimitivecoordinatesat + S (jt_value_appendresultinputprimitivecoordinates) = S ((S (jt_index_appendresultinputprimitivecoordinates)) * c)) /\ exists fs_q_jt_appendresultinputprimitivecoordinatesat. jt_z_appendresult = fs_q_jt_appendresultinputprimitivecoordinatesat * S ((S (jt_index_appendresultinputprimitivecoordinates)) * c) + (jt_value_appendresultinputprimitivecoordinates))) -> (exists jt_factor_appendresultinputprimitivecoordinatesdivides. (jt_value_appendresultinputprimitivecoordinates)=(jt_divisor_appendresultinputprimitive)*jt_factor_appendresultinputprimitivecoordinatesdivides)) -> jt_divisor_appendresultinputprimitive=1) -> (exists jt_index_appendresultlisted jt_code_appendresultlisted jt_scale_appendresultlisted. ((exists jt_gap_appendresultlistedindex. jt_gap_appendresultlistedindex+S (jt_index_appendresultlisted)=(S j)) /\ (((((((exists fs_h_jt_appendresultlistedcode. fs_h_jt_appendresultlistedcode + S (jt_code_appendresultlisted) = S ((S (jt_index_appendresultlisted)) * V)) /\ exists fs_q_jt_appendresultlistedcode. U = fs_q_jt_appendresultlistedcode * S ((S (jt_index_appendresultlisted)) * V) + (jt_code_appendresultlisted))) /\ (((exists fs_h_jt_appendresultlistedscale. fs_h_jt_appendresultlistedscale + S (jt_scale_appendresultlisted) = S ((S (jt_index_appendresultlisted)) * X)) /\ exists fs_q_jt_appendresultlistedscale. W = fs_q_jt_appendresultlistedscale * S ((S (jt_index_appendresultlisted)) * X) + (jt_scale_appendresultlisted))))) /\ (forall jt_index_appendresultlistedequal jt_left_appendresultlistedequal jt_right_appendresultlistedequal. (exists jt_gap_appendresultlistedequalindex. jt_gap_appendresultlistedequalindex+S (jt_index_appendresultlistedequal)=(k)) -> (((exists fs_h_jt_appendresultlistedequalleft. fs_h_jt_appendresultlistedequalleft + S (jt_left_appendresultlistedequal) = S ((S (jt_index_appendresultlistedequal)) * c)) /\ exists fs_q_jt_appendresultlistedequalleft. jt_z_appendresult = fs_q_jt_appendresultlistedequalleft * S ((S (jt_index_appendresultlistedequal)) * c) + (jt_left_appendresultlistedequal))) -> (((exists fs_h_jt_appendresultlistedequalright. fs_h_jt_appendresultlistedequalright + S (jt_right_appendresultlistedequal) = S ((S (jt_index_appendresultlistedequal)) * jt_scale_appendresultlisted)) /\ exists fs_q_jt_appendresultlistedequalright. jt_code_appendresultlisted = fs_q_jt_appendresultlistedequalright * S ((S (jt_index_appendresultlistedequal)) * jt_scale_appendresultlisted) + (jt_right_appendresultlistedequal))) -> jt_left_appendresultlistedequal=jt_right_appendresultlistedequal)))))))))

Constructive proof overview

Generated structural guide

Append an actually absent primitive tuple and prove full soundness, distinctness and prefix coverage.

The unchanged tactic script uses 8 declared prerequisites and contains 388 exact native proof lines.

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

Proof neighborhood

Direct dependencies

JT0021 jordan_tuple_outer_append_exists JT0002 jordan_tuple_equal_symm finite_lt_succ_eq_or_lt Alpha theorem; checked-use authorized JT001F jordan_tuple_equal_entry beta_at_unique Alpha theorem; checked-use authorized le_refl Alpha theorem; checked-use authorized jordan_tuple_equal_refl Alpha theorem; checked-use authorized le_succ Alpha theorem; checked-use authorized

Direct dependents

Formal native tactic body

Dependencies are introduced as named hypotheses before line 1. Local theorem links identify exact declared prerequisites. This exact body belongs to a complete independently kernel-checked constructive proof bundle and has Alpha checked-use authority; it does not imply Stable membership.

Read the argument

Proof checkpoints

388 script commands · 96 reading checkpoints · 13 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.

Named ingredients (3)

Long local formulas use this family’s existing definitions. Each new abbreviation was expanded back to the identical native formula, including its free-variable context. The original edition is preserved below.

01Fix variables and assumptionsL1–10

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

  1. L1
    intro k
  2. L2
    intro n
  3. L3
    intro c
  4. L4
    intro t
  5. L5
    intro B
  6. L6
    intro C
  7. L7
    intro D
  8. L8
    intro E
  9. L9
    intro j
  10. L10
    intro hscan
02Fix variables and assumptionsL11–13

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

  1. L11
    intro hb
  2. L12
    intro hp
  3. L13
    intro hfresh
03Establish hextL14–22

Establish this local claim before using it. It is not an additional assumption. The following proof commands apply jordan tuple outer append exists.

  1. L14
    have hext : ∃ U. ∃ V. ∃ W. ∃ X. IntegerVectorZero(B,C,U,V,j) ∧ (IntegerVectorZero(D,E,W,X,j) ∧ (BetaAt(U,V,j,t) ∧ BetaAt(W,X,j,c)))Definitions: IntegerVectorZeroBetaAt
  2. L15
    specialize jordan_tuple_outer_append_exists (B)
  3. L16
    specialize jordan_tuple_outer_append_exists (C)
  4. L17
    specialize jordan_tuple_outer_append_exists (D)
  5. L18
    specialize jordan_tuple_outer_append_exists (E)
  6. L19
    specialize jordan_tuple_outer_append_exists (j)
  7. L20
    specialize jordan_tuple_outer_append_exists (t)
  8. L21
    specialize jordan_tuple_outer_append_exists (c)
  9. L22
    apply jordan_tuple_outer_append_exists
04Separate the logical casesL23–31

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

  1. L23
    cases hext
  2. L24
    cases hext_witness
  3. L25
    cases hext_witness_witness
  4. L26
    cases hext_witness_witness_witness
  5. L27
    cases hext_witness_witness_witness_witness
  6. L28
    cases hext_witness_witness_witness_witness_right
  7. L29
    cases hext_witness_witness_witness_witness_right_right
  8. L30
    cases hscan
  9. L31
    cases hscan_right
05Establish hcodesbackL32–39

Establish this local claim before using it. It is not an additional assumption. The following proof commands apply jordan tuple equal symm.

  1. L32
    have hcodesback : IntegerVectorZero(x,x1,B,C,j)Definitions: IntegerVectorZero
  2. L33
    specialize jordan_tuple_equal_symm (B)
  3. L34
    specialize jordan_tuple_equal_symm (C)
  4. L35
    specialize jordan_tuple_equal_symm (x)
  5. L36
    specialize jordan_tuple_equal_symm (x1)
  6. L37
    specialize jordan_tuple_equal_symm (j)
  7. L38
    apply jordan_tuple_equal_symm
  8. L39
    exact hext_witness_witness_witness_witness_left
06Establish hscalesbackL40–47

Establish this local claim before using it. It is not an additional assumption. The following proof commands apply jordan tuple equal symm.

  1. L40
    have hscalesback : IntegerVectorZero(x2,x3,D,E,j)Definitions: IntegerVectorZero
  2. L41
    specialize jordan_tuple_equal_symm (D)
  3. L42
    specialize jordan_tuple_equal_symm (E)
  4. L43
    specialize jordan_tuple_equal_symm (x2)
  5. L44
    specialize jordan_tuple_equal_symm (x3)
  6. L45
    specialize jordan_tuple_equal_symm (j)
  7. L46
    apply jordan_tuple_equal_symm
  8. L47
    exact hext_witness_witness_witness_witness_right_left
07Construct an explicit witnessL48–51

Supply the displayed value, then prove that it has the required property.

  1. L48
    exists x
  2. L49
    exists x1
  3. L50
    exists x2
  4. L51
    exists x3
08Separate the logical casesL52–52

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

  1. L52
    split
09Fix variables and assumptionsL53–54

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

  1. L53
    intro i
  2. L54
    intro hi
10Establish hicL55–59

Establish this local claim before using it. It is not an additional assumption. The following proof commands apply finite lt succ eq or lt.

  1. L55
    have hic : i=j \/ (exists jt_gap_appendindex. jt_gap_appendindex+S (i)=(j))
  2. L56
    specialize finite_lt_succ_eq_or_lt (j)
  3. L57
    specialize finite_lt_succ_eq_or_lt (i)
  4. L58
    apply finite_lt_succ_eq_or_lt
  5. L59
    exact hi
11Separate the logical casesL60–60

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

  1. L60
    cases hic
12Construct an explicit witnessL61–62

Supply the displayed value, then prove that it has the required property.

  1. L61
    exists t
  2. L62
    exists c
13Separate the logical casesL63–64

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

  1. L63
    split
  2. L64
    split
14Calculate and transport equalitiesL65–66

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

  1. L65
    rewrite hic_left
  2. L66
    rewrite hic_left
15Use earlier factsL67–67

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

  1. L67
    exact hext_witness_witness_witness_witness_right_right_left
16Calculate and transport equalitiesL68–69

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

  1. L68
    rewrite hic_left
  2. L69
    rewrite hic_left
17Use earlier factsL70–70

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

  1. L70
    exact hext_witness_witness_witness_witness_right_right_right
18Separate the logical casesL71–71

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

  1. L71
    split
19Use earlier factsL72–73

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

  1. L72
    exact hb
  2. L73
    exact hp
20Establish hvalueL74–77

Establish this local claim before using it. It is not an additional assumption. The following proof commands apply hscan left.

  1. L74
    have hvalue : ∃ b. ∃ e. BetaAt(B,C,i,b) ∧ BetaAt(D,E,i,e) ∧ (BetaPrefixInto(b,e,k,n) ∧ JordanPrimitiveTuple(n,b,e,k))Definitions: BetaPrefixIntoJordanPrimitiveTupleBetaAt
  2. L75
    specialize hscan_left (i)
  3. L76
    apply hscan_left
  4. L77
    exact hic_right
21Separate the logical casesL78–82

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

  1. L78
    cases hvalue
  2. L79
    cases hvalue_witness
  3. L80
    cases hvalue_witness_witness
  4. L81
    cases hvalue_witness_witness_right
  5. L82
    cases hvalue_witness_witness_left
22Construct an explicit witnessL83–84

Supply the displayed value, then prove that it has the required property.

  1. L83
    exists x4
  2. L84
    exists x5
23Separate the logical casesL85–86

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

  1. L85
    split
  2. L86
    split
24Use earlier factsL87–96

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

  1. L87
    specialize jordan_tuple_equal_entry (B)
  2. L88
    specialize jordan_tuple_equal_entry (C)
  3. L89
    specialize jordan_tuple_equal_entry (x)
  4. L90
    specialize jordan_tuple_equal_entry (x1)
  5. L91
    specialize jordan_tuple_equal_entry (j)
  6. L92
    specialize jordan_tuple_equal_entry (i)
  7. L93
    specialize jordan_tuple_equal_entry (x4)
  8. L94
    apply jordan_tuple_equal_entry
  9. L95
    exact hext_witness_witness_witness_witness_left
  10. L96
    exact hic_right
25Use earlier factsL97–106

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

  1. L97
    exact hvalue_witness_witness_left_left
  2. L98
    specialize jordan_tuple_equal_entry (D)
  3. L99
    specialize jordan_tuple_equal_entry (E)
  4. L100
    specialize jordan_tuple_equal_entry (x2)
  5. L101
    specialize jordan_tuple_equal_entry (x3)
  6. L102
    specialize jordan_tuple_equal_entry (j)
  7. L103
    specialize jordan_tuple_equal_entry (i)
  8. L104
    specialize jordan_tuple_equal_entry (x5)
  9. L105
    apply jordan_tuple_equal_entry
  10. L106
    exact hext_witness_witness_witness_witness_right_left
26Use earlier factsL107–108

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

  1. L107
    exact hic_right
  2. L108
    exact hvalue_witness_witness_left_right
27Separate the logical casesL109–109

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

  1. L109
    split
28Use earlier factsL110–111

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

  1. L110
    exact hvalue_witness_witness_right_left
  2. L111
    exact hvalue_witness_witness_right_right
29Separate the logical casesL112–112

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

  1. L112
    split
30Fix variables and assumptionsL113–122

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

  1. L113
    intro i
  2. L114
    intro h
  3. L115
    intro b
  4. L116
    intro e
  5. L117
    intro d
  6. L118
    intro f
  7. L119
    intro hi
  8. L120
    intro hh
  9. L121
    intro hfirst
  10. L122
    intro hsecond
31Fix variables and assumptionsL123–123

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

  1. L123
    intro heq
32Separate the logical casesL124–125

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

  1. L124
    cases hfirst
  2. L125
    cases hsecond
33Establish hicL126–130

Establish this local claim before using it. It is not an additional assumption. The following proof commands apply finite lt succ eq or lt.

  1. L126
    have hic : i=j \/ (exists jt_gap_appendfirstcase. jt_gap_appendfirstcase+S (i)=(j))
  2. L127
    specialize finite_lt_succ_eq_or_lt (j)
  3. L128
    specialize finite_lt_succ_eq_or_lt (i)
  4. L129
    apply finite_lt_succ_eq_or_lt
  5. L130
    exact hi
34Establish hhcL131–135

Establish this local claim before using it. It is not an additional assumption. The following proof commands apply finite lt succ eq or lt.

  1. L131
    have hhc : h=j \/ (exists jt_gap_appendsecondcase. jt_gap_appendsecondcase+S (h)=(j))
  2. L132
    specialize finite_lt_succ_eq_or_lt (j)
  3. L133
    specialize finite_lt_succ_eq_or_lt (h)
  4. L134
    apply finite_lt_succ_eq_or_lt
  5. L135
    exact hh
35Separate the logical casesL136–137

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

  1. L136
    cases hic
  2. L137
    cases hhc
36Calculate and transport equalitiesL138–138

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

  1. L138
    trans j
37Use earlier factsL139–139

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

  1. L139
    exact hic_left
38Calculate and transport equalitiesL140–140

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

  1. L140
    symm
39Use earlier factsL141–141

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

  1. L141
    exact hhc_left
40Establish hbvalL142–151

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

  1. L142
    have hbval : b=t
  2. L143
    specialize beta_at_unique (x)
  3. L144
    specialize beta_at_unique (x1)
  4. L145
    specialize beta_at_unique (j)
  5. L146
    specialize beta_at_unique (b)
  6. L147
    specialize beta_at_unique (t)
  7. L148
    apply beta_at_unique
  8. L149
    rewrite hic_left at hfirst_left
  9. L150
    rewrite hic_left at hfirst_left
  10. L151
    exact hfirst_left
41Use earlier factsL152–152

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

  1. L152
    exact hext_witness_witness_witness_witness_right_right_left
42Establish hevalL153–162

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

  1. L153
    have heval : e=c
  2. L154
    specialize beta_at_unique (x2)
  3. L155
    specialize beta_at_unique (x3)
  4. L156
    specialize beta_at_unique (j)
  5. L157
    specialize beta_at_unique (e)
  6. L158
    specialize beta_at_unique (c)
  7. L159
    apply beta_at_unique
  8. L160
    rewrite hic_left at hfirst_right
  9. L161
    rewrite hic_left at hfirst_right
  10. L162
    exact hfirst_right
43Use earlier factsL163–163

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

  1. L163
    exact hext_witness_witness_witness_witness_right_right_right
44Separate the logical casesL164–164

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

  1. L164
    exfalso
45Use earlier factsL165–165

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

  1. L165
    apply hfresh
46Construct an explicit witnessL166–168

Supply the displayed value, then prove that it has the required property.

  1. L166
    exists h
  2. L167
    exists d
  3. L168
    exists f
47Separate the logical casesL169–169

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

  1. L169
    split
48Use earlier factsL170–170

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

  1. L170
    exact hhc_right
49Separate the logical casesL171–172

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

  1. L171
    split
  2. L172
    split
50Use earlier factsL173–182

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

  1. L173
    specialize jordan_tuple_equal_entry (x)
  2. L174
    specialize jordan_tuple_equal_entry (x1)
  3. L175
    specialize jordan_tuple_equal_entry (B)
  4. L176
    specialize jordan_tuple_equal_entry (C)
  5. L177
    specialize jordan_tuple_equal_entry (j)
  6. L178
    specialize jordan_tuple_equal_entry (h)
  7. L179
    specialize jordan_tuple_equal_entry (d)
  8. L180
    apply jordan_tuple_equal_entry
  9. L181
    exact hcodesback
  10. L182
    exact hhc_right
51Use earlier factsL183–192

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

  1. L183
    exact hsecond_left
  2. L184
    specialize jordan_tuple_equal_entry (x2)
  3. L185
    specialize jordan_tuple_equal_entry (x3)
  4. L186
    specialize jordan_tuple_equal_entry (D)
  5. L187
    specialize jordan_tuple_equal_entry (E)
  6. L188
    specialize jordan_tuple_equal_entry (j)
  7. L189
    specialize jordan_tuple_equal_entry (h)
  8. L190
    specialize jordan_tuple_equal_entry (f)
  9. L191
    apply jordan_tuple_equal_entry
  10. L192
    exact hscalesback
52Use earlier factsL193–194

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

  1. L193
    exact hhc_right
  2. L194
    exact hsecond_right
53Calculate and transport equalitiesL195–197

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

  1. L195
    rewrite hbval at heq
  2. L196
    rewrite heval at heq
  3. L197
    rewrite heval at heq
54Use earlier factsL198–198

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

  1. L198
    exact heq
55Separate the logical casesL199–199

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

  1. L199
    cases hhc
56Establish hdvalL200–209

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

  1. L200
    have hdval : d=t
  2. L201
    specialize beta_at_unique (x)
  3. L202
    specialize beta_at_unique (x1)
  4. L203
    specialize beta_at_unique (j)
  5. L204
    specialize beta_at_unique (d)
  6. L205
    specialize beta_at_unique (t)
  7. L206
    apply beta_at_unique
  8. L207
    rewrite hhc_left at hsecond_left
  9. L208
    rewrite hhc_left at hsecond_left
  10. L209
    exact hsecond_left
57Use earlier factsL210–210

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

  1. L210
    exact hext_witness_witness_witness_witness_right_right_left
58Establish hfvalL211–220

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

  1. L211
    have hfval : f=c
  2. L212
    specialize beta_at_unique (x2)
  3. L213
    specialize beta_at_unique (x3)
  4. L214
    specialize beta_at_unique (j)
  5. L215
    specialize beta_at_unique (f)
  6. L216
    specialize beta_at_unique (c)
  7. L217
    apply beta_at_unique
  8. L218
    rewrite hhc_left at hsecond_right
  9. L219
    rewrite hhc_left at hsecond_right
  10. L220
    exact hsecond_right
59Use earlier factsL221–221

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

  1. L221
    exact hext_witness_witness_witness_witness_right_right_right
60Separate the logical casesL222–222

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

  1. L222
    exfalso
61Use earlier factsL223–223

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

  1. L223
    apply hfresh
62Construct an explicit witnessL224–226

Supply the displayed value, then prove that it has the required property.

  1. L224
    exists i
  2. L225
    exists b
  3. L226
    exists e
63Separate the logical casesL227–227

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

  1. L227
    split
64Use earlier factsL228–228

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

  1. L228
    exact hic_right
65Separate the logical casesL229–230

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

  1. L229
    split
  2. L230
    split
66Use earlier factsL231–240

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

  1. L231
    specialize jordan_tuple_equal_entry (x)
  2. L232
    specialize jordan_tuple_equal_entry (x1)
  3. L233
    specialize jordan_tuple_equal_entry (B)
  4. L234
    specialize jordan_tuple_equal_entry (C)
  5. L235
    specialize jordan_tuple_equal_entry (j)
  6. L236
    specialize jordan_tuple_equal_entry (i)
  7. L237
    specialize jordan_tuple_equal_entry (b)
  8. L238
    apply jordan_tuple_equal_entry
  9. L239
    exact hcodesback
  10. L240
    exact hic_right
67Use earlier factsL241–250

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

  1. L241
    exact hfirst_left
  2. L242
    specialize jordan_tuple_equal_entry (x2)
  3. L243
    specialize jordan_tuple_equal_entry (x3)
  4. L244
    specialize jordan_tuple_equal_entry (D)
  5. L245
    specialize jordan_tuple_equal_entry (E)
  6. L246
    specialize jordan_tuple_equal_entry (j)
  7. L247
    specialize jordan_tuple_equal_entry (i)
  8. L248
    specialize jordan_tuple_equal_entry (e)
  9. L249
    apply jordan_tuple_equal_entry
  10. L250
    exact hscalesback
68Use earlier factsL251–258

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

  1. L251
    exact hic_right
  2. L252
    exact hfirst_right
  3. L253
    specialize jordan_tuple_equal_symm (b)
  4. L254
    specialize jordan_tuple_equal_symm (e)
  5. L255
    specialize jordan_tuple_equal_symm (t)
  6. L256
    specialize jordan_tuple_equal_symm (c)
  7. L257
    specialize jordan_tuple_equal_symm (k)
  8. L258
    apply jordan_tuple_equal_symm
69Calculate and transport equalitiesL259–261

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

  1. L259
    rewrite hdval at heq
  2. L260
    rewrite hfval at heq
  3. L261
    rewrite hfval at heq
70Use earlier factsL262–271

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

  1. L262
    exact heq
  2. L263
    specialize hscan_right_left (i)
  3. L264
    specialize hscan_right_left (h)
  4. L265
    specialize hscan_right_left (b)
  5. L266
    specialize hscan_right_left (e)
  6. L267
    specialize hscan_right_left (d)
  7. L268
    specialize hscan_right_left (f)
  8. L269
    apply hscan_right_left
  9. L270
    exact hic_right
  10. L271
    exact hhc_right
71Separate the logical casesL272–272

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

  1. L272
    split
72Use earlier factsL273–282

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

  1. L273
    specialize jordan_tuple_equal_entry (x)
  2. L274
    specialize jordan_tuple_equal_entry (x1)
  3. L275
    specialize jordan_tuple_equal_entry (B)
  4. L276
    specialize jordan_tuple_equal_entry (C)
  5. L277
    specialize jordan_tuple_equal_entry (j)
  6. L278
    specialize jordan_tuple_equal_entry (i)
  7. L279
    specialize jordan_tuple_equal_entry (b)
  8. L280
    apply jordan_tuple_equal_entry
  9. L281
    exact hcodesback
  10. L282
    exact hic_right
73Use earlier factsL283–292

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

  1. L283
    exact hfirst_left
  2. L284
    specialize jordan_tuple_equal_entry (x2)
  3. L285
    specialize jordan_tuple_equal_entry (x3)
  4. L286
    specialize jordan_tuple_equal_entry (D)
  5. L287
    specialize jordan_tuple_equal_entry (E)
  6. L288
    specialize jordan_tuple_equal_entry (j)
  7. L289
    specialize jordan_tuple_equal_entry (i)
  8. L290
    specialize jordan_tuple_equal_entry (e)
  9. L291
    apply jordan_tuple_equal_entry
  10. L292
    exact hscalesback
74Use earlier factsL293–294

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

  1. L293
    exact hic_right
  2. L294
    exact hfirst_right
75Separate the logical casesL295–295

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

  1. L295
    split
76Use earlier factsL296–305

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

  1. L296
    specialize jordan_tuple_equal_entry (x)
  2. L297
    specialize jordan_tuple_equal_entry (x1)
  3. L298
    specialize jordan_tuple_equal_entry (B)
  4. L299
    specialize jordan_tuple_equal_entry (C)
  5. L300
    specialize jordan_tuple_equal_entry (j)
  6. L301
    specialize jordan_tuple_equal_entry (h)
  7. L302
    specialize jordan_tuple_equal_entry (d)
  8. L303
    apply jordan_tuple_equal_entry
  9. L304
    exact hcodesback
  10. L305
    exact hhc_right
77Use earlier factsL306–315

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

  1. L306
    exact hsecond_left
  2. L307
    specialize jordan_tuple_equal_entry (x2)
  3. L308
    specialize jordan_tuple_equal_entry (x3)
  4. L309
    specialize jordan_tuple_equal_entry (D)
  5. L310
    specialize jordan_tuple_equal_entry (E)
  6. L311
    specialize jordan_tuple_equal_entry (j)
  7. L312
    specialize jordan_tuple_equal_entry (h)
  8. L313
    specialize jordan_tuple_equal_entry (f)
  9. L314
    apply jordan_tuple_equal_entry
  10. L315
    exact hscalesback
78Use earlier factsL316–318

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

  1. L316
    exact hhc_right
  2. L317
    exact hsecond_right
  3. L318
    exact heq
79Fix variables and assumptionsL319–322

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

  1. L319
    intro z
  2. L320
    intro hz
  3. L321
    intro hzb
  4. L322
    intro hzp
80Establish hzcL323–327

Establish this local claim before using it. It is not an additional assumption. The following proof commands apply finite lt succ eq or lt.

  1. L323
    have hzc : z=t \/ (exists jt_gap_appendcovercase. jt_gap_appendcovercase+S (z)=(t))
  2. L324
    specialize finite_lt_succ_eq_or_lt (t)
  3. L325
    specialize finite_lt_succ_eq_or_lt (z)
  4. L326
    apply finite_lt_succ_eq_or_lt
  5. L327
    exact hz
81Separate the logical casesL328–328

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

  1. L328
    cases hzc
82Calculate and transport equalitiesL329–329

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

  1. L329
    rewrite hzc_left
83Construct an explicit witnessL330–332

Supply the displayed value, then prove that it has the required property.

  1. L330
    exists j
  2. L331
    exists t
  3. L332
    exists c
84Separate the logical casesL333–333

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

  1. L333
    split
85Use earlier factsL334–335

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

  1. L334
    specialize le_refl (S j)
  2. L335
    apply le_refl
86Separate the logical casesL336–337

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

  1. L336
    split
  2. L337
    split
87Use earlier factsL338–343

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

  1. L338
    exact hext_witness_witness_witness_witness_right_right_left
  2. L339
    exact hext_witness_witness_witness_witness_right_right_right
  3. L340
    specialize jordan_tuple_equal_refl (t)
  4. L341
    specialize jordan_tuple_equal_refl (c)
  5. L342
    specialize jordan_tuple_equal_refl (k)
  6. L343
    apply jordan_tuple_equal_refl
88Establish holdL344–349

Establish this local claim before using it. It is not an additional assumption. The following proof commands apply hscan right right.

  1. L344
    have hold : JordanTupleListed(z,c,k,B,C,D,E,j)Definitions: JordanTupleListed
  2. L345
    specialize hscan_right_right (z)
  3. L346
    apply hscan_right_right
  4. L347
    exact hzc_right
  5. L348
    exact hzb
  6. L349
    exact hzp
89Separate the logical casesL350–355

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

  1. L350
    cases hold
  2. L351
    cases hold_witness
  3. L352
    cases hold_witness_witness
  4. L353
    cases hold_witness_witness_witness
  5. L354
    cases hold_witness_witness_witness_right
  6. L355
    cases hold_witness_witness_witness_right_left
90Construct an explicit witnessL356–358

Supply the displayed value, then prove that it has the required property.

  1. L356
    exists x4
  2. L357
    exists x5
  3. L358
    exists x6
91Separate the logical casesL359–359

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

  1. L359
    split
92Use earlier factsL360–363

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

  1. L360
    specialize le_succ (S x4)
  2. L361
    specialize le_succ (j)
  3. L362
    apply le_succ
  4. L363
    exact hold_witness_witness_witness_left
93Separate the logical casesL364–365

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

  1. L364
    split
  2. L365
    split
94Use earlier factsL366–375

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

  1. L366
    specialize jordan_tuple_equal_entry (B)
  2. L367
    specialize jordan_tuple_equal_entry (C)
  3. L368
    specialize jordan_tuple_equal_entry (x)
  4. L369
    specialize jordan_tuple_equal_entry (x1)
  5. L370
    specialize jordan_tuple_equal_entry (j)
  6. L371
    specialize jordan_tuple_equal_entry (x4)
  7. L372
    specialize jordan_tuple_equal_entry (x5)
  8. L373
    apply jordan_tuple_equal_entry
  9. L374
    exact hext_witness_witness_witness_witness_left
  10. L375
    exact hold_witness_witness_witness_left
95Use earlier factsL376–385

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

  1. L376
    exact hold_witness_witness_witness_right_left_left
  2. L377
    specialize jordan_tuple_equal_entry (D)
  3. L378
    specialize jordan_tuple_equal_entry (E)
  4. L379
    specialize jordan_tuple_equal_entry (x2)
  5. L380
    specialize jordan_tuple_equal_entry (x3)
  6. L381
    specialize jordan_tuple_equal_entry (j)
  7. L382
    specialize jordan_tuple_equal_entry (x4)
  8. L383
    specialize jordan_tuple_equal_entry (x6)
  9. L384
    apply jordan_tuple_equal_entry
  10. L385
    exact hext_witness_witness_witness_witness_right_left
96Use earlier factsL386–388

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

  1. L386
    exact hold_witness_witness_witness_left
  2. L387
    exact hold_witness_witness_witness_right_left_right
  3. L388
    exact hold_witness_witness_witness_right_right

Library-wide reading audit

Original exact command ledger · 388 lines
  1. 0001intro k
  2. 0002intro n
  3. 0003intro c
  4. 0004intro t
  5. 0005intro B
  6. 0006intro C
  7. 0007intro D
  8. 0008intro E
  9. 0009intro j
  10. 0010intro hscan
  11. 0011intro hb
  12. 0012intro hp
  13. 0013intro hfresh
  14. 0014have hext : exists U V W X. ((forall jt_index_scanappendcodes jt_left_scanappendcodes jt_right_scanappendcodes. (exists jt_gap_scanappendcodesindex. jt_gap_scanappendcodesindex+S (jt_index_scanappendcodes)=(j)) -> (((exists fs_h_jt_scanappendcodesleft. fs_h_jt_scanappendcodesleft + S (jt_left_scanappendcodes) = S ((S (jt_index_scanappendcodes)) * C)) /\ exists fs_q_jt_scanappendcodesleft. B = fs_q_jt_scanappendcodesleft * S ((S (jt_index_scanappendcodes)) * C) + (jt_left_scanappendcodes))) -> (((exists fs_h_jt_scanappendcodesright. fs_h_jt_scanappendcodesright + S (jt_right_scanappendcodes) = S ((S (jt_index_scanappendcodes)) * V)) /\ exists fs_q_jt_scanappendcodesright. U = fs_q_jt_scanappendcodesright * S ((S (jt_index_scanappendcodes)) * V) + (jt_right_scanappendcodes))) -> jt_left_scanappendcodes=jt_right_scanappendcodes) /\ (((forall jt_index_scanappendscales jt_left_scanappendscales jt_right_scanappendscales. (exists jt_gap_scanappendscalesindex. jt_gap_scanappendscalesindex+S (jt_index_scanappendscales)=(j)) -> (((exists fs_h_jt_scanappendscalesleft. fs_h_jt_scanappendscalesleft + S (jt_left_scanappendscales) = S ((S (jt_index_scanappendscales)) * E)) /\ exists fs_q_jt_scanappendscalesleft. D = fs_q_jt_scanappendscalesleft * S ((S (jt_index_scanappendscales)) * E) + (jt_left_scanappendscales))) -> (((exists fs_h_jt_scanappendscalesright. fs_h_jt_scanappendscalesright + S (jt_right_scanappendscales) = S ((S (jt_index_scanappendscales)) * X)) /\ exists fs_q_jt_scanappendscalesright. W = fs_q_jt_scanappendscalesright * S ((S (jt_index_scanappendscales)) * X) + (jt_right_scanappendscales))) -> jt_left_scanappendscales=jt_right_scanappendscales) /\ (((((exists fs_h_jt_scanappendlastcode. fs_h_jt_scanappendlastcode + S (t) = S ((S (j)) * V)) /\ exists fs_q_jt_scanappendlastcode. U = fs_q_jt_scanappendlastcode * S ((S (j)) * V) + (t))) /\ (((exists fs_h_jt_scanappendlastscale. fs_h_jt_scanappendlastscale + S (c) = S ((S (j)) * X)) /\ exists fs_q_jt_scanappendlastscale. W = fs_q_jt_scanappendlastscale * S ((S (j)) * X) + (c))))))))
  15. 0015specialize jordan_tuple_outer_append_exists (B)
  16. 0016specialize jordan_tuple_outer_append_exists (C)
  17. 0017specialize jordan_tuple_outer_append_exists (D)
  18. 0018specialize jordan_tuple_outer_append_exists (E)
  19. 0019specialize jordan_tuple_outer_append_exists (j)
  20. 0020specialize jordan_tuple_outer_append_exists (t)
  21. 0021specialize jordan_tuple_outer_append_exists (c)
  22. 0022apply jordan_tuple_outer_append_exists
  23. 0023cases hext
  24. 0024cases hext_witness
  25. 0025cases hext_witness_witness
  26. 0026cases hext_witness_witness_witness
  27. 0027cases hext_witness_witness_witness_witness
  28. 0028cases hext_witness_witness_witness_witness_right
  29. 0029cases hext_witness_witness_witness_witness_right_right
  30. 0030cases hscan
  31. 0031cases hscan_right
  32. 0032have hcodesback : forall jt_index_scanappendcodesback jt_left_scanappendcodesback jt_right_scanappendcodesback. (exists jt_gap_scanappendcodesbackindex. jt_gap_scanappendcodesbackindex+S (jt_index_scanappendcodesback)=(j)) -> (((exists fs_h_jt_scanappendcodesbackleft. fs_h_jt_scanappendcodesbackleft + S (jt_left_scanappendcodesback) = S ((S (jt_index_scanappendcodesback)) * x1)) /\ exists fs_q_jt_scanappendcodesbackleft. x = fs_q_jt_scanappendcodesbackleft * S ((S (jt_index_scanappendcodesback)) * x1) + (jt_left_scanappendcodesback))) -> (((exists fs_h_jt_scanappendcodesbackright. fs_h_jt_scanappendcodesbackright + S (jt_right_scanappendcodesback) = S ((S (jt_index_scanappendcodesback)) * C)) /\ exists fs_q_jt_scanappendcodesbackright. B = fs_q_jt_scanappendcodesbackright * S ((S (jt_index_scanappendcodesback)) * C) + (jt_right_scanappendcodesback))) -> jt_left_scanappendcodesback=jt_right_scanappendcodesback
  33. 0033specialize jordan_tuple_equal_symm (B)
  34. 0034specialize jordan_tuple_equal_symm (C)
  35. 0035specialize jordan_tuple_equal_symm (x)
  36. 0036specialize jordan_tuple_equal_symm (x1)
  37. 0037specialize jordan_tuple_equal_symm (j)
  38. 0038apply jordan_tuple_equal_symm
  39. 0039exact hext_witness_witness_witness_witness_left
  40. 0040have hscalesback : forall jt_index_scanappendscalesback jt_left_scanappendscalesback jt_right_scanappendscalesback. (exists jt_gap_scanappendscalesbackindex. jt_gap_scanappendscalesbackindex+S (jt_index_scanappendscalesback)=(j)) -> (((exists fs_h_jt_scanappendscalesbackleft. fs_h_jt_scanappendscalesbackleft + S (jt_left_scanappendscalesback) = S ((S (jt_index_scanappendscalesback)) * x3)) /\ exists fs_q_jt_scanappendscalesbackleft. x2 = fs_q_jt_scanappendscalesbackleft * S ((S (jt_index_scanappendscalesback)) * x3) + (jt_left_scanappendscalesback))) -> (((exists fs_h_jt_scanappendscalesbackright. fs_h_jt_scanappendscalesbackright + S (jt_right_scanappendscalesback) = S ((S (jt_index_scanappendscalesback)) * E)) /\ exists fs_q_jt_scanappendscalesbackright. D = fs_q_jt_scanappendscalesbackright * S ((S (jt_index_scanappendscalesback)) * E) + (jt_right_scanappendscalesback))) -> jt_left_scanappendscalesback=jt_right_scanappendscalesback
  41. 0041specialize jordan_tuple_equal_symm (D)
  42. 0042specialize jordan_tuple_equal_symm (E)
  43. 0043specialize jordan_tuple_equal_symm (x2)
  44. 0044specialize jordan_tuple_equal_symm (x3)
  45. 0045specialize jordan_tuple_equal_symm (j)
  46. 0046apply jordan_tuple_equal_symm
  47. 0047exact hext_witness_witness_witness_witness_right_left
  48. 0048exists x
  49. 0049exists x1
  50. 0050exists x2
  51. 0051exists x3
  52. 0052split
  53. 0053intro i
  54. 0054intro hi
  55. 0055have hic : i=j \/ (exists jt_gap_appendindex. jt_gap_appendindex+S (i)=(j))
  56. 0056specialize finite_lt_succ_eq_or_lt (j)
  57. 0057specialize finite_lt_succ_eq_or_lt (i)
  58. 0058apply finite_lt_succ_eq_or_lt
  59. 0059exact hi
  60. 0060cases hic
  61. 0061exists t
  62. 0062exists c
  63. 0063split
  64. 0064split
  65. 0065rewrite hic_left
  66. 0066rewrite hic_left
  67. 0067exact hext_witness_witness_witness_witness_right_right_left
  68. 0068rewrite hic_left
  69. 0069rewrite hic_left
  70. 0070exact hext_witness_witness_witness_witness_right_right_right
  71. 0071split
  72. 0072exact hb
  73. 0073exact hp
  74. 0074have hvalue : exists b e. ((((((exists fs_h_jt_appendoldcode. fs_h_jt_appendoldcode + S (b) = S ((S (i)) * C)) /\ exists fs_q_jt_appendoldcode. B = fs_q_jt_appendoldcode * S ((S (i)) * C) + (b))) /\ (((exists fs_h_jt_appendoldscale. fs_h_jt_appendoldscale + S (e) = S ((S (i)) * E)) /\ exists fs_q_jt_appendoldscale. D = fs_q_jt_appendoldscale * S ((S (i)) * E) + (e))))) /\ (((forall jt_index_appendoldbound. (exists jt_gap_appendoldboundindex. jt_gap_appendoldboundindex+S (jt_index_appendoldbound)=(k)) -> exists jt_value_appendoldbound. ((((exists fs_h_jt_appendoldboundat. fs_h_jt_appendoldboundat + S (jt_value_appendoldbound) = S ((S (jt_index_appendoldbound)) * e)) /\ exists fs_q_jt_appendoldboundat. b = fs_q_jt_appendoldboundat * S ((S (jt_index_appendoldbound)) * e) + (jt_value_appendoldbound))) /\ (exists jt_gap_appendoldboundvalue. jt_gap_appendoldboundvalue+S (jt_value_appendoldbound)=(n)))) /\ (forall jt_divisor_appendoldprimitive. (exists jt_factor_appendoldprimitivemodulus. (n)=(jt_divisor_appendoldprimitive)*jt_factor_appendoldprimitivemodulus) -> (forall jt_index_appendoldprimitivecoordinates jt_value_appendoldprimitivecoordinates. (exists jt_gap_appendoldprimitivecoordinatesindex. jt_gap_appendoldprimitivecoordinatesindex+S (jt_index_appendoldprimitivecoordinates)=(k)) -> (((exists fs_h_jt_appendoldprimitivecoordinatesat. fs_h_jt_appendoldprimitivecoordinatesat + S (jt_value_appendoldprimitivecoordinates) = S ((S (jt_index_appendoldprimitivecoordinates)) * e)) /\ exists fs_q_jt_appendoldprimitivecoordinatesat. b = fs_q_jt_appendoldprimitivecoordinatesat * S ((S (jt_index_appendoldprimitivecoordinates)) * e) + (jt_value_appendoldprimitivecoordinates))) -> (exists jt_factor_appendoldprimitivecoordinatesdivides. (jt_value_appendoldprimitivecoordinates)=(jt_divisor_appendoldprimitive)*jt_factor_appendoldprimitivecoordinatesdivides)) -> jt_divisor_appendoldprimitive=1))))
  75. 0075specialize hscan_left (i)
  76. 0076apply hscan_left
  77. 0077exact hic_right
  78. 0078cases hvalue
  79. 0079cases hvalue_witness
  80. 0080cases hvalue_witness_witness
  81. 0081cases hvalue_witness_witness_right
  82. 0082cases hvalue_witness_witness_left
  83. 0083exists x4
  84. 0084exists x5
  85. 0085split
  86. 0086split
  87. 0087specialize jordan_tuple_equal_entry (B)
  88. 0088specialize jordan_tuple_equal_entry (C)
  89. 0089specialize jordan_tuple_equal_entry (x)
  90. 0090specialize jordan_tuple_equal_entry (x1)
  91. 0091specialize jordan_tuple_equal_entry (j)
  92. 0092specialize jordan_tuple_equal_entry (i)
  93. 0093specialize jordan_tuple_equal_entry (x4)
  94. 0094apply jordan_tuple_equal_entry
  95. 0095exact hext_witness_witness_witness_witness_left
  96. 0096exact hic_right
  97. 0097exact hvalue_witness_witness_left_left
  98. 0098specialize jordan_tuple_equal_entry (D)
  99. 0099specialize jordan_tuple_equal_entry (E)
  100. 0100specialize jordan_tuple_equal_entry (x2)
  101. 0101specialize jordan_tuple_equal_entry (x3)
  102. 0102specialize jordan_tuple_equal_entry (j)
  103. 0103specialize jordan_tuple_equal_entry (i)
  104. 0104specialize jordan_tuple_equal_entry (x5)
  105. 0105apply jordan_tuple_equal_entry
  106. 0106exact hext_witness_witness_witness_witness_right_left
  107. 0107exact hic_right
  108. 0108exact hvalue_witness_witness_left_right
  109. 0109split
  110. 0110exact hvalue_witness_witness_right_left
  111. 0111exact hvalue_witness_witness_right_right
  112. 0112split
  113. 0113intro i
  114. 0114intro h
  115. 0115intro b
  116. 0116intro e
  117. 0117intro d
  118. 0118intro f
  119. 0119intro hi
  120. 0120intro hh
  121. 0121intro hfirst
  122. 0122intro hsecond
  123. 0123intro heq
  124. 0124cases hfirst
  125. 0125cases hsecond
  126. 0126have hic : i=j \/ (exists jt_gap_appendfirstcase. jt_gap_appendfirstcase+S (i)=(j))
  127. 0127specialize finite_lt_succ_eq_or_lt (j)
  128. 0128specialize finite_lt_succ_eq_or_lt (i)
  129. 0129apply finite_lt_succ_eq_or_lt
  130. 0130exact hi
  131. 0131have hhc : h=j \/ (exists jt_gap_appendsecondcase. jt_gap_appendsecondcase+S (h)=(j))
  132. 0132specialize finite_lt_succ_eq_or_lt (j)
  133. 0133specialize finite_lt_succ_eq_or_lt (h)
  134. 0134apply finite_lt_succ_eq_or_lt
  135. 0135exact hh
  136. 0136cases hic
  137. 0137cases hhc
  138. 0138trans j
  139. 0139exact hic_left
  140. 0140symm
  141. 0141exact hhc_left
  142. 0142have hbval : b=t
  143. 0143specialize beta_at_unique (x)
  144. 0144specialize beta_at_unique (x1)
  145. 0145specialize beta_at_unique (j)
  146. 0146specialize beta_at_unique (b)
  147. 0147specialize beta_at_unique (t)
  148. 0148apply beta_at_unique
  149. 0149rewrite hic_left at hfirst_left
  150. 0150rewrite hic_left at hfirst_left
  151. 0151exact hfirst_left
  152. 0152exact hext_witness_witness_witness_witness_right_right_left
  153. 0153have heval : e=c
  154. 0154specialize beta_at_unique (x2)
  155. 0155specialize beta_at_unique (x3)
  156. 0156specialize beta_at_unique (j)
  157. 0157specialize beta_at_unique (e)
  158. 0158specialize beta_at_unique (c)
  159. 0159apply beta_at_unique
  160. 0160rewrite hic_left at hfirst_right
  161. 0161rewrite hic_left at hfirst_right
  162. 0162exact hfirst_right
  163. 0163exact hext_witness_witness_witness_witness_right_right_right
  164. 0164exfalso
  165. 0165apply hfresh
  166. 0166exists h
  167. 0167exists d
  168. 0168exists f
  169. 0169split
  170. 0170exact hhc_right
  171. 0171split
  172. 0172split
  173. 0173specialize jordan_tuple_equal_entry (x)
  174. 0174specialize jordan_tuple_equal_entry (x1)
  175. 0175specialize jordan_tuple_equal_entry (B)
  176. 0176specialize jordan_tuple_equal_entry (C)
  177. 0177specialize jordan_tuple_equal_entry (j)
  178. 0178specialize jordan_tuple_equal_entry (h)
  179. 0179specialize jordan_tuple_equal_entry (d)
  180. 0180apply jordan_tuple_equal_entry
  181. 0181exact hcodesback
  182. 0182exact hhc_right
  183. 0183exact hsecond_left
  184. 0184specialize jordan_tuple_equal_entry (x2)
  185. 0185specialize jordan_tuple_equal_entry (x3)
  186. 0186specialize jordan_tuple_equal_entry (D)
  187. 0187specialize jordan_tuple_equal_entry (E)
  188. 0188specialize jordan_tuple_equal_entry (j)
  189. 0189specialize jordan_tuple_equal_entry (h)
  190. 0190specialize jordan_tuple_equal_entry (f)
  191. 0191apply jordan_tuple_equal_entry
  192. 0192exact hscalesback
  193. 0193exact hhc_right
  194. 0194exact hsecond_right
  195. 0195rewrite hbval at heq
  196. 0196rewrite heval at heq
  197. 0197rewrite heval at heq
  198. 0198exact heq
  199. 0199cases hhc
  200. 0200have hdval : d=t
  201. 0201specialize beta_at_unique (x)
  202. 0202specialize beta_at_unique (x1)
  203. 0203specialize beta_at_unique (j)
  204. 0204specialize beta_at_unique (d)
  205. 0205specialize beta_at_unique (t)
  206. 0206apply beta_at_unique
  207. 0207rewrite hhc_left at hsecond_left
  208. 0208rewrite hhc_left at hsecond_left
  209. 0209exact hsecond_left
  210. 0210exact hext_witness_witness_witness_witness_right_right_left
  211. 0211have hfval : f=c
  212. 0212specialize beta_at_unique (x2)
  213. 0213specialize beta_at_unique (x3)
  214. 0214specialize beta_at_unique (j)
  215. 0215specialize beta_at_unique (f)
  216. 0216specialize beta_at_unique (c)
  217. 0217apply beta_at_unique
  218. 0218rewrite hhc_left at hsecond_right
  219. 0219rewrite hhc_left at hsecond_right
  220. 0220exact hsecond_right
  221. 0221exact hext_witness_witness_witness_witness_right_right_right
  222. 0222exfalso
  223. 0223apply hfresh
  224. 0224exists i
  225. 0225exists b
  226. 0226exists e
  227. 0227split
  228. 0228exact hic_right
  229. 0229split
  230. 0230split
  231. 0231specialize jordan_tuple_equal_entry (x)
  232. 0232specialize jordan_tuple_equal_entry (x1)
  233. 0233specialize jordan_tuple_equal_entry (B)
  234. 0234specialize jordan_tuple_equal_entry (C)
  235. 0235specialize jordan_tuple_equal_entry (j)
  236. 0236specialize jordan_tuple_equal_entry (i)
  237. 0237specialize jordan_tuple_equal_entry (b)
  238. 0238apply jordan_tuple_equal_entry
  239. 0239exact hcodesback
  240. 0240exact hic_right
  241. 0241exact hfirst_left
  242. 0242specialize jordan_tuple_equal_entry (x2)
  243. 0243specialize jordan_tuple_equal_entry (x3)
  244. 0244specialize jordan_tuple_equal_entry (D)
  245. 0245specialize jordan_tuple_equal_entry (E)
  246. 0246specialize jordan_tuple_equal_entry (j)
  247. 0247specialize jordan_tuple_equal_entry (i)
  248. 0248specialize jordan_tuple_equal_entry (e)
  249. 0249apply jordan_tuple_equal_entry
  250. 0250exact hscalesback
  251. 0251exact hic_right
  252. 0252exact hfirst_right
  253. 0253specialize jordan_tuple_equal_symm (b)
  254. 0254specialize jordan_tuple_equal_symm (e)
  255. 0255specialize jordan_tuple_equal_symm (t)
  256. 0256specialize jordan_tuple_equal_symm (c)
  257. 0257specialize jordan_tuple_equal_symm (k)
  258. 0258apply jordan_tuple_equal_symm
  259. 0259rewrite hdval at heq
  260. 0260rewrite hfval at heq
  261. 0261rewrite hfval at heq
  262. 0262exact heq
  263. 0263specialize hscan_right_left (i)
  264. 0264specialize hscan_right_left (h)
  265. 0265specialize hscan_right_left (b)
  266. 0266specialize hscan_right_left (e)
  267. 0267specialize hscan_right_left (d)
  268. 0268specialize hscan_right_left (f)
  269. 0269apply hscan_right_left
  270. 0270exact hic_right
  271. 0271exact hhc_right
  272. 0272split
  273. 0273specialize jordan_tuple_equal_entry (x)
  274. 0274specialize jordan_tuple_equal_entry (x1)
  275. 0275specialize jordan_tuple_equal_entry (B)
  276. 0276specialize jordan_tuple_equal_entry (C)
  277. 0277specialize jordan_tuple_equal_entry (j)
  278. 0278specialize jordan_tuple_equal_entry (i)
  279. 0279specialize jordan_tuple_equal_entry (b)
  280. 0280apply jordan_tuple_equal_entry
  281. 0281exact hcodesback
  282. 0282exact hic_right
  283. 0283exact hfirst_left
  284. 0284specialize jordan_tuple_equal_entry (x2)
  285. 0285specialize jordan_tuple_equal_entry (x3)
  286. 0286specialize jordan_tuple_equal_entry (D)
  287. 0287specialize jordan_tuple_equal_entry (E)
  288. 0288specialize jordan_tuple_equal_entry (j)
  289. 0289specialize jordan_tuple_equal_entry (i)
  290. 0290specialize jordan_tuple_equal_entry (e)
  291. 0291apply jordan_tuple_equal_entry
  292. 0292exact hscalesback
  293. 0293exact hic_right
  294. 0294exact hfirst_right
  295. 0295split
  296. 0296specialize jordan_tuple_equal_entry (x)
  297. 0297specialize jordan_tuple_equal_entry (x1)
  298. 0298specialize jordan_tuple_equal_entry (B)
  299. 0299specialize jordan_tuple_equal_entry (C)
  300. 0300specialize jordan_tuple_equal_entry (j)
  301. 0301specialize jordan_tuple_equal_entry (h)
  302. 0302specialize jordan_tuple_equal_entry (d)
  303. 0303apply jordan_tuple_equal_entry
  304. 0304exact hcodesback
  305. 0305exact hhc_right
  306. 0306exact hsecond_left
  307. 0307specialize jordan_tuple_equal_entry (x2)
  308. 0308specialize jordan_tuple_equal_entry (x3)
  309. 0309specialize jordan_tuple_equal_entry (D)
  310. 0310specialize jordan_tuple_equal_entry (E)
  311. 0311specialize jordan_tuple_equal_entry (j)
  312. 0312specialize jordan_tuple_equal_entry (h)
  313. 0313specialize jordan_tuple_equal_entry (f)
  314. 0314apply jordan_tuple_equal_entry
  315. 0315exact hscalesback
  316. 0316exact hhc_right
  317. 0317exact hsecond_right
  318. 0318exact heq
  319. 0319intro z
  320. 0320intro hz
  321. 0321intro hzb
  322. 0322intro hzp
  323. 0323have hzc : z=t \/ (exists jt_gap_appendcovercase. jt_gap_appendcovercase+S (z)=(t))
  324. 0324specialize finite_lt_succ_eq_or_lt (t)
  325. 0325specialize finite_lt_succ_eq_or_lt (z)
  326. 0326apply finite_lt_succ_eq_or_lt
  327. 0327exact hz
  328. 0328cases hzc
  329. 0329rewrite hzc_left
  330. 0330exists j
  331. 0331exists t
  332. 0332exists c
  333. 0333split
  334. 0334specialize le_refl (S j)
  335. 0335apply le_refl
  336. 0336split
  337. 0337split
  338. 0338exact hext_witness_witness_witness_witness_right_right_left
  339. 0339exact hext_witness_witness_witness_witness_right_right_right
  340. 0340specialize jordan_tuple_equal_refl (t)
  341. 0341specialize jordan_tuple_equal_refl (c)
  342. 0342specialize jordan_tuple_equal_refl (k)
  343. 0343apply jordan_tuple_equal_refl
  344. 0344have hold : exists jt_index_appendoldlisted jt_code_appendoldlisted jt_scale_appendoldlisted. ((exists jt_gap_appendoldlistedindex. jt_gap_appendoldlistedindex+S (jt_index_appendoldlisted)=(j)) /\ (((((((exists fs_h_jt_appendoldlistedcode. fs_h_jt_appendoldlistedcode + S (jt_code_appendoldlisted) = S ((S (jt_index_appendoldlisted)) * C)) /\ exists fs_q_jt_appendoldlistedcode. B = fs_q_jt_appendoldlistedcode * S ((S (jt_index_appendoldlisted)) * C) + (jt_code_appendoldlisted))) /\ (((exists fs_h_jt_appendoldlistedscale. fs_h_jt_appendoldlistedscale + S (jt_scale_appendoldlisted) = S ((S (jt_index_appendoldlisted)) * E)) /\ exists fs_q_jt_appendoldlistedscale. D = fs_q_jt_appendoldlistedscale * S ((S (jt_index_appendoldlisted)) * E) + (jt_scale_appendoldlisted))))) /\ (forall jt_index_appendoldlistedequal jt_left_appendoldlistedequal jt_right_appendoldlistedequal. (exists jt_gap_appendoldlistedequalindex. jt_gap_appendoldlistedequalindex+S (jt_index_appendoldlistedequal)=(k)) -> (((exists fs_h_jt_appendoldlistedequalleft. fs_h_jt_appendoldlistedequalleft + S (jt_left_appendoldlistedequal) = S ((S (jt_index_appendoldlistedequal)) * c)) /\ exists fs_q_jt_appendoldlistedequalleft. z = fs_q_jt_appendoldlistedequalleft * S ((S (jt_index_appendoldlistedequal)) * c) + (jt_left_appendoldlistedequal))) -> (((exists fs_h_jt_appendoldlistedequalright. fs_h_jt_appendoldlistedequalright + S (jt_right_appendoldlistedequal) = S ((S (jt_index_appendoldlistedequal)) * jt_scale_appendoldlisted)) /\ exists fs_q_jt_appendoldlistedequalright. jt_code_appendoldlisted = fs_q_jt_appendoldlistedequalright * S ((S (jt_index_appendoldlistedequal)) * jt_scale_appendoldlisted) + (jt_right_appendoldlistedequal))) -> jt_left_appendoldlistedequal=jt_right_appendoldlistedequal))))
  345. 0345specialize hscan_right_right (z)
  346. 0346apply hscan_right_right
  347. 0347exact hzc_right
  348. 0348exact hzb
  349. 0349exact hzp
  350. 0350cases hold
  351. 0351cases hold_witness
  352. 0352cases hold_witness_witness
  353. 0353cases hold_witness_witness_witness
  354. 0354cases hold_witness_witness_witness_right
  355. 0355cases hold_witness_witness_witness_right_left
  356. 0356exists x4
  357. 0357exists x5
  358. 0358exists x6
  359. 0359split
  360. 0360specialize le_succ (S x4)
  361. 0361specialize le_succ (j)
  362. 0362apply le_succ
  363. 0363exact hold_witness_witness_witness_left
  364. 0364split
  365. 0365split
  366. 0366specialize jordan_tuple_equal_entry (B)
  367. 0367specialize jordan_tuple_equal_entry (C)
  368. 0368specialize jordan_tuple_equal_entry (x)
  369. 0369specialize jordan_tuple_equal_entry (x1)
  370. 0370specialize jordan_tuple_equal_entry (j)
  371. 0371specialize jordan_tuple_equal_entry (x4)
  372. 0372specialize jordan_tuple_equal_entry (x5)
  373. 0373apply jordan_tuple_equal_entry
  374. 0374exact hext_witness_witness_witness_witness_left
  375. 0375exact hold_witness_witness_witness_left
  376. 0376exact hold_witness_witness_witness_right_left_left
  377. 0377specialize jordan_tuple_equal_entry (D)
  378. 0378specialize jordan_tuple_equal_entry (E)
  379. 0379specialize jordan_tuple_equal_entry (x2)
  380. 0380specialize jordan_tuple_equal_entry (x3)
  381. 0381specialize jordan_tuple_equal_entry (j)
  382. 0382specialize jordan_tuple_equal_entry (x4)
  383. 0383specialize jordan_tuple_equal_entry (x6)
  384. 0384apply jordan_tuple_equal_entry
  385. 0385exact hext_witness_witness_witness_witness_right_left
  386. 0386exact hold_witness_witness_witness_left
  387. 0387exact hold_witness_witness_witness_right_left_right
  388. 0388exact hold_witness_witness_witness_right_right