stdlib.bus

/*
Language built-ins:
atom IMPLIES;
syntax (a b) = a b, precedence 10000, associativity left;
*/

syntax (a -> b) = IMPLIES a b, precedence 100, associativity right;

assume proofsyntax
	ARGS : (
		( (first:IDENT) (rest:ARGS) ),
		( ),
	),
	
	(
		define (funcname:IDENT) (args:ARGS) = (expr) ;
		(innerproof)
	) = (
		atom ((funcname));
		syntaxassume _def_((funcname))_ltr proves ((make_forany args)) ((funcname)) ((args)) -> ( ((expr)) );
		syntaxassume _def_((funcname))_rtl proves ((make_forany args)) ( ((expr)) ) -> ((funcname)) ((args));
		((innerproof))
	),
	
	make_forany_3 (args:ARGS.0) = ( , ((args.first)) ((make_forany_3 args.rest)) ),
	make_forany_3 (args:ARGS.1) = ( ),
	make_forany_2 (args:ARGS.0) = ( ((args.first)) ((make_forany_3 args.rest)) ),
	make_forany_2 (args:ARGS.1) = ( ),
	make_forany   (args:ARGS.0) = ( forany ((make_forany_2 args)) : ),
	make_forany   (args:ARGS.1) = ( ),
;

proofsyntax
	(
		unwrap (funcname:IDENT) (innerproof)
	) = (
		_def_((funcname))_ltr < ( ((innerproof)) )
	),
;

proofsyntax
	(
		wrap (funcname:IDENT) (innerproof)
	) = (
		_def_((funcname))_rtl < ( ((innerproof)) )
	),
;


assume todo proves forany a: a;

define FALSE = forany a: a;
syntax (!a) = a -> FALSE, precedence 20000, associativity right;
require false_proves_anything proves forany a: FALSE -> a  by ( assume f proves FALSE; unwrap FALSE f );
assume not_not_impl proves forany a: ((a -> FALSE) -> FALSE) -> a;

atom AND;
syntax (a && b) = AND a b, precedence 150, associativity left;
assume and_left  proves forany a,b: (a && b) -> a;
assume and_right proves forany a,b: (a && b) -> b;
assume impl_impl_and proves forany a,b: a -> b -> (a && b);

define eq x y = (x -> y) && (y -> x);
syntax (a == b) = eq a b, precedence 160, associativity noassoc;
syntax (a != b) = !(a == b), precedence 160, associativity noassoc;
assume func_eq proves forany f,g: (f == g) == (forany x,y: x == y -> f x == g y);

define or a b = !(!a && !b);
syntax (a || b) = or a b, precedence 150, associativity left;

define xor a b = (a || b) && !(a && b);
syntax (a ^^ b) = xor a b, precedence 150, associativity left;



atom HAS_MEMBER;
syntax (a : b)  = HAS_MEMBER b a, precedence 200, associativity noassoc;

assume proofsyntax
	(
		enum (enumname:IDENT) {
			(vallist:VAL_LIST)
		};
		(innerproof)
	) = (
		atom ((enumname));
		((make_atoms vallist))
		((make_has_members enumname vallist))
		((make_is_one_of enumname vallist))
		((make_inequalities enumname vallist))
		((innerproof))
	),
	
	CONDITION : (
		( | (condition) ),
		( ),
	),
	
	VAL_ITEM_ARGS : (
		( (first:IDENT) (rest:VAL_ITEM_ARGS) ),
		( ),
	),
	VAL_LIST : (
		( (first_name:IDENT) (first_args:VAL_ITEM_ARGS) (first_condition:CONDITION) , (rest:VAL_LIST) ),
		( ),
		( , ),
	),
	
	
	make_atoms (vallist:VAL_LIST.0) = (
		atom ((vallist.first_name));
		((make_atoms vallist.rest))
	),
	make_atoms (vallist:VAL_LIST.1) = ( ),
	make_atoms (vallist:VAL_LIST.2) = ( ),
	
	
	make_inequality__arg_list enumname name (args:VAL_ITEM_ARGS.0) = (
		_((enumname))_((name))_((args.first))
		((make_inequality__arg_list enumname name args.rest))
	),
	make_inequality__arg_list enumname name (args:VAL_ITEM_ARGS.1) = ( ),
	make_inequality__forany_3 enumname first_name (first_args:VAL_ITEM_ARGS.1) second_name (second_args:VAL_ITEM_ARGS.1) = ( ),
	make_inequality__forany_3 enumname first_name (first_args:VAL_ITEM_ARGS.1) second_name (second_args:VAL_ITEM_ARGS.0) = (
		, _((enumname))_((second_name))_((second_args.first))
		((make_inequality__forany_3 enumname first_name first_args second_name second_args.rest))
	),
	make_inequality__forany_3 enumname first_name (first_args:VAL_ITEM_ARGS.0) second_name (second_args:VAL_ITEM_ARGS) = (
		, _((enumname))_((first_name))_((first_args.first))
		((make_inequality__forany_3 enumname first_name first_args.rest second_name second_args))
	),
	make_inequality__forany enumname first_name (first_args:VAL_ITEM_ARGS.1) second_name (second_args:VAL_ITEM_ARGS.1) = ( ),
	make_inequality__forany enumname first_name (first_args:VAL_ITEM_ARGS.0) second_name second_args = (
		forany _((enumname))_((first_name))_((first_args.first))
		((make_inequality__forany_3 enumname first_name first_args.rest second_name second_args))
		:
	),
	make_inequality__forany enumname first_name first_args second_name (second_args:VAL_ITEM_ARGS.0) = (
		forany _((enumname))_((second_name))_((second_args.first))
		((make_inequality__forany_3 enumname first_name first_args second_name second_args.rest))
		:
	),
	make_inequality enumname first_name first_args first_condition second_name second_args second_condition = (
		syntaxassume _neq_((enumname))_((first_name))_((second_name))
		proves
			((make_inequality__forany enumname first_name first_args second_name second_args))
			((make_inequality_condition first_condition  enumname first_name first_args))
			((make_inequality_condition second_condition enumname second_name second_args))
			((first_name))
			((make_inequality__arg_list enumname first_name first_args))
		!=
			((second_name))
			((make_inequality__arg_list enumname second_name second_args))
		;
	),
	make_inequalities_2 enumname first_name first_args first_condition (vallist:VAL_LIST.0) = (
		((make_inequality enumname first_name first_args first_condition vallist.first_name vallist.first_args vallist.first_condition))
		((make_inequalities_2 enumname first_name first_args first_condition vallist.rest))
	),
	make_inequalities_2 enumname first_name first_args first_condition (vallist:VAL_LIST.1) = ( ),
	make_inequalities_2 enumname first_name first_args first_condition (vallist:VAL_LIST.2) = ( ),
	make_inequalities enumname (vallist:VAL_LIST.0) = (
		((make_inequalities_2 enumname vallist.first_name vallist.first_args vallist.first_condition vallist.rest))
	),
	make_inequalities enumname (vallist:VAL_LIST.1) = ( ),
	make_inequalities enumname (vallist:VAL_LIST.2) = ( ),
	
	replace_arg_names input enumname name (args:VAL_ITEM_ARGS.0) = ( ((replace_ident args.first (concat "_" enumname "_" name "_" args.first) (replace_arg_names input enumname name args.rest))) ),
	replace_arg_names input enumname name (args:VAL_ITEM_ARGS.1) = ( ((input)) ),
	
	make_inequality_condition (condition:CONDITION.0) enumname name args = ( ( ((replace_arg_names condition.condition enumname name args)) ) -> ),
	make_inequality_condition (condition:CONDITION.1) enumname name args = ( ),
	
	make_forany_2 (args:VAL_ITEM_ARGS.0) = ( , ((args.first)) ((make_forany_2 args.rest)) ),
	make_forany_2 (args:VAL_ITEM_ARGS.1) = ( ),
	make_forany (args:VAL_ITEM_ARGS.0) = (
		forany ((args.first)) ((make_forany_2 args.rest)) :
	),
	make_forany (args:VAL_ITEM_ARGS.1) = ( ),
	
	make_has_member_maybe_condition (condition:CONDITION.0) = ( ( ((condition.condition)) ) -> ),
	make_has_member_maybe_condition (condition:CONDITION.1) = ( ),
	make_has_members enumname (vallist:VAL_LIST.0) = (
		syntaxassume _((enumname))_has_member_((vallist.first_name)) proves ((make_forany vallist.first_args)) ((make_has_member_maybe_condition vallist.first_condition)) HAS_MEMBER ((enumname)) ( ((vallist.first_name)) ((vallist.first_args)) );
		((make_has_members enumname vallist.rest))
	),
	make_has_members enumname (vallist:VAL_LIST.1) = ( ),
	
	make_is_one_of__maybe_condition (condition:CONDITION.0) = ( ( ((condition.condition)) ) && ),
	make_is_one_of__maybe_condition (condition:CONDITION.1) = ( ),
	make_is_one_of_4 (vallist:VAL_LIST.0) = (
		( ( ((make_forany vallist.first_args)) ( ((make_is_one_of__maybe_condition vallist.first_condition)) xxx == ((vallist.first_name)) ((vallist.first_args)) )  -> FALSE ) -> FALSE )
	),
	make_is_one_of_3 (vallist:VAL_LIST.0) = ( || ((make_is_one_of_4 vallist)) ((make_is_one_of_3 vallist.rest)) ),
	make_is_one_of_3 (vallist:VAL_LIST.1) = ( ),
	make_is_one_of_2 (vallist:VAL_LIST.0) = (
		((make_is_one_of_4 vallist)) ((make_is_one_of_3 vallist.rest))
	),
	make_is_one_of enumname (vallist:VAL_LIST.0) = (
		syntaxassume _((enumname))_is_one_of proves forany xxx: (HAS_MEMBER UINT xxx) -> ( ((make_is_one_of_2 vallist)) ) ;
	),
;




assume proofsyntax
	(
		define (funcname:IDENT) {
			(branch_list:BRANCH_LIST) ;
			(inequality_proofs:INEQUALITY_PROOFS) ;
			(self_inequality_proofs:INEQUALITY_PROOFS) ;
		};
		(innerproof)
	) = (
		atom ((funcname));
		((make_equalities funcname branch_list "x"))
		scope (
			((make_requirements funcname branch_list inequality_proofs "x"))
			((make_self_requirements funcname branch_list self_inequality_proofs "x"))
		);
		((innerproof))
	),
	INEQUALITY_PROOFS : (
		( (proof) , (rest:INEQUALITY_PROOFS) ),
		( (proof) ),
	),
	CONDITION : (
		( | (condition) ),
		( ),
	),
	BRANCH_LIST : (
		( (branch:BRANCH) , (rest:BRANCH_LIST) ),
		( (branch:BRANCH) ),
	),
	BRANCH : (
		( (vars:BRANCH_VARS) : (lhs_args_maybe:LHS_ARGS_MAYBE) (condition:CONDITION) = (rhs) ),
		( (lhs_args_maybe:LHS_ARGS_MAYBE) (condition:CONDITION) = (rhs) ),
	),
	BRANCH_VARS : (
		( (first:IDENT) , (rest:BRANCH_VARS) ),
		( (first:IDENT) ),
	),
	LHS_ARG : (
		( (ident:IDENT) ),
		( (paren:PAREN) ),
	),
	LHS_ARGS_MAYBE : (
		( (lhs_args:LHS_ARGS) ),
		( ),
	),
	LHS_ARGS : (
		( (arg:LHS_ARG) (rest:LHS_ARGS) ),
		( (arg:LHS_ARG) ),
	),
	make_equalities funcname (branch_list:BRANCH_LIST.0) counter = (
		((make_equality funcname branch_list.branch counter))
		((make_equalities funcname branch_list.rest (concat counter "x")))
	),
	make_equalities funcname (branch_list:BRANCH_LIST.1) counter = (
		((make_equality funcname branch_list.branch counter))
	),
	make_condition (condition:CONDITION.0) = ( ( ((condition.condition)) ) -> ),
	make_condition (condition:CONDITION.1) = ( ),
	make_equality funcname (branch:BRANCH.0) counter = (
		syntaxassume _def_((funcname))_((counter)) proves forany ((branch.vars)) : ((make_condition branch.condition)) ((funcname)) ((branch.lhs_args_maybe)) == ( ((branch.rhs)) );
	),
	make_equality funcname (branch:BRANCH.1) counter = (
		syntaxassume _def_((funcname))_((counter)) proves ((make_condition branch.condition)) ((funcname)) ((branch.lhs_args_maybe)) == ( ((branch.rhs)) );
	),
	
	make_requirements_3 funcname (branch_list_1:BRANCH_LIST.0) (branch_list_2:BRANCH_LIST.0) inequality_proofs counter = (
		((make_requirement funcname branch_list_1.branch branch_list_2.branch inequality_proofs.proof counter))
		((make_requirements_3 funcname branch_list_1 branch_list_2.rest inequality_proofs.rest (concat counter "x")))
	),
	make_requirements_3 funcname (branch_list_1:BRANCH_LIST.0) (branch_list_2:BRANCH_LIST.1) (inequality_proofs:INEQUALITY_PROOFS.0) counter = (
		((make_requirement funcname branch_list_1.branch branch_list_2.branch inequality_proofs.proof counter))
		((make_requirements funcname branch_list_1.rest inequality_proofs.rest (concat counter "x")))
	),
	make_requirements_3 funcname (branch_list_1:BRANCH_LIST.0) (branch_list_2:BRANCH_LIST.1) (inequality_proofs:INEQUALITY_PROOFS.1) counter = (
		((make_requirement funcname branch_list_1.branch branch_list_2.branch inequality_proofs.proof counter))
	),
	// TODO error when there are too many proofs
	make_requirements funcname (branch_list_1:BRANCH_LIST.1) inequality_proofs counter = ( ),
	make_requirements funcname (branch_list_1:BRANCH_LIST.0) inequality_proofs counter = (
		((make_requirements_3 funcname branch_list_1 branch_list_1.rest inequality_proofs counter))
	),
	make_requirements_3 funcname (branch_list_1:BRANCH_LIST.1) branch_list_2 inequality_proofs = ( ),
	
	make_requirement_forany_2 (vars:BRANCH_VARS.0) suffix = ( ((vars.first))((suffix)) , ((make_requirement_forany_2 vars.rest suffix)) ),
	make_requirement_forany_2 (vars:BRANCH_VARS.1) suffix = ( ((vars.first))((suffix)) ),
	make_requirement_forany (first:BRANCH.0) (second:BRANCH.0) = (
		forany ((make_requirement_forany_2 first.vars "_1")) , ((make_requirement_forany_2 second.vars "_2")) :
	),
	make_requirement_forany (first:BRANCH.0) (second:BRANCH.1) = (
		forany ((make_requirement_forany_2 first.vars "_1")) :
	),
	make_requirement_forany (first:BRANCH.1) (second:BRANCH.0) = (
		forany ((make_requirement_forany_2 second.vars "_2")) :
	),
	make_requirement_forany (first:BRANCH.1) (second:BRANCH.1) = ( ),
	make_requirement funcname (first:BRANCH) (second:BRANCH) inequality_proof counter = (
		require _def_((funcname))_((counter)) proves ((make_requirement_forany first second)) ((make_inequality_condition first "_1")) ((make_inequality_condition second "_2")) ((make_inequalities first second first.lhs_args_maybe.lhs_args second.lhs_args_maybe.lhs_args))
			by ((inequality_proof)) ;
	),
	
	make_forany_var_replacements (a:BRANCH_VARS.0) suffix expr
		= ( ((replace_ident a.first (concat a.first suffix) (make_forany_var_replacements a.rest suffix expr))) ),
	make_forany_var_replacements (a:BRANCH_VARS.1) suffix expr
		= ( ((replace_ident a.first (concat a.first suffix) expr)) ),
	
	make_inequality_condition_without_vars (condition:CONDITION.0) = ( ( ((condition.condition)) ) -> ),
	make_inequality_condition_without_vars (condition:CONDITION.1) = ( ),
	make_inequality_condition_with_vars (vars:BRANCH_VARS) suffix (condition:CONDITION.0) = ( ( ((make_forany_var_replacements vars suffix condition.condition)) ) -> ),
	make_inequality_condition_with_vars (vars:BRANCH_VARS) suffix (condition:CONDITION.1) = ( ),
	make_inequality_condition (branch:BRANCH.0) suffix = ( ((make_inequality_condition_with_vars branch.vars suffix branch.condition)) ),
	make_inequality_condition (branch:BRANCH.1) suffix = ( ((make_inequality_condition_without_vars branch.condition)) ),
	
	arg_with_var_replacements (branch:BRANCH.0) suffix (arg:LHS_ARG) = ( ( ((make_forany_var_replacements branch.vars suffix arg)) ) ),
	arg_with_var_replacements (branch:BRANCH.1) suffix (arg:LHS_ARG) = ( ( ((arg)) ) ),
	
 	make_inequality (a:BRANCH) (b:BRANCH) (first_arg:LHS_ARG) (second_arg:LHS_ARG) = (
		((arg_with_var_replacements a "_1" first_arg)) != ((arg_with_var_replacements b "_2" second_arg))
	),
	
	make_inequalities (a:BRANCH) (b:BRANCH) (first_args:LHS_ARGS.0) (second_args:LHS_ARGS.0) = (
		((make_inequality a b first_args.arg second_args.arg)) || ((make_inequalities a b first_args.rest second_args.rest))
	),
	make_inequalities (a:BRANCH) (b:BRANCH) (first_args:LHS_ARGS.1) (second_args:LHS_ARGS.1) = (
		((make_inequality a b first_args.arg second_args.arg))
	),
	make_inequalities (a:BRANCH) (b:BRANCH) (first_args:LHS_ARGS.1) (second_args:LHS_ARGS.0) = ( ((error "Define branches must have same amount of arguments")) ),
	make_inequalities (a:BRANCH) (b:BRANCH) (first_args:LHS_ARGS.0) (second_args:LHS_ARGS.1) = ( ((error "Define branches must have same amount of arguments")) ),
	
	
	
	
	
	
	
	
	make_self_requirement_forany_3 (vars:BRANCH_VARS.0) = ( ((vars.first))_1 != ((vars.first))_2 -> ((make_self_requirement_forany_3 vars.rest)) ),
	make_self_requirement_forany_3 (vars:BRANCH_VARS.1) = ( ((vars.first))_1 != ((vars.first))_2 -> ),
	make_self_requirement_forany_2 (vars:BRANCH_VARS.0) suffix = ( ((vars.first))((suffix)) , ((make_self_requirement_forany_2 vars.rest suffix)) ),
	make_self_requirement_forany_2 (vars:BRANCH_VARS.1) suffix = ( ((vars.first))((suffix)) ),
	make_self_requirement_forany (branch:BRANCH.0) = ( forany ((make_self_requirement_forany_2 branch.vars "_1")) , ((make_self_requirement_forany_2 branch.vars "_2")) : ((make_self_requirement_forany_3 branch.vars)) ),
	make_self_requirement_2 (lhs_args:LHS_ARGS.0) (vars:BRANCH_VARS) = ( ((make_forany_var_replacements vars "_1" lhs_args.arg)) != ((make_forany_var_replacements vars "_2" lhs_args.arg)) || ((make_self_requirement_2 lhs_args.rest vars)) ),
	make_self_requirement_2 (lhs_args:LHS_ARGS.1) (vars:BRANCH_VARS) = ( ((make_forany_var_replacements vars "_1" lhs_args.arg)) != ((make_forany_var_replacements vars "_2" lhs_args.arg)) ),
	make_self_requirement_conditions (condition:CONDITION.0) (vars:BRANCH_VARS) = (
		( ((make_forany_var_replacements vars "_1" condition.condition)) ) -> ( ((make_forany_var_replacements vars "_2" condition.condition)) ) -> 
	),
	make_self_requirement_conditions (condition:CONDITION.1) (vars:BRANCH_VARS) = ( ),
	make_self_requirement funcname (branch:BRANCH.0) proof counter = (
		require _def_((funcname))_self_((counter)) proves ((make_self_requirement_forany branch)) ((make_self_requirement_conditions branch.condition branch.vars)) ((make_self_requirement_2 branch.lhs_args_maybe.lhs_args branch.vars)) by ((proof));
	),
	
	make_self_requirements_2 funcname (branch:BRANCH.0) (branch_list:BRANCH_LIST) (self_inequality_proofs:INEQUALITY_PROOFS.0) counter = (
		((make_self_requirement funcname branch self_inequality_proofs.proof counter))
		((make_self_requirements funcname branch_list self_inequality_proofs.rest (concat counter "x")))
	),
	make_self_requirements_2 funcname (branch:BRANCH.0) (branch_list:BRANCH_LIST) (self_inequality_proofs:INEQUALITY_PROOFS.1) counter = (
		((error "Too few self-inequality proofs"))
	),
	make_self_requirements_2 funcname (branch:BRANCH.1) (branch_list:BRANCH_LIST) (self_inequality_proofs:INEQUALITY_PROOFS) counter = (
		((make_self_requirements funcname branch_list self_inequality_proofs counter))
	),
	
	make_self_requirements funcname (branch_list:BRANCH_LIST.0) (self_inequality_proofs:INEQUALITY_PROOFS) counter = (
		((make_self_requirements_2 funcname branch_list.branch branch_list.rest self_inequality_proofs counter))
	),
	make_self_requirements funcname (branch_list:BRANCH_LIST.1) (self_inequality_proofs:INEQUALITY_PROOFS.1) counter = (
		((make_self_requirement funcname branch_list.branch self_inequality_proofs.proof counter))
	),
	make_self_requirements funcname (branch_list:BRANCH_LIST.1) (self_inequality_proofs:INEQUALITY_PROOFS.0) counter = (
		((error "Too many self-inequality proofs"))
	),
;

proofsyntax
	( unwrap2 (funcname:IDENT).(counter:IDENT) (innerproof) ) =
	( ( _def_((funcname))_((counter)) > eq_ltr ) < ( ((innerproof)) ) );

proofsyntax
	( wrap2 (funcname:IDENT).(counter:IDENT) (innerproof) ) =
	( ( _def_((funcname))_((counter)) > eq_rtl) < ( ((innerproof)) ) );

proofsyntax
	( defeq2 (funcname:IDENT).(counter:IDENT) ) =
	( _def_((funcname))_((counter)) );

enum UINT {
	UINT_ZERO,
	UINT_SUCC prev | prev : UINT,
};





require impl_same proves forany a: a -> a
by (
	forany a:
	assume A proves a;
	A
);

require impl_reverse proves forany a,b: (a -> b) -> (!b -> !a)
by (
	forany a,b:
	assume AB proves a -> b;
	assume BF proves b -> FALSE; // !b
	assume A proves a;
	(A > AB) > BF
);

require impl_not_not proves forany a: a -> !!a
by (
	forany a:
	assume A proves a;
	assume NA proves (a -> FALSE);
	A > NA
);

require not_not_eq proves forany a: ((a -> FALSE) -> FALSE) == a
by (
	wrap eq (impl_impl_and < not_not_impl < impl_not_not)
);

require left_impl_not_right__not_and proves forany a,b: (a -> !b) -> !(a && b)
by (
	forany a,b:
	assume a_nb proves a -> !b;
	assume a_and_b proves a && b;
	a_nb < (a_and_b > and_left) < (a_and_b > and_right)
);

require right_impl_not_left__not_and proves forany a,b: (b -> !a) -> !(a && b)
by (
	forany a,b:
	assume b_na proves b -> !a;
	assume a_and_b proves a && b;
	b_na < (a_and_b > and_right) < (a_and_b > and_left)
);

require yay_or_nay proves forany a: a || !a
by (
	forany aa:
	require temp proves !(!aa && !!aa)
	by (substitute a=!aa in impl_not_not) > left_impl_not_right__not_and;
	wrap or temp
);

require or__not_left__right proves forany a,b: a || b  ->  !a -> b
by (
	forany a,b:
	assume A_OR_B proves a || b;
	assume NA proves !a;
	require A_OR_B_ proves !(!a && !b)
	by unwrap or A_OR_B;
	
	not_not_impl < (
		// Goal:
		// !!b
		assume NB proves !b;
		A_OR_B_ < (NB > NA > impl_impl_and)
	)
);

require or__not_right__left proves forany a,b: a || b  ->  !b -> a
by (
	forany a,b:
	assume A_OR_B proves a || b;
	assume NB proves !b;
	require A_OR_B_ proves !(!a && !b)
	by unwrap or A_OR_B;
	
	not_not_impl < (
		// Goal:
		// !!a
		assume NA proves !a;
		A_OR_B_ < (NB > NA > impl_impl_and)
	)
);

require impl_weaken proves forany a,b: a -> (b -> a)
by (
	forany a,b:
	assume A proves a;
	assume _ proves b;
	A
);

require impl_trans proves forany a,b,c: (a -> b) -> (b -> c) -> (a -> c)
by (
	forany a,b,c:
	assume AB proves a -> b;
	assume BC proves b -> c;
	assume A proves a;
	(A > AB) > BC
);

require impl_impl_impl__and_impl proves forany a,b,c: (a -> b -> c) -> (a && b -> c)
by (
	forany a,b,c:
	assume abc proves a -> b -> c;
	assume ab proves a && b;
	(ab > and_right) > (ab > and_left) > abc
);

require impl_reverse_back proves forany a,b: (!b -> !a) -> (a -> b)
by (
	forany a,b:
	assume NB_NA proves !b -> !a;
	assume A proves a;
	((A > impl_not_not) > (NB_NA > impl_reverse)) > not_not_impl
);



require or_cases proves forany a,b,c: a || b  ->  (a -> c)  ->  (b -> c)  ->  c
by (
	forany a,b,c:
	assume ab proves a || b;
	assume a_c proves a -> c;
	assume b_c proves b -> c;
	
	require nc_na proves !c -> !a   by  a_c > impl_reverse;
	require nc_nb proves !c -> !b   by  b_c > impl_reverse;
	
	not_not_impl < (
		// Goal:
		// !!c
		
		assume nc proves !c;
		
		// Goal:
		// FALSE
		
		(unwrap or ab) < (
			// Goal:
			// !a && !b
			
			impl_impl_and < (nc > nc_na) < (nc > nc_nb)
		)
	)
);




require by_contradiction proves forany a: (a -> !a) -> !a
by (
	forany a:
	assume A_NA proves a -> !a;
	assume A proves a;
	A > (A > A_NA)
);

require by_contradiction_2 proves forany a: (!a -> a) -> a
by (
	forany a:
	assume NA_A proves !a -> a;
	NA_A > impl_same > yay_or_nay > or_cases
);















require eq_same proves forany a: a == a
by (
	wrap eq (impl_same > impl_same > impl_impl_and)
);









require wrap_in_func_impl proves forany f,a,b: a == b  ->  (f a) == (f b)
by (
	forany f,a,b:
	assume AB proves eq a b;
	AB > eq_same > ((unwrap eq func_eq) > and_left)
);

require lhs_rhs_eq proves forany f,g,a,b: f == g  ->  a == b  ->  (f a) == (g b)
by (
	(unwrap eq func_eq) > and_left
);

require bin_sub_left_impl proves forany f,a,b,x: a == b  ->  f a x  ->  f b x
by (
	forany f,a,b,x:
	assume AB proves eq a b;
	assume FAX proves f a x;
	
	require FA_FB proves eq (f a) (f b)   by   AB > eq_same > lhs_rhs_eq;
	
	FAX > ((unwrap eq (eq_same > FA_FB > lhs_rhs_eq)) > and_left)
);

require bin_sub_left_eq proves forany f,a,b,x: a == b  ->  (f a x) == (f b x)
by (
	forany f,a,b,x:
	assume AB proves eq a b;
	eq_same > (AB > (substitute f=f in wrap_in_func_impl)) > lhs_rhs_eq
);

require bin_sub_right_impl proves forany f,a,b,x: a == b  ->  f x a  ->  f x b
by (
	forany f,a,b,x:
	assume AB proves eq a b;
	assume FXA proves f x a;
	FXA > (unwrap eq (AB > eq_same > lhs_rhs_eq) > and_left)
);

require bin_sub_right_eq proves forany f,a,b,x: a == b  ->  (f x a) == (f x b)
by (
	forany f,x,a,b:
	assume AB proves eq a b;
	AB > (substitute a=(f x) in eq_same) > lhs_rhs_eq
);







require un_sub_arg proves forany f,a,b: a == b  ->  (f a) == (f b)
by wrap_in_func_impl;

require wrap_in_bin_func_lhs proves forany f,a,b,c: a == b  ->  (f a c) == (f b c)
by (
	forany f,a,b,c:
	assume ab proves eq a b;
	(substitute a=(f a c) in eq_same) > (ab > bin_sub_left_eq) > bin_sub_right_impl
);

require wrap_in_bin_func_rhs proves forany f,a,b,c: a == b  ->  (f c a) == (f c b)
by (
	forany f,a,b,c:
	assume ab proves eq a b;
	(substitute a=(f c a) in eq_same) > (ab > bin_sub_right_eq) > bin_sub_right_impl
);





require and_comm_impl proves forany a,b: a && b  ->  b && a
by (
	forany a,b:
	assume AB proves AND a b;
	(AB > and_left) > ((AB > and_right) > impl_impl_and)
);

require and_comm_eq proves forany a,b: (a && b) == (b && a)
by wrap eq ( impl_impl_and < and_comm_impl < and_comm_impl );

require not_left__not_and proves forany a,b: !a -> !(a && b)
by (
	forany a,b:
	assume NA proves a -> FALSE;
	assume AB proves AND a b;
	(AB > and_left) > NA
);

require not_right__not_and proves forany a,b: !b -> !(a && b)
by (
	forany a,b:
	assume NB proves b -> FALSE;
	assume AB proves AND a b;
	(AB > and_right) > NB
);

require and_same proves forany a: (a && a) == a
by (
	forany a:
	require ltr proves (AND a a) -> a by and_left;
	require rtl proves a -> (AND a a) by (
		assume A proves a;
		A > A > impl_impl_and
	);
	wrap eq (rtl > ltr > impl_impl_and)
);

require not_and__left_impl_not_right proves forany a,b: !(a && b) -> a -> !b
by (
	forany a,b:
	assume not_ab proves !(a && b);
	assume A proves a;
	assume B proves b;
	not_ab < (impl_impl_and < A < B)
);

require not_and__right_impl_not_left proves forany a,b: !(a && b) -> b -> !a
by (
	forany a,b:
	assume not_ab proves !(a && b);
	assume B proves b;
	assume A proves a;
	not_ab < (impl_impl_and < A < B)
);








require eq_ltr proves forany a,b: a == b -> (a -> b)
by (
	forany a,b:
	assume AeqB proves a == b;
	(unwrap eq AeqB) > and_left
);

require eq_rtl proves forany a,b: a == b -> (b -> a)
by (
	forany a,b:
	assume AeqB proves a == b;
	(unwrap eq AeqB) > and_right
);

require eq_comm proves forany a,b: a == b -> b == a
by (
	forany a,b:
	assume A_eq_B proves a == b;
	wrap eq ((unwrap eq A_eq_B) > and_comm_impl)
);

require eq_comm_eq proves forany a,b: (a == b) == (b == a)
by (
	forany a,b:
	wrap eq (impl_impl_and < eq_comm < eq_comm)
);

require eq_trans proves forany a,b,c:  a == b  ->  b == c  ->  a == c
by (
	forany a,b,c:
	assume A_eq_B proves eq a b;
	assume B_eq_C proves eq b c;
	A_eq_B > B_eq_C > bin_sub_right_impl
);

require neq_comm proves forany a,b: a != b  ->  b != a
by (
	forany a,b:
	assume ab proves a != b;
	assume ba proves b == a;
	ab < (ba > eq_comm)
);

require neq_same proves forany a: !(a != a)
by eq_same > impl_not_not;




require not_impl__or proves forany a,b: (!a -> b)  ->  a || b
by (
	forany a,b:
	assume NA_B proves !a -> b;
	wrap or (
		assume NA_AND_NB proves !a && !b;
		(NA_AND_NB > and_left) > ((NA_AND_NB > and_right) > (NA_B > impl_reverse))
	)
);

require or_left proves forany a,b: a  ->  a || b
by (
	forany a,b:
	assume A proves a;
	wrap or (
		assume NA_and_NB proves !a && !b;
		A > (NA_and_NB > and_left)
	)
);

require or_right proves forany a,b: b  ->  a || b
by (
	forany a,b:
	assume B proves b;
	wrap or (
		assume NA_and_NB proves !a && !b;
		B > (NA_and_NB > and_right)
	)
);

require or_impl_left proves forany a,b,c: ((a || b) -> c) -> (a -> c)
by (
	forany a,b,c:
	assume OR_AB_C proves (a || b) -> c;
	assume A proves a;
	((A > or_left) > OR_AB_C)
);

require or_impl_right proves forany a,b,c: ((a || b) -> c) -> (b -> c)
by (
	forany a,b,c:
	assume OR_AB_C proves (a || b) -> c;
	assume B proves b;
	((B > or_right) > OR_AB_C)
);

require or_comm_impl proves forany a,b: a || b  ->  b || a
by (
	forany a,b:
	assume A_OR_B proves a || b;
	require A_IMPL_B_OR_A proves a -> b || a by or_right;
	require B_IMPL_B_OR_A proves b -> b || a by or_left;
	B_IMPL_B_OR_A > A_IMPL_B_OR_A > A_OR_B > or_cases
);

require or_comm_eq proves forany a,b: eq (or a b) (or b a)
by  wrap eq ( impl_impl_and < or_comm_impl < or_comm_impl );

require false_false__not_or proves forany a,b: !a -> !b -> !(a || b)
by (
	forany a,b:
	assume NA proves !a;
	assume NB proves !b;
	assume OR_AB proves or a b;
	require OR_AB_ proves (AND !a !b) -> FALSE
	by unwrap or OR_AB;
	(NB > NA > impl_impl_and) > OR_AB_
);





syntax (a++) = UINT_SUCC a, precedence 20000, associativity left;

print _UINT_has_member_UINT_ZERO;
print _UINT_has_member_UINT_SUCC;

require zero_is_uint proves UINT_ZERO : UINT  by  _UINT_has_member_UINT_ZERO;
require succ_uint_is_uint proves forany a: (a : UINT) -> HAS_MEMBER UINT (UINT_SUCC a)  by
	(forany a: assume auint proves a : UINT;  _UINT_has_member_UINT_SUCC < auint);
require succ_not_zero proves forany a: a : UINT -> (UINT_SUCC a) != UINT_ZERO
by (
	forany a:
	assume auint proves a : UINT;
	(_neq_UINT_UINT_ZERO_UINT_SUCC < auint) > neq_comm
);

require uint_is_zero_or_succ_new proves forany a: a : UINT  ->  or (eq a UINT_ZERO) ((forany b: (HAS_MEMBER UINT b && (eq a (UINT_SUCC b)) -> FALSE)) -> FALSE) by (
	forany a:
	assume auint proves a : UINT;
	(auint > _UINT_is_one_of) > (not_not_eq > bin_sub_left_impl)
);

require uint_is_zero_or_succ proves forany a: a : UINT  ->  or (eq a UINT_ZERO) ((forany b: (HAS_MEMBER UINT b -> (eq a (UINT_SUCC b)) -> FALSE)) -> FALSE) by (
	forany a:
	assume auint proves a : UINT;
	
	or_cases < (uint_is_zero_or_succ_new < auint) < (
		assume ass proves eq a UINT_ZERO;
		ass > or_left
	) < (
		assume ass proves (forany b: (HAS_MEMBER UINT b && (eq a (UINT_SUCC b)) -> FALSE)) -> FALSE;
		
		or_right < (
			
			// Goal:
			// (forany b: (HAS_MEMBER UINT b -> (eq a (UINT_SUCC b)) -> FALSE)) -> FALSE
			
			assume ass2 proves forany b: HAS_MEMBER UINT b -> (eq a (UINT_SUCC b)) -> FALSE;
			
			// Goal: FALSE
			
			ass < (
				// Goal:
				// forany b: HAS_MEMBER UINT b && (eq a (UINT_SUCC b)) -> FALSE
				
				forany b:
				assume ass3 proves HAS_MEMBER UINT b && (eq a (UINT_SUCC b));
				
				// Goal: FALSE
				
				ass2 < (
					ass3 > and_left
				) < (
					// Goal:
					// (eq a (UINT_SUCC b))
					ass3 > and_right
				)
			)
		)
	)
);

assume uint_inductive proves forany a,P: P UINT_ZERO -> (forany b: (b : UINT) -> P b -> P (UINT_SUCC b)) -> (a : UINT) -> P a;
assume uint_succ_injective proves forany a,b: a : UINT  ->  b : UINT  ->  a++ == b++  ->  a == b;

define UINT_ONE = UINT_SUCC UINT_ZERO;
define UINT_TWO = UINT_SUCC UINT_ONE;

define UINT_PRED {
	a: (UINT_SUCC a) | a : UINT = a;
	;
	(
		forany a1, a2:
		assume a1_not_a2 proves a1 != a2;
		assume a1uint proves a1 : UINT;
		assume a2uint proves a2 : UINT;
		((uint_succ_injective < a1uint < a2uint) > impl_reverse) < a1_not_a2
	);
};

require uint_pred proves forany a: (a : UINT) -> eq (UINT_PRED (UINT_SUCC a)) a by (
	forany a:
	assume auint proves a : UINT;
	eq_same > (defeq2 UINT_PRED.x < auint) > bin_sub_right_impl
);


define UINT_ADD {
	a  : a UINT_ZERO     | a : UINT                 = a,
	a,b: a (UINT_SUCC b) | (a : UINT) && (b : UINT) = UINT_SUCC (UINT_ADD a b);
	(
		forany a1,a2,b2:
		assume condition_1 proves a1 : UINT;
		assume condition_2 proves (a2 : UINT) && (b2 : UINT);
		(_neq_UINT_UINT_ZERO_UINT_SUCC < (condition_2 > and_right)) > or_right
	);
	(
		forany a1, a2:
		assume a1_not_a2 proves a1 != a2;
		assume a1uint proves a1 : UINT;
		assume a2uint proves a2 : UINT;
		
		or_left < a1_not_a2
	), (
		forany a1, b1, a2, b2:
		assume a1_not_a2 proves a1 != a2;
		assume b1_not_b2 proves b1 != b2;
		assume a1b1uint proves (a1 : UINT) && (b1 : UINT);
		assume a2b2uint proves (a2 : UINT) && (b2 : UINT);
		or_left < a1_not_a2
	);
};
syntax (a + b) = UINT_ADD a b, precedence 200, associativity left;



define UINT_MUL {
	a:   a UINT_ZERO     | a : UINT                 = UINT_ZERO,
	a,b: a (UINT_SUCC b) | (a : UINT) && (b : UINT) = (UINT_ADD (UINT_MUL a b) a);
	(
		forany a1,a2,b2:
		assume condition_1 proves a1 : UINT;
		assume condition_2 proves (a2 : UINT) && (b2 : UINT);
		(_neq_UINT_UINT_ZERO_UINT_SUCC < (condition_2 > and_right)) > or_right
	);
	(
		forany a1, a2:
		assume a1_not_a2 proves a1 != a2;
		assume a1uint proves a1 : UINT;
		assume a2uint proves a2 : UINT;
		
		or_left < a1_not_a2
	), (
		forany a1, b1, a2, b2:
		assume a1_not_a2 proves a1 != a2;
		assume b1_not_b2 proves b1 != b2;
		assume a1b1uint proves (a1 : UINT) && (b1 : UINT);
		assume a2b2uint proves (a2 : UINT) && (b2 : UINT);
		or_left < a1_not_a2
	);
};
syntax (a * b) = UINT_MUL a b, precedence 210, associativity left;

define UINT_POW {
	a:   a UINT_ZERO     | a : UINT                 = UINT_ONE,
	a,b: a (UINT_SUCC b) | (a : UINT) && (b : UINT) = (UINT_MUL (UINT_POW a b) a);
	(
		forany a1,a2,b2:
		assume condition_1 proves a1 : UINT;
		assume condition_2 proves (a2 : UINT) && (b2 : UINT);
		(_neq_UINT_UINT_ZERO_UINT_SUCC < (condition_2 > and_right)) > or_right
	);
	(
		forany a1, a2:
		assume a1_not_a2 proves a1 != a2;
		assume a1uint proves a1 : UINT;
		assume a2uint proves a2 : UINT;
		
		or_left < a1_not_a2
	), (
		forany a1, b1, a2, b2:
		assume a1_not_a2 proves a1 != a2;
		assume b1_not_b2 proves b1 != b2;
		assume a1b1uint proves (a1 : UINT) && (b1 : UINT);
		assume a2b2uint proves (a2 : UINT) && (b2 : UINT);
		or_left < a1_not_a2
	);
};
syntax (a ** b) = UINT_POW a b, precedence 220, associativity right;

define uint_le a b = (forany c: ((c : UINT) && (b == (a + c))) -> FALSE) -> FALSE;
syntax (a <= b) = uint_le a b, precedence 190, associativity noassoc;

define UINT_SATPRED {
	UINT_ZERO                   = UINT_ZERO,
	a: (UINT_SUCC a) | a : UINT = a;
	(
		forany a:
		assume auint proves a : UINT;
		_neq_UINT_UINT_ZERO_UINT_SUCC < auint
	);
	(
		forany a1, a2:
		assume a1_not_a2 proves a1 != a2;
		assume a1uint proves a1 : UINT;
		assume a2uint proves a2 : UINT;
		((uint_succ_injective < a1uint < a2uint) > impl_reverse) < a1_not_a2
	);
};

define UINT_SATSUB {
	a:   a UINT_ZERO     | a : UINT                 = a,
	a,b: a (UINT_SUCC b) | (a : UINT) && (b : UINT) = UINT_SATSUB (UINT_SATPRED a) b;
	(
		forany a1,a2,b2:
		assume condition_1 proves a1 : UINT;
		assume condition_2 proves (a2 : UINT) && (b2 : UINT);
		(_neq_UINT_UINT_ZERO_UINT_SUCC < (condition_2 > and_right)) > or_right
	);
	(
		forany a1, a2:
		assume a1_not_a2 proves a1 != a2;
		assume a1uint proves a1 : UINT;
		assume a2uint proves a2 : UINT;
		
		or_left < a1_not_a2
	), (
		forany a1, b1, a2, b2:
		assume a1_not_a2 proves a1 != a2;
		assume b1_not_b2 proves b1 != b2;
		assume a1b1uint proves (a1 : UINT) && (b1 : UINT);
		assume a2b2uint proves (a2 : UINT) && (b2 : UINT);
		or_left < a1_not_a2
	);
};

syntax (a - b) = UINT_SATSUB a b, precedence 200, associativity left;



require satpred_uint_is_uint proves forany a: a : UINT -> (UINT_SATPRED a) : UINT
by (
	forany a:
	assume auint proves a : UINT;
	or_cases < (uint_is_zero_or_succ < auint) < (
		assume a_0 proves a == UINT_ZERO;
		
		(zero_is_uint > ((defeq2 UINT_SATPRED.x) > eq_comm) > bin_sub_right_impl)
		>
		((a_0 > eq_comm) > un_sub_arg)
		>
		bin_sub_right_impl
	) < (
		assume a_is_succ proves (forany b: (HAS_MEMBER UINT b -> (eq a (UINT_SUCC b)) -> FALSE)) -> FALSE;
		
		not_not_impl < (
			// Goal:
			// ((UINT_SATPRED a) : UINT -> FALSE) -> FALSE
			
			assume aaa proves (UINT_SATPRED a) : UINT -> FALSE;
			
			// Goal: FALSE
			
			a_is_succ < (
				forany b:
				assume buint proves b : UINT;
				assume a_sb proves a == b++;
				
				// Goal: FALSE
				
				aaa < (
					// Goal: (UINT_SATPRED a) : UINT
					
					require temp1 proves (UINT_SATPRED (b++)) : UINT
					by buint > (((defeq2 UINT_SATPRED.xx) < buint) > eq_comm) > bin_sub_right_impl;
					
					temp1 > ((a_sb > eq_comm) > un_sub_arg) > bin_sub_right_impl
				)
			)
		)
	)
);


require satsub_succ__satpred_satsub proves forany a,b:  a : UINT -> b : UINT -> (a - b++) == UINT_SATPRED (a - b)
by (
	define Func b = forany a: a : UINT -> (a - b++)  == UINT_SATPRED (a - b);
	
	require casezero proves Func UINT_ZERO
	by wrap Func (
		forany a:
		assume auint proves a : UINT;
		
		// Goal:
		// (a - 0++)  == UINT_SATPRED (a - 0)
		
		require temp1 proves UINT_SATPRED (a - UINT_ZERO) == UINT_SATPRED (a - UINT_ZERO)
		by eq_same;
		
		require temp2 proves UINT_SATPRED a == UINT_SATPRED (a - UINT_ZERO)
		by temp1 > ((defeq2 UINT_SATSUB.x < auint) > un_sub_arg) > bin_sub_left_impl;
		
		require temp3 proves (UINT_SATPRED a - UINT_ZERO) == UINT_SATPRED (a - UINT_ZERO)
		by temp2 > ((defeq2 UINT_SATSUB.x < (auint > satpred_uint_is_uint)) > eq_comm) > bin_sub_left_impl;
		
		temp3 > ((defeq2 UINT_SATSUB.xx < (impl_impl_and < auint < zero_is_uint)) > eq_comm) > bin_sub_left_impl
	);
	
	require casesucc proves forany b: b : UINT -> Func b -> Func (b++)
	by (
		forany b:
		assume buint proves b : UINT;
		assume hypoth proves Func b;
		require hypoth_ proves forany a: a : UINT -> (a - b++)  == UINT_SATPRED (a - b)
		by unwrap Func hypoth;
		
		wrap Func (
			forany a:
			assume auint proves a : UINT;
			
			require temp1 proves UINT_SATPRED (UINT_SATPRED a - b) == UINT_SATPRED (UINT_SATPRED a - b)
			by eq_same;
			
			require temp2 proves UINT_SATPRED (UINT_SATPRED a - b) == UINT_SATPRED (a - b++)
			by temp1 > (((defeq2 UINT_SATSUB.xx < (impl_impl_and < auint < buint)) > eq_comm) > un_sub_arg) > bin_sub_right_impl;
			
			require temp3 proves (UINT_SATPRED a - b++) == UINT_SATPRED (a - b++)
			by temp2 > ((hypoth_ < (auint > satpred_uint_is_uint)) > eq_comm) > bin_sub_left_impl;
			
			require temp4 proves (a - (b++)++) == UINT_SATPRED (a - b++)
			by temp3 > ((defeq2 UINT_SATSUB.xx < (impl_impl_and < auint < (succ_uint_is_uint < buint))) > eq_comm) > bin_sub_left_impl;
			
			temp4
		)
	);
	
	forany a,b:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	
	(unwrap Func (uint_inductive < casezero < casesucc < buint)) < auint
);

define is_divisible_by n o = (n : UINT) && (o : UINT) && !(forany x: !((x : UINT) && x * o == n));

define is_even n = is_divisible_by n UINT_TWO;

define is_prime p = forany d: (p : UINT) && p != UINT_ONE && (d : UINT  ->  d != UINT_ONE  ->  d != p  ->  !(is_divisible_by p d));

define MUL_RANGE {
	a:   a a                      = a,
	a,b: a b | (a <= b && a != b) = a * MUL_RANGE a++ b;
	(
		forany a1,a2,b2:
		assume conditions proves (a2 <= b2 && a2 != b2);
		or_cases < yay_or_nay < (
			assume a1_eq_a2 proves a1 == a2;
			or_right < ((conditions > and_right) > ((a1_eq_a2 > eq_comm) > bin_sub_left_eq) > bin_sub_left_impl)
		) < (
			assume a1_neq_a2 proves a1 != a2;
			or_left < a1_neq_a2
		)
	);
	(
		forany a1, a2:
		assume a1_not_a2 proves a1 != a2;
		
		or_left < a1_not_a2
	), (
		forany a1, b1, a2, b2:
		assume a1_not_a2 proves a1 != a2;
		assume b1_not_b2 proves b1 != b2;
		assume a1b1uint proves (a1 <= b1 && a1 != b1);
		assume a2b2uint proves (a2 <= b2 && a2 != b2);
		or_left < a1_not_a2
	);
};






require or_assoc_impl proves forany a,b,c: (a || b) || c  ->  a || (b || c)
by (
	forany a,b,c:
	assume AB_C proves (a || b) || c;
	
	require AB_C_ proves AND (or a b -> FALSE) (c -> FALSE) -> FALSE
	by unwrap or AB_C;
	
	wrap or (
		// Goal:
		// AND (a -> FALSE) (or b c -> FALSE) -> FALSE
		
		assume NA_NBC proves AND (a -> FALSE) (or b c -> FALSE);
		
		// Goal:
		// FALSE
		
		require NA proves a -> FALSE by NA_NBC > and_left;
		require NBC proves or b c -> FALSE
		by NA_NBC > and_right;
		
		require NBC_ proves (AND (b -> FALSE) (c -> FALSE) -> FALSE) -> FALSE
		by (
			assume temp proves AND (b -> FALSE) (c -> FALSE) -> FALSE;
			(wrap or temp) > NBC
		);
		
		require NBC__ proves AND (b -> FALSE) (c -> FALSE)
		by NBC_ > not_not_impl;
		
		require NB proves b -> FALSE  by  NBC__ > and_left;
		require NC proves c -> FALSE  by  NBC__ > and_right;
		
		AB_C_ < (
			// Goal:
			// AND (or a b -> FALSE) (c -> FALSE)
			
			impl_impl_and < (
				// Goal:
				// or a b -> FALSE
				
				assume AB proves or a b;
				
				// Goal:
				// FALSE
				
				require AB_ proves AND (a -> FALSE) (b -> FALSE) -> FALSE
				by unwrap or AB;
				
				AB_ < (
					impl_impl_and < NA < NB
				)
			) < NC
		)
	)
);

require not_not_or_not__and proves forany a,b:  (or (a -> FALSE) (b -> FALSE) -> FALSE) -> AND a b
by (
	forany a,b:
	assume not_na_or_nb proves or (a -> FALSE) (b -> FALSE) -> FALSE;
	require temp1 proves (AND ((a -> FALSE) -> FALSE) ((b -> FALSE) -> FALSE) -> FALSE) -> FALSE
	by (
		assume ttt proves AND ((a -> FALSE) -> FALSE) ((b -> FALSE) -> FALSE) -> FALSE;
		wrap or ttt > not_na_or_nb
	);
	
	require temp2 proves AND ((a -> FALSE) -> FALSE) ((b -> FALSE) -> FALSE)
	by temp1 > not_not_impl;
	
	(temp2 > not_not_eq > bin_sub_left_impl) > not_not_eq > bin_sub_right_impl
);












require xor__not_right__left proves forany a,b: a ^^ b  ->  !b  ->  a
by (
	forany a,b:
	assume XAB proves a ^^ b;
	assume NB proves !b;
	
	NB > (((unwrap xor XAB) > and_left) > or__not_right__left)
);

require xor__not_left__right proves forany a,b: a ^^b  ->  !a  ->  b
by (
	forany a,b:
	assume XAB proves a ^^ b;
	assume NA proves !a;
	
	NA > (((unwrap xor XAB) > and_left) > or__not_left__right)
);

require xor_comm_impl proves forany a,b: a ^^ b  ->  b ^^ a
by (
	forany a,b:
	assume XAB proves a ^^ b;
	require OR_BA proves b || a  by  ((unwrap xor XAB) > and_left) > or_comm_impl;
	require NOT_AND_BA proves !(b && a)  by  ((unwrap xor XAB) > and_right) > (and_comm_impl > impl_trans);
	wrap xor (NOT_AND_BA > OR_BA > impl_impl_and)
);

require xor__left__not_right proves forany a,b: a ^^ b  ->  a  ->  !b
by (
	forany a,b:
	assume XAB proves a ^^ b;
	assume A proves a;
	assume B proves b;
	(B > A > impl_impl_and) > (unwrap xor XAB > and_right)
);

require xor__right__not_left proves forany a,b: a ^^ b  ->  b  ->  !a
by (
	forany a,b:
	assume XAB proves a ^^ b;
	assume B proves b;
	assume A proves a;
	(B > A > impl_impl_and) > (unwrap xor XAB > and_right)
);

require true__false__xor proves forany a,b: a  ->  !b  ->  a ^^ b
by (
	forany a,b:
	assume A proves a;
	assume NB proves b -> FALSE;
	wrap xor (impl_impl_and < (or_left < A) < (not_right__not_and < NB))
);

require false__true__xor proves forany a,b: !a  ->  b  ->  a ^^ b
by (
	forany a,b:
	assume NA proves !a;
	assume B proves b;
	wrap xor (impl_impl_and < (or_right < B) < (not_left__not_and < NA))
);

require false_false__not_xor proves forany a,b: !a  ->  !b  ->  !(a ^^ b)
by (
	forany a,b:
	assume NA proves !a;
	assume NB proves !b;
	assume XAB proves a ^^ b;
	
	(unwrap xor XAB) > (NB > NA > false_false__not_or) > not_left__not_and
);




require satsub_zero proves forany a: a : UINT -> a - UINT_ZERO == a
by (
	forany a:
	assume auint proves a : UINT;
	
	(defeq2 UINT_SATSUB.x) < auint
);
require zero_satsub proves forany a: a : UINT -> UINT_ZERO - a == UINT_ZERO
by (
	forany a:
	assume auint proves a : UINT;
	
	define ZeroSubFunc _a = UINT_ZERO - _a == UINT_ZERO;
	
	require casezero proves ZeroSubFunc UINT_ZERO
	by wrap ZeroSubFunc (satsub_zero < zero_is_uint);
	
	require casesucc proves forany a: a : UINT -> ZeroSubFunc a -> ZeroSubFunc a++
	by (
		forany a:
		assume auint proves a : UINT;
		assume hypoth proves ZeroSubFunc a;
		require hypoth_ proves UINT_ZERO - a == UINT_ZERO
		by unwrap ZeroSubFunc hypoth;
		wrap ZeroSubFunc (
			require temp1 proves (UINT_SATPRED UINT_ZERO) - a == UINT_ZERO
			by hypoth_ > (((defeq2 UINT_SATPRED.x) > eq_comm) > bin_sub_left_eq) > bin_sub_left_impl;
			
			temp1 > ((defeq2 UINT_SATSUB.xx) < (impl_impl_and < zero_is_uint < auint) > eq_comm) > bin_sub_left_impl
		)
	);
	
	unwrap ZeroSubFunc (uint_inductive < casezero < casesucc < auint)
);

require succ_satsub_succ proves forany a, b: a : UINT  ->  b : UINT  ->  UINT_SATSUB a++ b++  ==  UINT_SATSUB a b
by (
	forany a,b:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	
	require temp1 proves UINT_SATSUB a++ b++ == UINT_SATSUB a++ b++
	by eq_same;
	
	require temp2 proves UINT_SATSUB a++ b++ == UINT_SATSUB (UINT_SATPRED (a++)) b
	by temp1 > ((defeq2 UINT_SATSUB.xx) < (impl_impl_and < (succ_uint_is_uint < auint) < buint)) > bin_sub_right_impl;
	
	temp2 > (((defeq2 UINT_SATPRED.xx) < auint) > bin_sub_left_eq) > bin_sub_right_impl
);
require sat_pred_zero_is_zero proves UINT_SATPRED UINT_ZERO == UINT_ZERO
by (
	defeq2 UINT_SATPRED.x
);
require sat_pred_succ proves forany a: a : UINT -> UINT_SATPRED (a++) == a
by (
	forany a:
	assume auint proves a : UINT;
	
	(defeq2 UINT_SATPRED.xx) < auint
);




require sat_pred__succ_satsub proves forany a,b: a : UINT -> b : UINT -> UINT_SATPRED (a++ - b) == a - b
by (
	forany a,b:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	or_cases < (uint_is_zero_or_succ < buint) < (
		assume b_0 proves b == UINT_ZERO;
		
		require temp1 proves UINT_SATPRED (a++) == UINT_SATPRED (a++)
		by eq_same;
		
		require temp2 proves UINT_SATPRED (a++) == a
		by temp1 > (sat_pred_succ < auint) > bin_sub_right_impl;
		
		require temp3 proves UINT_SATPRED (a++) == a - UINT_ZERO
		by temp2 > ((satsub_zero < auint) > eq_comm) > bin_sub_right_impl;
		
		require temp4 proves UINT_SATPRED (a++ - UINT_ZERO) == a - UINT_ZERO
		by temp3 > (((satsub_zero < (succ_uint_is_uint < auint)) > eq_comm) > un_sub_arg) > bin_sub_left_impl;
		
		require temp5 proves UINT_SATPRED (a++ - UINT_ZERO) == a - b
		by temp4 > ((b_0 > eq_comm) > bin_sub_right_eq) > bin_sub_right_impl;
		
		temp5 > (un_sub_arg < (bin_sub_right_eq < (b_0 > eq_comm))) > bin_sub_left_impl
	) < (
		assume b_succ proves (forany c: (HAS_MEMBER UINT c -> (eq b (UINT_SUCC c)) -> FALSE)) -> FALSE;
		
		not_not_impl < (
			assume ttt proves UINT_SATPRED (a++ - b) == a - b -> FALSE;
			
			// Goal: FALSE
			
			b_succ < (
				// Goal:
				// forany c: HAS_MEMBER UINT c -> (eq b (UINT_SUCC c)) -> FALSE
				
				forany c:
				assume cuint proves c : UINT;
				assume b_sc proves b == c++;
				
				// Goal: FALSE
				
				ttt < (
					// Goal:
					// UINT_SATPRED (a++ - b) == a - b
					
					require temp1 proves UINT_SATPRED (a - c) == UINT_SATPRED (a - c)
					by eq_same;
					
					require temp2 proves UINT_SATPRED (a - c) == a - c++
					by temp1 > ((satsub_succ__satpred_satsub < auint < cuint) > eq_comm) > bin_sub_right_impl;
					
					require temp3 proves UINT_SATPRED (a++ - c++) == a - c++
					by temp2 > (((succ_satsub_succ < auint < cuint) > eq_comm) > un_sub_arg) > bin_sub_left_impl;
					
					require temp4 proves UINT_SATPRED (a++ - b) == a - c++
					by temp3 > (((b_sc > eq_comm) > bin_sub_right_eq) > un_sub_arg) > bin_sub_left_impl;
					
					temp4 > ((b_sc > eq_comm) > bin_sub_right_eq) > bin_sub_right_impl
				)
			)
		)
	)
);

/*
require satsub_succ__satpred_satsub2 proves forany a,b:  a : UINT -> b : UINT -> (a - b++) == UINT_SATPRED (a - b)
by (
	forany a,b:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	
	or_cases < (uint_is_zero_or_succ < auint) < (
		assume a_0 proves a == UINT_ZERO;
		
		require temp1 proves UINT_ZERO == UINT_SATPRED (UINT_ZERO - b)
		by (sat_pred_zero_is_zero > eq_comm) > (((buint > zero_satsub) > eq_comm) > un_sub_arg) > bin_sub_right_impl;
		
		require temp2 proves (UINT_ZERO - b++) == UINT_SATPRED (UINT_ZERO - b)
		by temp1 > (((buint > succ_uint_is_uint) > zero_satsub) > eq_comm) > bin_sub_left_impl;
		
		require temp3 proves (UINT_ZERO - b++) == UINT_SATPRED (a - b)
		by temp2 > (((a_0 > eq_comm) > bin_sub_left_eq) > un_sub_arg) > bin_sub_right_impl;
		
		temp3 > ((a_0 > eq_comm) > bin_sub_left_eq) > bin_sub_left_impl
	) < (
		assume a_succ proves (forany c: (HAS_MEMBER UINT c -> (eq a (UINT_SUCC c)) -> FALSE)) -> FALSE;
		
		not_not_impl < (
			assume ttt proves ((a - b++) == UINT_SATPRED (a - b)) -> FALSE;
			
			// Goal: FALSE
			
			a_succ < (
				// Goal:
				// forany c: (HAS_MEMBER UINT c -> (eq a (UINT_SUCC c)) -> FALSE)
				
				forany c:
				assume cuint proves c : UINT;
				assume a_sc proves a == c++;
				
				// Goal: FALSE
				
				ttt < (
					// Goal:
					// (a - b++) == UINT_SATPRED (a - b)
					
					require temp1 proves c - b == c - b  by eq_same;
					require temp2 proves (c - b) == UINT_SATPRED (c++ - b)
					by temp1 > ((sat_pred__succ_satsub < cuint < buint) > eq_comm) > bin_sub_right_impl;
					
					require temp3 proves (c++ - b++) == UINT_SATPRED (c++ - b)
					by temp2 > ((succ_satsub_succ < cuint < buint) > eq_comm) > bin_sub_left_impl;
					
					(temp3 > ((a_sc > eq_comm) > bin_sub_left_eq) > bin_sub_left_impl) > (((a_sc > eq_comm) > bin_sub_left_eq) > un_sub_arg) > bin_sub_right_impl
					
					// (c - b) == (c - b)
					// (c - b) == UINT_SATPRED (c++ - b)
					// (c++ - b++) == UINT_SATPRED (c++ - b)
				)
			)
		)
	)
	
	// (a - b++) == UINT_SATPRED (a - b)
);
*/









require add_zero proves forany a: (a : UINT) -> eq (UINT_ADD a UINT_ZERO) a
by (
	forany a:
	assume auint proves a : UINT;
	
	(defeq2 UINT_ADD.x) < auint
);

require add_succ proves forany a,b: (a : UINT) -> (b : UINT) -> eq (UINT_ADD a (UINT_SUCC b)) (UINT_SUCC (a + b))
by (
	forany a,b:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	
	(defeq2 UINT_ADD.xx) < (impl_impl_and < auint < buint)
);

















require mul_zero proves forany a: (a : UINT)  ->  (a * UINT_ZERO) == UINT_ZERO
by (
	forany a,b:
	assume a_uint proves a : UINT;
	
	(defeq2 UINT_MUL.x) < a_uint
);

require mul_succ proves forany a,b: (a : UINT) -> (b : UINT)  ->  (a * (b++)) == (a * b + a)
by (
	forany a,b:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	
	(defeq2 UINT_MUL.xx) < (impl_impl_and < auint < buint)
);









require pow_zero proves forany a: (a : UINT)  ->  (a ** UINT_ZERO) == UINT_ONE
by (
	forany a:
	assume a_uint proves a : UINT;
	
	(defeq2 UINT_POW.x) < a_uint
);

require pow_succ proves forany a,b: (a : UINT)  ->  (b : UINT)  ->  (a ** (b++)) == ((a ** b) * a)
by (
	forany a,b:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	
	(defeq2 UINT_POW.xx) < (impl_impl_and < auint < buint)
);














require succ_inj proves forany a,b: (a : UINT)  ->  (b : UINT)  ->  a++ == b++  ->  a == b
by (
	forany a,b:
	assume a_uint proves a : UINT;
	assume b_uint proves b : UINT;
	
	assume temp1 proves eq (UINT_SUCC a) (UINT_SUCC b);
	require temp2 proves eq (UINT_PRED (UINT_SUCC a)) (UINT_PRED (UINT_SUCC b))  by  temp1 > wrap_in_func_impl;
	
	(temp2 > (a_uint > uint_pred) > bin_sub_left_impl)
	> (b_uint > uint_pred) > bin_sub_right_impl
);

require uint_neq_succ_self proves forany a: a : UINT  ->  a != a++
by (
	forany a:
	assume auint proves a : UINT;
	
	define Func aa = aa != aa++;
	
	require casezero proves Func UINT_ZERO
	by wrap Func (
		(succ_not_zero < zero_is_uint) > neq_comm
	);
	
	require casesucc proves forany aa: aa : UINT  ->  Func aa  ->  Func aa++
	by (
		forany aa:
		assume aauint proves aa : UINT;
		assume hypoth proves Func aa;
		require hypoth_ proves aa != aa++
		by unwrap Func hypoth;
		wrap Func (
			// Goal:
			// aa++ != aa++++
			
			assume ttt proves aa++ == aa++++;
			
			// FALSE
			
			hypoth_ < (
				// Goal:
				// aa == aa++
				
				succ_inj < aauint < (succ_uint_is_uint < aauint) < ttt
			)
		)
	);
	
	unwrap Func (uint_inductive < casezero < casesucc < auint)
);

require uint_add_uint_is_uint proves forany a,b: a : UINT  ->   b : UINT   ->   (a + b) : UINT
by (
	forany a,b:
	assume a_uint proves a : UINT;
	assume b_uint proves b : UINT;
	define AddUintIsUintFunc y = forany x: (HAS_MEMBER UINT x) -> (HAS_MEMBER UINT (x + y));
	require casezero proves AddUintIsUintFunc UINT_ZERO
	by (
		require temp proves forany x: (HAS_MEMBER UINT x) -> (HAS_MEMBER UINT (UINT_ADD x UINT_ZERO))
		by (
			forany x:
			assume x_uint proves x : UINT;
			require temp2 proves  eq (UINT_ADD x UINT_ZERO) x by  (x_uint > add_zero);
			x_uint > (temp2 > eq_comm) > bin_sub_right_impl
		);
		wrap AddUintIsUintFunc temp
	);
	
	require casesucc proves forany b: (b : UINT)   ->   AddUintIsUintFunc b   ->   AddUintIsUintFunc (UINT_SUCC b)
	by (
		forany b:
		assume _buint proves b : UINT;
		assume hypoth proves AddUintIsUintFunc b;
		wrap AddUintIsUintFunc (
			forany a:
			assume _auint proves a : UINT;
			
			require temp1 proves HAS_MEMBER UINT (UINT_SUCC (a + b))
				by  (_auint > (unwrap AddUintIsUintFunc hypoth)) > succ_uint_is_uint;
			
			require temp2 proves  eq (UINT_SUCC (a + b)) (UINT_ADD a (UINT_SUCC b))
				by   (_buint > _auint > add_succ) > eq_comm;
			
			temp1 > temp2 > bin_sub_right_impl
		)
	);
	
	a_uint > unwrap AddUintIsUintFunc (b_uint > casesucc > casezero > uint_inductive)
);

require zero_add proves forany a: (a : UINT) -> eq (UINT_ADD UINT_ZERO a) a
by (
	forany a:
	assume a_uint proves a : UINT;
	
	define ZeroAddFunc x = eq (UINT_ADD UINT_ZERO x) x;
	
	require casezero proves ZeroAddFunc UINT_ZERO
	by (
		wrap ZeroAddFunc ((eq_same > (zero_is_uint > add_zero) > bin_sub_left_impl) > eq_comm)
	);
	
	require casesucc proves forany y: (HAS_MEMBER UINT y) -> ZeroAddFunc y -> ZeroAddFunc (UINT_SUCC y)
	by (
		forany y:
		assume y_uint proves y : UINT;
		assume hypoth proves ZeroAddFunc y;
		require temp1 proves eq (UINT_ADD UINT_ZERO y) y  by  unwrap ZeroAddFunc hypoth;
		require temp2 proves eq (UINT_SUCC (UINT_ADD UINT_ZERO y)) (UINT_SUCC y)  by   temp1 > wrap_in_func_impl;
		wrap ZeroAddFunc (
			// We want to prove     eq (UINT_ADD UINT_ZERO (UINT_SUCC y)) (UINT_SUCC y)
			temp2 > ((y_uint > zero_is_uint > add_succ) > eq_comm) > bin_sub_left_impl
		)
	);
	
	unwrap ZeroAddFunc (a_uint > casesucc > casezero > uint_inductive)
);


require succ_add proves forany a,b: (a : UINT) -> (b : UINT) -> (a++ + b) == ((a + b)++)
by (
	forany a,b:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	
	define SuccAddFunc _b = (forany _a: (HAS_MEMBER UINT _a) -> eq (UINT_ADD (UINT_SUCC _a) _b) (UINT_SUCC (UINT_ADD _a _b)));
	
	require casezero proves SuccAddFunc UINT_ZERO
	by wrap SuccAddFunc (
		forany a: assume _auint proves a : UINT;
		(
			eq_same
			>
			(
				((_auint > succ_uint_is_uint) > add_zero)
				>
				eq_comm
			)
			>
			bin_sub_left_impl
		)
		>
		(
			((_auint > add_zero) > eq_comm) > un_sub_arg
		)
		>
		bin_sub_right_impl
	);
	
	require casesucc proves forany b: (b : UINT) -> SuccAddFunc b -> SuccAddFunc (UINT_SUCC b)
	by (
		forany b:
		assume buint proves b : UINT;
		assume hypoth proves SuccAddFunc b;
		wrap SuccAddFunc (
			forany _a:
			assume _auint proves HAS_MEMBER UINT _a;
			(
				(
					eq_same
					>
					((buint > _auint > add_succ) > un_sub_arg)
					>
					bin_sub_left_impl
				)
				>
				(
					((_auint > (unwrap SuccAddFunc hypoth)) > eq_comm)
					>
					un_sub_arg
				)
				>
				bin_sub_left_impl
			)
			>
			(
				(buint > (_auint > succ_uint_is_uint) > add_succ)
				>
				eq_comm
			)
			>
			bin_sub_left_impl
		)
	);
	
	auint > unwrap SuccAddFunc (buint > casesucc > casezero > uint_inductive)
);

require add_comm proves forany a,b: (a : UINT) -> (b : UINT) ->  (a + b) == (b + a)
by (
	forany a,b:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	define AddCommFunc _b = (forany _a: (HAS_MEMBER UINT _a) -> eq (UINT_ADD _a _b) (UINT_ADD _b _a));
	
	require casezero proves AddCommFunc UINT_ZERO by wrap AddCommFunc (
		forany _a:
		assume _auint proves HAS_MEMBER UINT _a;
		(eq_same > ((_auint > add_zero) > eq_comm) > bin_sub_left_impl) > ((_auint > zero_add) > eq_comm) > bin_sub_right_impl
	);
	require casesucc proves forany b: (b : UINT) -> AddCommFunc b -> AddCommFunc (UINT_SUCC b)
	by (
		forany b:
		assume buint proves b : UINT;
		assume hypoth proves AddCommFunc b;
		
		wrap AddCommFunc (
			forany _a:
			assume _auint proves HAS_MEMBER UINT _a;
			(
				((_auint > (unwrap AddCommFunc hypoth)) > wrap_in_func_impl)
				>
				((buint > _auint > add_succ) > eq_comm)
				>
				bin_sub_left_impl
			)
			>
			((_auint > buint > succ_add) > eq_comm)
			>
			bin_sub_right_impl
		)
	);
	
	auint > unwrap AddCommFunc (buint > casesucc > casezero > uint_inductive)
);

require add_same_impl proves forany a,b,c: a : UINT  ->  b : UINT  ->  c : UINT ->  (a + c) == (b + c)  ->  a == b
by (
	define AddSameFunc z = forany x,y: HAS_MEMBER UINT x -> HAS_MEMBER UINT y -> eq (UINT_ADD x z) (UINT_ADD y z) -> eq x y;
	
	require casezero proves AddSameFunc UINT_ZERO
	by (
		wrap AddSameFunc (
			forany x,y:
			assume xuint proves x : UINT;
			assume yuint proves y : UINT;
			assume temp proves eq (UINT_ADD x UINT_ZERO) (UINT_ADD y UINT_ZERO);
			(temp > (xuint > add_zero) > bin_sub_left_impl)
			>
			(yuint > add_zero)
			>
			bin_sub_right_impl
		)
	);
	
	require casesucc proves forany z: HAS_MEMBER UINT z -> AddSameFunc z -> AddSameFunc (UINT_SUCC z)
	by (
		forany z:
		assume zuint proves z : UINT;
		assume hypoth proves AddSameFunc z;
		require hypoth_ proves forany x,y: HAS_MEMBER UINT x -> HAS_MEMBER UINT y -> eq (UINT_ADD x z) (UINT_ADD y z) -> eq x y
		by unwrap AddSameFunc hypoth;
		wrap AddSameFunc (
			forany x,y:
			assume xuint proves x : UINT;
			assume yuint proves y : UINT;
			
			// We must prove:
			// eq (UINT_ADD x (UINT_SUCC z)) (UINT_ADD y (UINT_SUCC z)) -> eq x y
			
			assume temp proves eq (UINT_ADD x (UINT_SUCC z)) (UINT_ADD y (UINT_SUCC z));
			
			// We must prove:
			// eq x y
			
			require temp2 proves eq (UINT_SUCC (UINT_ADD x z)) (UINT_ADD y (UINT_SUCC z))
			by temp  > (zuint > xuint > add_succ) > bin_sub_left_impl;
			require temp3 proves eq (UINT_SUCC (UINT_ADD x z)) (UINT_SUCC (UINT_ADD y z))
			by temp2 > (zuint > yuint > add_succ) > bin_sub_right_impl;
			require temp4 proves eq (UINT_ADD x z) (UINT_ADD y z)
			by temp3 > ((zuint > yuint > uint_add_uint_is_uint) > (zuint > xuint > uint_add_uint_is_uint) > succ_inj);
			
			temp4 > yuint > xuint > hypoth_
		)
	);
	
	forany a,b,c:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	assume cuint proves c : UINT;
	
	assume bla proves eq (UINT_ADD a c) (b + c);
	
	bla > buint > auint > unwrap AddSameFunc (cuint > casesucc > casezero > uint_inductive)
);

require add_same_impl_rev proves forany a,b,c: a : UINT -> b : UINT -> c : UINT -> a == b -> (a + c) == (b + c)
by (
	forany a,b,c:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	assume cuint proves c : UINT;
	
	define InductFunc c = eq a b -> eq (UINT_ADD a c) (b + c);
	
	require casezero proves InductFunc UINT_ZERO
	by wrap InductFunc (
		assume ab proves eq a b;
		(ab > ((auint > add_zero) > eq_comm) > bin_sub_left_impl)
		>
		((buint > add_zero) > eq_comm)
		>
		bin_sub_right_impl
	);
	
	require casesucc proves forany c: (c : UINT) -> InductFunc c -> InductFunc (UINT_SUCC c)
	by (
		forany c:
		assume cuint proves c : UINT;
		assume hypoth proves InductFunc c;
		require hypoth_ proves eq a b -> eq (UINT_ADD a c) (b + c)
		by unwrap InductFunc hypoth;
		
		wrap InductFunc (
			assume ab proves eq a b;
			
			// Goal:
			// eq (UINT_ADD a (UINT_SUCC c)) (UINT_ADD b (UINT_SUCC c))
			
			(
				((ab > hypoth_) > wrap_in_func_impl)
				>
				((cuint > auint > add_succ) > eq_comm)
				> bin_sub_left_impl
			)
			>
			((cuint > buint > add_succ) > eq_comm)
			>
			bin_sub_right_impl
		)
	);
		
	unwrap InductFunc (cuint > casesucc > casezero > uint_inductive)
);

require add_same_eq proves forany a,b,c: a : UINT  ->  b : UINT  ->  c : UINT  ->  ((a + c) == (b + c)) == (a == b)
by (
	forany a,b,c:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	assume cuint proves c : UINT;
	
	wrap eq (
		(cuint > buint > auint > add_same_impl_rev)
		>
		(cuint > buint > auint > add_same_impl)
		>
		impl_impl_and
	)
);

require same_add proves forany a,b,c: a : UINT  ->  b : UINT  ->  c : UINT ->  (a + b) == (a + c)  ->  b == c
by (
	forany a,b,c:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	assume cuint proves c : UINT;
	assume ab_ac proves eq (a + b) (UINT_ADD a c);
	
	(
		(
			ab_ac
			> 
			(buint > auint > add_comm)
			>
			bin_sub_left_impl
		)
		>
		(cuint > auint > add_comm)
		>
		bin_sub_right_impl
	)
	>
	(auint > cuint > buint > add_same_impl)
);

require add_left_eq_self proves forany a,b: a : UINT  ->  b : UINT  ->  (a + b) == b  ->  a == UINT_ZERO
by (
	forany a,b:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	assume ab_b proves eq (a + b) b;
	
	(ab_b > ((buint > zero_add) > eq_comm) > bin_sub_right_impl)
	>
	(buint > zero_is_uint > auint > add_same_impl)
);


require add_right_eq_self proves forany a,b: a : UINT  ->  b : UINT  ->  (a + b) == a  ->  b == UINT_ZERO
by (
	forany a,b:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	assume ab_a proves (a + b) == a;
	
	(ab_a > ((auint > add_zero) > eq_comm) > bin_sub_right_impl)
	>
	(zero_is_uint > buint > auint > same_add)
);


require add_assoc proves forany a,b,c: a : UINT -> b : UINT -> c : UINT ->  ((a + b) + c) == (a + (b + c))
by (
	forany a,b,c:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	assume cuint proves c : UINT;
	
	define AddAssocFunc z = forany x,y: x : UINT  ->  y : UINT  ->  ((x + y) + z) == (x + (y + z));
	
	require casezero proves AddAssocFunc UINT_ZERO
	by wrap AddAssocFunc (
		forany x,y:
		assume xuint proves x : UINT;
		assume yuint proves y : UINT;
		
		require temp proves (x + y) == (x + y)
		by eq_same;
		
		require temp2 proves ((x + y) + UINT_ZERO) == (x + y)
		by temp > (((yuint > xuint > uint_add_uint_is_uint) > add_zero) > eq_comm) > bin_sub_left_impl;
		
		temp2 > (((yuint > add_zero) > eq_comm) > bin_sub_right_eq) > bin_sub_right_impl
	);
	
	require casesucc proves forany z: (z : UINT)  ->  AddAssocFunc z  ->  AddAssocFunc (z++)
	by (
		forany z:
		assume zuint proves z : UINT;
		assume hypoth proves AddAssocFunc z;
		
		wrap AddAssocFunc (
			forany x,y:
			assume xuint proves x : UINT;
			assume yuint proves y : UINT;
			
			require temp proves eq (UINT_ADD (x + y) z) (UINT_ADD x (UINT_ADD y z))
			by yuint > xuint > unwrap AddAssocFunc hypoth;
			
			require temp2 proves eq (UINT_SUCC (UINT_ADD (x + y) z)) (UINT_SUCC (UINT_ADD x (UINT_ADD y z)))
			by temp > wrap_in_func_impl;
			
			require temp3 proves eq (UINT_ADD (x + y) (UINT_SUCC z)) (UINT_SUCC (UINT_ADD x (UINT_ADD y z)))
			by temp2 > ((zuint > (yuint > xuint > uint_add_uint_is_uint) > add_succ) > eq_comm) > bin_sub_left_impl;
			
			require temp4 proves eq (UINT_ADD (x + y) (UINT_SUCC z)) (UINT_ADD x (UINT_SUCC (UINT_ADD y z)))
			by temp3 > (((zuint > yuint > uint_add_uint_is_uint) > xuint > add_succ) > eq_comm) > bin_sub_right_impl;
			
			temp4 > (((zuint > yuint > add_succ) > eq_comm) > bin_sub_right_eq) > bin_sub_right_impl
		)
	);
	
	buint > auint > unwrap AddAssocFunc (cuint > casesucc > casezero > uint_inductive)
);

require sum_zero_both_zero proves forany a,b: (a : UINT)  ->  (b : UINT)  ->  (a + b) == UINT_ZERO  ->  (a == UINT_ZERO) && (b == UINT_ZERO)
by (
	forany a,b:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	assume ab_zero proves eq (a + b) UINT_ZERO;
	
	require a_not_succ proves forany x: (HAS_MEMBER UINT x) -> eq a (UINT_SUCC x) -> FALSE
	by (
		forany x:
		assume xuint proves x : UINT;
		assume temp1 proves eq a (UINT_SUCC x);
		require temp2 proves eq (UINT_ADD (UINT_SUCC x) b) UINT_ZERO
		by ab_zero > (temp1 > bin_sub_left_eq) > bin_sub_left_impl;
		
		require temp3 proves eq (UINT_SUCC (UINT_ADD x b)) UINT_ZERO
		by temp2 > ((buint > xuint > succ_add) > eq_comm) > eq_trans;
		
		temp3 > (succ_not_zero < (uint_add_uint_is_uint < xuint < buint))
	);
	require b_not_succ proves forany x: (HAS_MEMBER UINT x) -> eq b (UINT_SUCC x) -> FALSE
	by (
		forany x:
		assume xuint proves x : UINT;
		assume temp1 proves eq b (UINT_SUCC x);
		require temp2 proves eq (UINT_ADD a (UINT_SUCC x)) UINT_ZERO
		by ab_zero > (temp1 > bin_sub_right_eq) > bin_sub_left_impl;
		
		require temp3 proves eq (UINT_SUCC (UINT_ADD a x)) UINT_ZERO
		by temp2 > ((xuint > auint > add_succ) > eq_comm) > eq_trans;
		
		temp3 > (succ_not_zero < (uint_add_uint_is_uint < auint < xuint))
	);
	
	require a_zero proves eq a UINT_ZERO
	by (
		(
			a_not_succ
			>
			(substitute a=(forany x: (HAS_MEMBER UINT x) -> eq a (UINT_SUCC x) -> FALSE) in impl_not_not)
		)
		>
		(auint > uint_is_zero_or_succ)
		>
		or__not_right__left
	);
	require b_zero proves eq b UINT_ZERO
	by (
		(
			b_not_succ
			>
			(substitute a=(forany x: (HAS_MEMBER UINT x) -> eq b (UINT_SUCC x) -> FALSE) in impl_not_not)
		)
		>
		(buint > uint_is_zero_or_succ)
		>
		or__not_right__left
	);
	
	
	b_zero > a_zero > impl_impl_and
);

require uint_one_eq_succ_zero proves UINT_ONE == (UINT_SUCC UINT_ZERO)
by (
	require bla proves eq UINT_ONE UINT_ONE by eq_same;
	require ltr proves UINT_ONE -> UINT_SUCC UINT_ZERO
	by ( assume a proves UINT_ONE; unwrap UINT_ONE a );
	require rtl proves UINT_SUCC UINT_ZERO -> UINT_ONE
	by ( assume a proves UINT_SUCC UINT_ZERO; wrap UINT_ONE a );
	wrap eq (rtl > ltr > impl_impl_and)
);

require uint_two_eq_succ_one proves UINT_TWO == (UINT_SUCC UINT_ONE)
by (
	require bla proves eq UINT_TWO UINT_TWO by eq_same;
	require ltr proves UINT_TWO -> UINT_SUCC UINT_ONE
	by ( assume a proves UINT_TWO; unwrap UINT_TWO a );
	require rtl proves UINT_SUCC UINT_ONE -> UINT_TWO
	by ( assume a proves UINT_SUCC UINT_ONE; wrap UINT_TWO a );
	wrap eq (rtl > ltr > impl_impl_and)
);

require one_is_uint proves UINT_ONE : UINT 
by (
	(zero_is_uint > succ_uint_is_uint) > (uint_one_eq_succ_zero > eq_comm) > bin_sub_right_impl
);

require two_is_uint proves UINT_TWO : UINT 
by (
	(one_is_uint > succ_uint_is_uint) > (uint_two_eq_succ_one > eq_comm) > bin_sub_right_impl
);

require one_add_eq_succ proves forany a: (a : UINT) -> eq (UINT_ADD UINT_ONE a) (UINT_SUCC a)
by (
	forany a:
	assume auint proves a : UINT;
	(
		(
			(substitute a=(UINT_ADD UINT_ONE a) in eq_same)
			>
			(uint_one_eq_succ_zero > bin_sub_left_eq)
			>
			bin_sub_right_impl
		)
		>
		(auint > zero_is_uint > succ_add)
		>
		bin_sub_right_impl
	)
	>
	((auint > zero_add) > un_sub_arg)
	>
	bin_sub_right_impl
);

require add_right_cancel proves forany a,b,c: (a : UINT)  ->  (b : UINT)  ->  (c : UINT) ->  (a + c) == (b + c)  ->  a == b
by (
	forany a,b,c:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	assume cuint proves c : UINT;
	
	define Func cc = eq (UINT_ADD a cc) (UINT_ADD b cc) -> eq a b;
	
	require casezero proves Func UINT_ZERO
	by wrap Func (
		assume a0_b0 proves eq (UINT_ADD a UINT_ZERO) (UINT_ADD b UINT_ZERO);
		(a0_b0 > (auint > add_zero) > bin_sub_left_impl) > (buint > add_zero) > bin_sub_right_impl
	);
	
	require casesucc proves forany cc: HAS_MEMBER UINT cc -> Func cc -> Func (UINT_SUCC cc)
	by (
		forany cc:
		assume ccuint proves HAS_MEMBER UINT cc;
		assume ttt proves Func cc;
		
		require ttt_ proves eq (UINT_ADD a cc) (UINT_ADD b cc) -> eq a b
		by unwrap Func ttt;
		
		wrap Func (
			assume ttt2 proves eq (UINT_ADD a (UINT_SUCC cc)) (UINT_ADD b (UINT_SUCC cc));
			require temp1 proves eq (UINT_SUCC (UINT_ADD a cc)) (UINT_SUCC (UINT_ADD b cc))
			by (ttt2 > (add_succ < auint < ccuint) > bin_sub_left_impl) > (add_succ < buint < ccuint) > bin_sub_right_impl;
			
			(succ_inj < (uint_add_uint_is_uint < auint < ccuint) < (uint_add_uint_is_uint < buint < ccuint) < temp1) > ttt_
		)
	);
	
	unwrap Func (uint_inductive < casezero < casesucc < cuint)
);

require add_left_cancel proves forany a,b,c: (a : UINT) -> (b : UINT) -> (c : UINT)  ->  (a + b) == (a + c)  ->  b == c
by (
	forany a,b,c:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	assume cuint proves c : UINT;
	assume ab_ac proves eq (a + b) (UINT_ADD a c);
	
	add_right_cancel < buint < cuint < auint < ((ab_ac > (add_comm < auint < buint) > bin_sub_left_impl) > (add_comm < auint < cuint) > bin_sub_right_impl)
);

require add_nonzero_right proves forany a,b: (a : UINT) -> (b : UINT) -> b != UINT_ZERO -> a + b != UINT_ZERO
by (
	forany a,b:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	assume b_not_0 proves b != UINT_ZERO;
	assume ab_0 proves a + b == UINT_ZERO;
	
	// Goal: FALSE
	
	b_not_0 < (
		// Goal:
		// b == UINT_ZERO
		
		(sum_zero_both_zero < auint < buint < ab_0) > and_right
	)
);

require succ_add__add_succ proves forany a,b: a : UINT -> b : UINT -> (a++) + b == a + (b++)
by (
	forany a,b:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	
	require temp1 proves (a++) + b == (a++) + b
	by eq_same;
	
	(temp1 > (succ_add < auint < buint) > bin_sub_right_impl) > ((add_succ < auint < buint) > eq_comm) > bin_sub_right_impl
);



























require uint_mul_uint_is_uint proves forany a,b: (a : UINT) -> (b : UINT) -> ((a * b) : UINT)
by (
	forany a,b:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	
	define IFunc y = forany x: HAS_MEMBER UINT x -> HAS_MEMBER UINT (UINT_MUL x y);
	
	require casezero proves IFunc UINT_ZERO
	by (
		wrap IFunc (
			forany x:
			assume xuint proves x : UINT;
			
			zero_is_uint > ((xuint > mul_zero) > eq_comm) > bin_sub_right_impl
		)
	);
	
	require casesucc proves forany y: HAS_MEMBER UINT y -> IFunc y -> IFunc (UINT_SUCC y)
	by (
		forany y:
		assume yuint proves y : UINT;
		assume hypoth proves IFunc y;
		require hypoth_ proves forany x: HAS_MEMBER UINT x -> HAS_MEMBER UINT (UINT_MUL x y)
		by unwrap IFunc hypoth;
		wrap IFunc (
			forany x:
			assume xuint proves x : UINT;
			
			(xuint > (xuint > hypoth_) > uint_add_uint_is_uint) > ((yuint > xuint > mul_succ) > eq_comm) > bin_sub_right_impl
		)
	);
	
	auint > unwrap IFunc (buint > casesucc > casezero > uint_inductive)
);

require mul_one proves forany a: (a : UINT)  ->  (a * UINT_ONE) == a
by (
	forany a:
	assume auint proves (a : UINT);
	require temp1 proves eq (UINT_MUL a UINT_ONE) (UINT_MUL a UINT_ONE) by eq_same;
	require temp2 proves eq (UINT_MUL a UINT_ONE) (UINT_MUL a (UINT_SUCC UINT_ZERO))
	by temp1 > (uint_one_eq_succ_zero > bin_sub_right_eq) > bin_sub_right_impl;
	require temp3 proves eq (UINT_MUL a UINT_ONE) (UINT_ADD (UINT_MUL a UINT_ZERO) a)
	by temp2 > (zero_is_uint > auint > mul_succ) > bin_sub_right_impl;
	require temp4 proves eq (UINT_MUL a UINT_ONE) (UINT_ADD UINT_ZERO a)
	by temp3 > ((auint > mul_zero) > bin_sub_left_eq) > bin_sub_right_impl;
	require temp5 proves eq (UINT_MUL a UINT_ONE) a
	by temp4 > (auint > zero_add) > bin_sub_right_impl;
	
	temp5
);

require zero_mul proves forany a: (a : UINT)  ->  (UINT_ZERO * a) == UINT_ZERO
by (
	forany a:
	assume auint proves (a : UINT);
	
	define ZeroMulFunc x = eq (UINT_MUL UINT_ZERO x) UINT_ZERO;
	
	require casezero proves ZeroMulFunc UINT_ZERO
	by (
		wrap ZeroMulFunc (zero_is_uint > mul_zero)
	);
	
	require casesucc proves forany y: (HAS_MEMBER UINT y) -> ZeroMulFunc y -> ZeroMulFunc (UINT_SUCC y)
	by (
		forany y:
		assume yuint proves y : UINT;
		assume hypoth proves ZeroMulFunc y;
		require temp1 proves eq (UINT_MUL UINT_ZERO y) UINT_ZERO by unwrap ZeroMulFunc hypoth;
		require temp2 proves eq (UINT_ADD (UINT_MUL UINT_ZERO y) UINT_ZERO) UINT_ZERO
		by (
			require mul_zero_y_is_uint proves HAS_MEMBER UINT (UINT_MUL UINT_ZERO y)
			by yuint > zero_is_uint > uint_mul_uint_is_uint;
			
			temp1 > ((mul_zero_y_is_uint > add_zero) > eq_comm) > bin_sub_left_impl
		);
		require temp3 proves eq (UINT_MUL UINT_ZERO (UINT_SUCC y)) UINT_ZERO
		by (
			temp2 > ((yuint > zero_is_uint > mul_succ) > eq_comm) > bin_sub_left_impl
		);
		
		wrap ZeroMulFunc temp3
	);
	
	unwrap ZeroMulFunc (auint > casesucc > casezero > uint_inductive)
);



require succ_mul proves forany a,b: (a : UINT)  ->  (b : UINT)  ->  (a++ * b) == (a * b + b)
by (
	forany a,b:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	
	define SuccMulFunc y = forany x: (HAS_MEMBER UINT x) -> eq (UINT_MUL (UINT_SUCC x) y) (UINT_ADD (UINT_MUL x y) y);
	
	require casezero proves SuccMulFunc UINT_ZERO
	by wrap SuccMulFunc (
		forany x:
		assume xuint proves x : UINT;
		
		require temp1 proves eq UINT_ZERO UINT_ZERO  by  eq_same;
		
		require temp2 proves eq UINT_ZERO (UINT_ADD UINT_ZERO UINT_ZERO)
		by temp1 > ((zero_is_uint > add_zero) > eq_comm) > bin_sub_right_impl;
		
		require temp3 proves eq UINT_ZERO (UINT_ADD (UINT_MUL x UINT_ZERO) UINT_ZERO)
		by temp2 > (((xuint > mul_zero) > eq_comm) > bin_sub_left_eq) > bin_sub_right_impl;
		
		require temp4 proves eq (UINT_MUL (UINT_SUCC x) UINT_ZERO) (UINT_ADD (UINT_MUL x UINT_ZERO) UINT_ZERO)
		by temp3 > (((xuint > succ_uint_is_uint) > mul_zero) > eq_comm)  > bin_sub_left_impl;
		
		temp4
	);
	
	require casesucc proves forany y: (HAS_MEMBER UINT y) -> SuccMulFunc y -> SuccMulFunc (UINT_SUCC y)
	by (
		forany y:
		assume yuint proves y : UINT;
		assume hypoth proves SuccMulFunc y;
		require hypoth_ proves forany x: (HAS_MEMBER UINT x) -> eq (UINT_MUL (UINT_SUCC x) y) (UINT_ADD (UINT_MUL x y) y)
		by unwrap SuccMulFunc hypoth;
		
		// succ (succ a * bb + a)  =  succ ((a * bb + a) + bb)
		define SuccMulFunc2 x = eq   (UINT_SUCC (UINT_ADD (UINT_MUL (UINT_SUCC x) y) x))     (UINT_SUCC (UINT_ADD (UINT_ADD (UINT_MUL x y) x) y));
		
		require casezero2 proves SuccMulFunc2 UINT_ZERO
		by wrap SuccMulFunc2 (
			// 
			// Goal: eq   (UINT_SUCC (UINT_ADD (UINT_MUL (UINT_SUCC UINT_ZERO) y) UINT_ZERO))     (UINT_SUCC (UINT_ADD (UINT_ADD (UINT_MUL UINT_ZERO y) UINT_ZERO) y))
			
			require temp1 proves eq   (UINT_SUCC (UINT_MUL (UINT_SUCC UINT_ZERO) y))    (UINT_SUCC (UINT_MUL (UINT_SUCC UINT_ZERO) y))
			by eq_same;
			
			require temp2 proves eq   (UINT_SUCC (UINT_MUL (UINT_SUCC UINT_ZERO) y))    (UINT_SUCC (UINT_ADD (UINT_MUL UINT_ZERO y) y))
			by temp1 > ((zero_is_uint > hypoth_) > un_sub_arg) > bin_sub_right_impl;
			
			require temp3 proves eq   (UINT_SUCC (UINT_ADD (UINT_MUL (UINT_SUCC UINT_ZERO) y) UINT_ZERO))    (UINT_SUCC (UINT_ADD (UINT_MUL UINT_ZERO y) y))
			by temp2 > (((
				
				// (UINT_MUL (UINT_SUCC UINT_ZERO) y) is a uint:
				(
					yuint > (zero_is_uint > succ_uint_is_uint) > uint_mul_uint_is_uint
				)
				
				 > add_zero) > eq_comm) > un_sub_arg) > bin_sub_left_impl;
			
			
			require temp4 proves eq   (UINT_SUCC (UINT_ADD (UINT_MUL (UINT_SUCC UINT_ZERO) y) UINT_ZERO))     (UINT_SUCC (UINT_ADD (UINT_ADD (UINT_MUL UINT_ZERO y) UINT_ZERO) y))
			by temp3 > (
				(
					(
						(
							(
								yuint > zero_is_uint > uint_mul_uint_is_uint
							)
							> add_zero
						)
						> eq_comm
					)
					> bin_sub_left_eq
				)
				> un_sub_arg
			) > bin_sub_right_impl;
			
			temp4
		);
		
		require casesucc2 proves forany x: HAS_MEMBER UINT x -> SuccMulFunc2 x -> SuccMulFunc2 (UINT_SUCC x)
		by (
			forany x:
			assume xuint proves x : UINT;
			assume hypoth2 proves SuccMulFunc2 x;
			wrap SuccMulFunc2 (
				// succ (succ ((succ f * bb + bb) + f))  =  succ (succ ((succ f * bb + bb) + f))
				require temp1 proves eq    (UINT_ADD (UINT_ADD (UINT_MUL (UINT_SUCC x) y) y) x)    (UINT_ADD (UINT_ADD (UINT_MUL (UINT_SUCC x) y) y) x)
				by eq_same;
				
				// (succ f * bb + bb)   >   succ (succ f) * bb
				// (UINT_ADD (UINT_MUL (UINT_SUCC x) y) y)    >     (UINT_MUL (UINT_SUCC (UINT_SUCC x)) y)
				require temp2 proves eq    (UINT_ADD (UINT_MUL (UINT_SUCC (UINT_SUCC x)) y) x)    (UINT_ADD (UINT_ADD (UINT_MUL (UINT_SUCC x) y) y) x)
				by temp1 > (
					(((xuint > succ_uint_is_uint) > hypoth_) > eq_comm) > bin_sub_left_eq
				) > bin_sub_left_impl;
				
				
				// (succ f * bb + bb) + f    >   succ f * bb + (bb + f)
				require temp3 proves eq    (UINT_ADD (UINT_MUL (UINT_SUCC (UINT_SUCC x)) y) x)    (UINT_ADD (UINT_MUL (UINT_SUCC x) y) (UINT_ADD y x))
				by temp2 > (
					xuint > yuint > (yuint > (xuint > succ_uint_is_uint) > uint_mul_uint_is_uint) > add_assoc
				) > bin_sub_right_impl;
				
				
				// succ f * bb + (bb + f)    >   succ f * bb + (f + bb)
				require temp4 proves eq    (UINT_ADD (UINT_MUL (UINT_SUCC (UINT_SUCC x)) y) x)    (UINT_ADD (UINT_MUL (UINT_SUCC x) y) (x + y))
				by temp3 > (
					(xuint > yuint > add_comm) > bin_sub_right_eq
				) > bin_sub_right_impl;
				
				
				// succ f * bb + (f + bb)    >   (succ f * bb + f) + bb
				require temp5 proves eq    (UINT_ADD (UINT_MUL (UINT_SUCC (UINT_SUCC x)) y) x)    (UINT_ADD (UINT_ADD (UINT_MUL (UINT_SUCC x) y) x) y)
				by temp4 > (
					(yuint > xuint > (yuint > (xuint > succ_uint_is_uint) > uint_mul_uint_is_uint) > add_assoc) > eq_comm
				) > bin_sub_right_impl;
				
				
				
				require temp6 proves eq    (UINT_SUCC (UINT_ADD (UINT_MUL (UINT_SUCC (UINT_SUCC x)) y) x))    (UINT_SUCC (UINT_ADD (UINT_ADD (UINT_MUL (UINT_SUCC x) y) x) y))
				by temp5 > wrap_in_func_impl;
				
				
				// succ ((succ f * bb + f) + bb)    >   succ (succ f * bb + f) + bb
				require temp7 proves eq    (UINT_SUCC (UINT_ADD (UINT_MUL (UINT_SUCC (UINT_SUCC x)) y) x))    (UINT_ADD (UINT_SUCC (UINT_ADD (UINT_MUL (UINT_SUCC x) y) x)) y)
				by temp6 > (
					(
						yuint
						>
						(
							xuint
							>
							(
								yuint
								>
								(xuint > succ_uint_is_uint)
								>
								uint_mul_uint_is_uint
							)
							>
							uint_add_uint_is_uint
						)
						>
						succ_add
					) > eq_comm
				) > bin_sub_right_impl;
				
				
				// succ (succ f * bb + f) + bb    >    (succ f * bb + succ f) + bb
				require temp8 proves eq    (UINT_SUCC (UINT_ADD (UINT_MUL (UINT_SUCC (UINT_SUCC x)) y) x))    (UINT_ADD (UINT_ADD (UINT_MUL (UINT_SUCC x) y) (UINT_SUCC x)) y)
				by (
					temp7 >
					(
						(
							(
								xuint
								>
								(
									yuint
									>
									(xuint > succ_uint_is_uint)
									>
									uint_mul_uint_is_uint
								)
								>
								add_succ
							)
							> eq_comm
						)
						>
						bin_sub_left_eq
					)
					> bin_sub_right_impl
				);
				
				
				
				
				
				// succ (succ (succ f) * bb + f)    >    succ (succ f) * bb + (succ f)
				require temp9 proves eq    (UINT_ADD (UINT_MUL (UINT_SUCC (UINT_SUCC x)) y) (UINT_SUCC x))    (UINT_ADD (UINT_ADD (UINT_MUL (UINT_SUCC x) y) (UINT_SUCC x)) y)
				by (
					temp8
					>
					(
						(
							xuint
							>
							(
								yuint
								>
								((xuint > succ_uint_is_uint) > succ_uint_is_uint)
								>
								uint_mul_uint_is_uint
							)
							>
							add_succ
						)
						>
						eq_comm
					)
					>
					bin_sub_left_impl
				);
				
				// Goal:
				// eq   (UINT_SUCC (UINT_ADD (UINT_MUL (UINT_SUCC (UINT_SUCC x)) y) (UINT_SUCC x)))     (UINT_SUCC (UINT_ADD (UINT_ADD (UINT_MUL (UINT_SUCC x) y) (UINT_SUCC x)) y));
				temp9 > wrap_in_func_impl
			)
		);
				
		wrap SuccMulFunc (
			forany x:
			assume xuint proves x : UINT;
			
			require temp1 proves eq   (UINT_SUCC (UINT_ADD (UINT_MUL (UINT_SUCC x) y) x))     (UINT_SUCC (UINT_ADD (UINT_ADD (UINT_MUL x y) x) y))
			by unwrap SuccMulFunc2 (xuint > casesucc2 > casezero2 > uint_inductive);
			
			require temp2 proves eq   (UINT_ADD (UINT_MUL (UINT_SUCC x) y) (UINT_SUCC x))     (UINT_SUCC (UINT_ADD (UINT_ADD (UINT_MUL x y) x) y))
			by (
				temp1
				>
				(
					(
						xuint
						>
						(
							yuint
							>
							(xuint > succ_uint_is_uint)
							>
							uint_mul_uint_is_uint
						)
						>
						add_succ
					) > eq_comm
				)
				>
				bin_sub_left_impl
			);
			
			require temp3 proves eq   (UINT_ADD (UINT_MUL (UINT_SUCC x) y) (UINT_SUCC x))     (UINT_ADD (UINT_ADD (UINT_MUL x y) x) (UINT_SUCC y))
			by (
				temp2
				>
				(
					(
						yuint
						>
						( // (UINT_ADD (UINT_MUL x y) x)
							xuint
							>
							(yuint > xuint > uint_mul_uint_is_uint)
							>
							uint_add_uint_is_uint
						)
						>
						add_succ
					) > eq_comm
				)
				>
				bin_sub_right_impl
			);
			
			require temp4 proves eq   (UINT_ADD (UINT_MUL (UINT_SUCC x) y) (UINT_SUCC x))     (UINT_ADD (UINT_MUL x (UINT_SUCC y)) (UINT_SUCC y))
			by (
				temp3
				>
				(
					(
						(
							yuint
							>
							xuint
							>
							mul_succ
						)
						>
						eq_comm
					)
					>
					bin_sub_left_eq
				)
				>
				bin_sub_right_impl
			);
			
			require temp5 proves eq   (UINT_MUL (UINT_SUCC x) (UINT_SUCC y))     (UINT_ADD (UINT_MUL x (UINT_SUCC y)) (UINT_SUCC y))
			by (
				temp4
				>
				(
					(
						yuint
						>
						(xuint > succ_uint_is_uint)
						>
						mul_succ
					)
					>
					eq_comm
				)
				>
				bin_sub_left_impl
			);
			
			/*
			Goal: succ (succ a * bb + a)  =  succ ((a * bb + a) + bb)
			| add_succ
			Goal: succ a * bb + succ a  =  (a * bb + a) + succ bb
			| mul_succ
			Goal: succ a * bb + succ a  =  a * succ bb + succ bb
			| mul_succ
			Goal: succ a * succ bb  =  a * succ bb + succ bb
			*/
			
			temp5
		)
		
		
		
		// We need:
		// forany x: (HAS_MEMBER UINT x) -> eq (UINT_MUL (UINT_SUCC x) (UINT_SUCC y)) (UINT_ADD (UINT_MUL x (UINT_SUCC y)) (UINT_SUCC y));
	);
	
	auint > unwrap SuccMulFunc (buint > casesucc > casezero > uint_inductive)
);

require mul_comm proves forany a,b: (a : UINT)  ->  (b : UINT)  ->  (a * b) == (b * a)
by (
	forany a,b:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	
	define MulCommFunc x = forany y: (HAS_MEMBER UINT y) -> eq (UINT_MUL x y) (UINT_MUL y x);
	
	require casezero proves MulCommFunc UINT_ZERO
	by wrap MulCommFunc (
		forany y:
		assume yuint proves y : UINT;
		require temp proves eq UINT_ZERO UINT_ZERO  by eq_same;
		
		(temp > ((yuint > zero_mul) > eq_comm) > bin_sub_left_impl)
		> ((yuint > mul_zero) > eq_comm) > bin_sub_right_impl
	);
	
	require casesucc proves forany x: (HAS_MEMBER UINT x) -> MulCommFunc x -> MulCommFunc (UINT_SUCC x)
	by (
		forany x:
		assume xuint proves x : UINT;
		assume hypoth proves MulCommFunc x;
		
		require hypoth_ proves forany y: (HAS_MEMBER UINT y) -> eq (UINT_MUL x y) (UINT_MUL y x)
		by unwrap MulCommFunc hypoth;
		
		wrap MulCommFunc (
			forany y:
			assume yuint proves y : UINT;
			
			require temp1 proves  eq  (UINT_ADD (UINT_MUL y x) y)  (UINT_ADD (UINT_MUL y x) y)
			by eq_same;
			
			require temp2 proves  eq  (UINT_ADD (UINT_MUL x y) y)  (UINT_ADD (UINT_MUL y x) y)
			by temp1 > (
				((yuint > hypoth_) > eq_comm) > bin_sub_left_eq
			) > bin_sub_left_impl;
			
			require temp3 proves  eq  (UINT_MUL (UINT_SUCC x) y)  (UINT_ADD (UINT_MUL y x) y)
			by temp2 > (
				(
					yuint
					>
					xuint
					>
					succ_mul
				)
				>
				eq_comm
			) > bin_sub_left_impl;
			
			require temp4 proves  eq  (UINT_MUL (UINT_SUCC x) y)  (UINT_MUL y (UINT_SUCC x))
			by temp3 > (
				(
					xuint
					>
					yuint
					>
					mul_succ
				)
				>
				eq_comm
			) > bin_sub_right_impl;
			
			temp4
		)
	);
	
	buint > unwrap MulCommFunc (auint > casesucc > casezero > uint_inductive)
);

require one_mul proves forany a: (a : UINT)  ->  (UINT_ONE * a) == a
by (
	forany a:
	assume auint proves (a : UINT);
	(eq_same > ((auint > mul_one) > eq_comm) > bin_sub_left_impl) > (one_is_uint > auint > mul_comm) > bin_sub_left_impl
);





require mul_add proves forany a,b,c: (a : UINT)  ->  (b : UINT)  ->  (c : UINT)  ->  (a * (b + c)) == ((a * b) + (a * c))
by (
	define MulAddFunc c = forany a,b: (a : UINT) -> (b : UINT) -> eq   (UINT_MUL a (b + c))    (UINT_ADD (UINT_MUL a b) (UINT_MUL a c));
	
	require casezero proves MulAddFunc UINT_ZERO
	by wrap MulAddFunc (
		forany a,b:
		assume auint proves a : UINT;
		assume buint proves b : UINT;
		
		require temp1 proves eq (UINT_MUL a b) (UINT_MUL a b)
		by eq_same;
		
		require temp2 proves eq (UINT_MUL a b) (UINT_ADD (UINT_MUL a b) UINT_ZERO)
		by temp1 > (((buint > auint > uint_mul_uint_is_uint) > add_zero) > eq_comm) > bin_sub_right_impl;
		
		require temp3 proves eq (UINT_MUL a b) (UINT_ADD (UINT_MUL a b) (UINT_MUL a UINT_ZERO))
		by temp2 > (((auint > mul_zero) > eq_comm) > bin_sub_right_eq) > bin_sub_right_impl;
		
		require temp4 proves eq (UINT_MUL a (UINT_ADD b UINT_ZERO)) (UINT_ADD (UINT_MUL a b) (UINT_MUL a UINT_ZERO))
		by temp3 > (((buint > add_zero) > eq_comm) > bin_sub_right_eq) > bin_sub_left_impl;
		
		temp4
	);
	
	require casesucc proves forany c: (c : UINT) -> MulAddFunc c -> MulAddFunc (UINT_SUCC c)
	by (
		forany c:
		assume cuint proves c : UINT;
		assume hypoth proves MulAddFunc c;
		require hypoth_ proves forany a,b: (a : UINT) -> (b : UINT) -> eq   (UINT_MUL a (b + c))    (UINT_ADD (UINT_MUL a b) (UINT_MUL a c))
		by unwrap MulAddFunc hypoth;
		
		wrap MulAddFunc (
			forany a,b:
			assume auint proves a : UINT;
			assume buint proves b : UINT;
			
			// Goal:
			// eq   (UINT_MUL a (UINT_ADD b (UINT_SUCC c)))    (UINT_ADD (UINT_MUL a b) (UINT_MUL a (UINT_SUCC c)))
			
			require temp1 proves eq    (UINT_ADD (UINT_ADD (UINT_MUL a b) (UINT_MUL a c)) a)    (UINT_ADD (UINT_ADD (UINT_MUL a b) (UINT_MUL a c)) a)
			by eq_same;
			
			require temp2 proves eq    (UINT_ADD (UINT_MUL a (b + c)) a)        (UINT_ADD (UINT_ADD (UINT_MUL a b) (UINT_MUL a c)) a)
			by temp1 > (
				(
					(buint > auint > hypoth_) > eq_comm
				)
				>
				bin_sub_left_eq
			) > bin_sub_left_impl;
			
			require temp3 proves eq    (UINT_ADD (UINT_MUL a (b + c)) a)        (UINT_ADD (UINT_MUL a b) (UINT_ADD (UINT_MUL a c) a))
			by temp2 > (
				auint
				>
				(cuint > auint > uint_mul_uint_is_uint)
				>
				(buint > auint > uint_mul_uint_is_uint)
				>
				add_assoc
			) > bin_sub_right_impl;
			
			require temp4 proves eq    (UINT_ADD (UINT_MUL a (b + c)) a)        (UINT_ADD (UINT_MUL a b) (UINT_MUL a (UINT_SUCC c)))
			by temp3 > (
				((cuint
				>
				auint
				>
				mul_succ) > eq_comm) > bin_sub_right_eq
			) > bin_sub_right_impl;
			
			require temp5 proves eq    (UINT_MUL a (UINT_SUCC (b + c)))        (UINT_ADD (UINT_MUL a b) (UINT_MUL a (UINT_SUCC c)))
			by temp4 > (
				(
					(cuint > buint > uint_add_uint_is_uint)
					>
					auint
					>
					mul_succ
				)
				>
				eq_comm
			) > bin_sub_left_impl;
			
			require temp6 proves eq    (UINT_MUL a (UINT_ADD b (UINT_SUCC c)))        (UINT_ADD (UINT_MUL a b) (UINT_MUL a (UINT_SUCC c)))
			by temp5 > (
				(
					(
						cuint
						>
						buint
						>
						add_succ
					)
					>
					eq_comm
				)
				>
				bin_sub_right_eq
			) > bin_sub_left_impl;
			
			temp6
		)
	);
	
	forany a,b,c:
	assume auint proves (a : UINT);
	assume buint proves (b : UINT);
	assume cuint proves (c : UINT);
	
	buint > auint > unwrap MulAddFunc (cuint > (casesucc > casezero > uint_inductive))
);


require add_mul proves forany a,b,c: (a : UINT)  ->  (b : UINT)  ->  (c : UINT)  ->  ((a + b) * c) == ((a * c) + (b * c))
by (
	forany a,b,c:
	assume auint proves (a : UINT);
	assume buint proves (b : UINT);
	assume cuint proves (c : UINT);
	
	require temp1 proves eq    (UINT_MUL c (a + b))    (UINT_ADD (UINT_MUL c a) (UINT_MUL c b))
	by buint > auint > cuint > mul_add;
	
	require temp2 proves eq    (UINT_MUL (a + b) c)    (UINT_ADD (UINT_MUL c a) (UINT_MUL c b))
	by temp1 > (
		(buint > auint > uint_add_uint_is_uint)
		>
		cuint
		>
		mul_comm
	) > bin_sub_left_impl;
	
	require temp3 proves eq    (UINT_MUL (a + b) c)    (UINT_ADD (UINT_MUL a c) (UINT_MUL c b))
	by temp2 > (
		(
			auint
			>
			cuint
			>
			mul_comm
		)
		>
		bin_sub_left_eq
	) > bin_sub_right_impl;
	
	require temp4 proves eq    (UINT_MUL (a + b) c)    (UINT_ADD (UINT_MUL a c) (UINT_MUL b c))
	by temp3 > (
		(
			buint
			>
			cuint
			>
			mul_comm
		)
		>
		bin_sub_right_eq
	) > bin_sub_right_impl;
	
	temp4
);

require mul_assoc proves forany a,b,c: (a : UINT) -> (b : UINT) -> (c : UINT) ->  ((a * b) * c) == (a * (b * c))
by (
	define MulAssocFunc b = forany a,c: (a : UINT) -> (c : UINT) -> eq    (UINT_MUL (UINT_MUL a b) c)    (UINT_MUL a (UINT_MUL b c));
	
	require casezero proves MulAssocFunc UINT_ZERO
	by wrap MulAssocFunc (
		forany a,c:
		assume auint proves (a : UINT);
		assume cuint proves (c : UINT);
		
		// Goal:
		// eq    (UINT_MUL (UINT_MUL a UINT_ZERO) c)    (UINT_MUL a (UINT_MUL UINT_ZERO c))
		
		require temp1 proves eq UINT_ZERO UINT_ZERO
		by eq_same;
		
		require temp2 proves eq (UINT_MUL UINT_ZERO c)   UINT_ZERO
		by temp1 > (
			(cuint > zero_mul) > eq_comm
		) > bin_sub_left_impl;
		
		require temp3 proves eq (UINT_MUL (UINT_MUL a UINT_ZERO) c)   UINT_ZERO
		by temp2 > (
			((auint > mul_zero) > eq_comm)
			> bin_sub_left_eq
		) > bin_sub_left_impl;
		
		require temp4 proves eq (UINT_MUL (UINT_MUL a UINT_ZERO) c)   (UINT_MUL a UINT_ZERO)
		by temp3 > (
			(auint > mul_zero) > eq_comm
		) > bin_sub_right_impl;
		
		require temp5 proves eq (UINT_MUL (UINT_MUL a UINT_ZERO) c)   (UINT_MUL a (UINT_MUL UINT_ZERO c))
		by temp4 > (
			((cuint > zero_mul) > eq_comm)
			> bin_sub_right_eq
		) > bin_sub_right_impl;
		
		temp5
	);
	
	require casesucc proves forany b: (b : UINT) -> MulAssocFunc b -> MulAssocFunc (UINT_SUCC b)
	by (
		forany b:
		assume buint proves b : UINT;
		assume hypoth proves MulAssocFunc b;
		require hypoth_ proves forany a,c: (a : UINT) -> (c : UINT) -> eq    (UINT_MUL (UINT_MUL a b) c)    (UINT_MUL a (UINT_MUL b c))
		by unwrap MulAssocFunc hypoth;
		
		
		wrap MulAssocFunc (
			forany a,c:
			assume auint proves (a : UINT);
			assume cuint proves (c : UINT);
			
			// Goal:
			// eq    (UINT_MUL (UINT_MUL a (UINT_SUCC b)) c)    (UINT_MUL a (UINT_MUL (UINT_SUCC b) c))
			
			// a * (bb * c) + a * c = a * (bb * c) + a * c
			require temp1 proves eq    (UINT_ADD (UINT_MUL a (UINT_MUL b c)) (UINT_MUL a c))    (UINT_ADD (UINT_MUL a (UINT_MUL b c)) (UINT_MUL a c))
			by eq_same;
			
			require temp2 proves eq    (UINT_ADD (UINT_MUL (UINT_MUL a b) c) (UINT_MUL a c))    (UINT_ADD (UINT_MUL a (UINT_MUL b c)) (UINT_MUL a c))
			by temp1 > (
				((cuint > auint > hypoth_) > eq_comm)
				>
				bin_sub_left_eq
			) > bin_sub_left_impl;
			
			require temp3 proves eq    (UINT_MUL (UINT_ADD (UINT_MUL a b) a) c)    (UINT_ADD (UINT_MUL a (UINT_MUL b c)) (UINT_MUL a c))
			by temp2 > (
				(
					cuint
					>
					auint
					>
					(buint > auint > uint_mul_uint_is_uint)
					>
					add_mul
				) > eq_comm
			) > bin_sub_left_impl;
			
			require temp4 proves eq    (UINT_MUL (UINT_ADD (UINT_MUL a b) a) c)    (UINT_MUL a (UINT_ADD (UINT_MUL b c) c))
			by temp3 > (
				(
					cuint
					>
					(cuint > buint > uint_mul_uint_is_uint)
					>
					auint
					>
					mul_add
				) > eq_comm
			) > bin_sub_right_impl;
			
			require temp5 proves eq    (UINT_MUL (UINT_MUL a (UINT_SUCC b)) c)    (UINT_MUL a (UINT_ADD (UINT_MUL b c) c))
			by temp4 > (
				(
					(
						buint
						>
						auint
						>
						mul_succ
					) > eq_comm
				) > bin_sub_left_eq
			) > bin_sub_left_impl;
			
			require temp6 proves eq    (UINT_MUL (UINT_MUL a (UINT_SUCC b)) c)    (UINT_MUL a (UINT_MUL (UINT_SUCC b) c))
			by temp5 > (
				(
					(
						cuint
						>
						buint
						>
						succ_mul
					) > eq_comm
				) > bin_sub_right_eq
			) > bin_sub_right_impl;
			
			
			temp6
		)
	);
	
	forany a,b,c:
	assume auint proves (a : UINT);
	assume buint proves (b : UINT);
	assume cuint proves (c : UINT);
	
	cuint > auint > unwrap MulAssocFunc (buint > casesucc > casezero > uint_inductive)
);

require mul_not_zero__left_not_zero proves forany a,b: (a : UINT)  ->  (b : UINT)  ->  ((a * b) != UINT_ZERO)  ->  (a != UINT_ZERO)
by (
	forany a,b,c:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	assume ab_not_zero proves eq (UINT_MUL a b) UINT_ZERO -> FALSE;
	assume a_zero proves eq a UINT_ZERO;
	
	(
		((substitute a=UINT_ZERO in eq_same) > ((buint > zero_mul) > eq_comm) > bin_sub_left_impl)
		>
		((a_zero > eq_comm) > bin_sub_left_eq)
		>
		bin_sub_left_impl
	)
	>
	ab_not_zero
);

require both_not_zero__mul_not_zero proves forany a,b: (a : UINT) -> (b : UINT) -> (a != UINT_ZERO) -> (b != UINT_ZERO) -> ((a * b) != UINT_ZERO)
by (
	forany a,b,c:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	assume a_not_0 proves eq a UINT_ZERO -> FALSE;
	assume b_not_0 proves eq b UINT_ZERO -> FALSE;
	assume ab_0 proves eq (UINT_MUL a b) UINT_ZERO;
	
	// Goal:
	// FALSE
	
	require a_is_succ proves (forany x: HAS_MEMBER UINT x -> eq a (UINT_SUCC x) -> FALSE) -> FALSE
	by or__not_left__right < (uint_is_zero_or_succ < auint) < a_not_0;
	
	require b_is_succ proves (forany y: HAS_MEMBER UINT y -> eq b (UINT_SUCC y) -> FALSE) -> FALSE
	by or__not_left__right < (uint_is_zero_or_succ < buint) < b_not_0;
	
	a_is_succ < (
		// Goal:
		// forany x: HAS_MEMBER UINT x -> eq a (UINT_SUCC x) -> FALSE
		
		forany x:
		assume xuint proves x : UINT;
		assume a_sx proves eq a (UINT_SUCC x);
		
		// Goal:
		// FALSE
		
		b_is_succ < (
			forany y:
			assume yuint proves y : UINT;
			assume b_sy proves eq b (UINT_SUCC y);
			
			// Goal:
			// FALSE
			
			require sx_sy__0 proves eq (UINT_MUL (UINT_SUCC x) (UINT_SUCC y)) UINT_ZERO
			by (ab_0 > (a_sx > bin_sub_left_eq) > bin_sub_left_impl) > (b_sy > bin_sub_right_eq) > bin_sub_left_impl;
			
			require tempp proves eq (UINT_SUCC (UINT_ADD (UINT_MUL x (UINT_SUCC y)) y)) UINT_ZERO
			by (sx_sy__0 > (succ_mul < xuint < (succ_uint_is_uint < yuint)) > bin_sub_left_impl) > (add_succ < (uint_mul_uint_is_uint < xuint < (succ_uint_is_uint < yuint)) < yuint) > bin_sub_left_impl;
			
			tempp > (succ_not_zero < (uint_add_uint_is_uint < (uint_mul_uint_is_uint < xuint < (succ_uint_is_uint < yuint)) < yuint))
		)
	)
);

require mul_is_zero__either_is_zero proves forany a,b: (a : UINT) -> (b : UINT) -> (eq (UINT_MUL a b) UINT_ZERO) -> or (eq a UINT_ZERO) (eq b UINT_ZERO)
by (
	forany a,b,c:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	assume ab_0 proves eq (UINT_MUL a b) UINT_ZERO;
	wrap or (
		assume ttt proves AND (eq a UINT_ZERO -> FALSE) (eq b UINT_ZERO -> FALSE);
		
		// Goal:
		// FALSE
		
		both_not_zero__mul_not_zero < auint < buint < (ttt > and_left) < (ttt > and_right) < ab_0
	)
);





require uint_pow_uint_is_uint proves forany a,b: (a : UINT) -> (b : UINT) -> (HAS_MEMBER UINT (UINT_POW a b))
by (
	forany a,b,c:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	
	define Func bb = HAS_MEMBER UINT (UINT_POW a bb);
	
	require casezero proves Func UINT_ZERO
	by wrap Func (
		one_is_uint > ((pow_zero < auint) > eq_comm) > bin_sub_right_impl
	);
	
	require casesucc proves forany bb: HAS_MEMBER UINT bb -> Func bb -> Func (UINT_SUCC bb)
	by (
		forany bb:
		assume bbuint proves HAS_MEMBER UINT bb;
		assume ttt proves Func bb;
		wrap Func (
			(uint_mul_uint_is_uint < unwrap Func ttt < auint) > ((pow_succ < auint < bbuint) > eq_comm) > bin_sub_right_impl
		)
	);
	
	unwrap Func (uint_inductive < casezero < casesucc < buint)
);

require zero_pow_succ proves forany a: (a : UINT) -> (UINT_ZERO ** (a++)) == UINT_ZERO
by (
	forany a:
	assume auint proves a : UINT;
	
	((substitute a=UINT_ZERO in eq_same) > ((mul_zero < (uint_pow_uint_is_uint < zero_is_uint < auint)) > eq_comm) > bin_sub_left_impl)
	>
	((pow_succ < zero_is_uint < auint) > eq_comm)
	>
	bin_sub_left_impl
);

require pow_one proves forany a: (a : UINT) ->  (a ** UINT_ONE) == a
by (
	forany a:
	assume auint proves a : UINT;
	
	(
		(
			(eq_same > ((auint > one_mul) > eq_comm) > bin_sub_left_impl)
			>
			(((pow_zero < auint) > eq_comm) > bin_sub_left_eq)
			>
			bin_sub_left_impl
		)
		>
		((pow_succ < auint < zero_is_uint) > eq_comm)
		>
		bin_sub_left_impl
	)
	>
	((uint_one_eq_succ_zero > eq_comm) > bin_sub_right_eq)
	>
	bin_sub_left_impl
);

require one_pow proves forany a: (a : UINT) ->  (UINT_ONE ** a) == UINT_ONE
by (
	define Func aa = eq (UINT_POW UINT_ONE aa) UINT_ONE;
	
	require casezero proves Func UINT_ZERO
	by wrap Func (
		pow_zero < one_is_uint
	);
	
	require casesucc proves forany aa: (HAS_MEMBER UINT aa) -> Func aa -> Func (UINT_SUCC aa)
	by (
		forany aa:
		assume aauint proves HAS_MEMBER UINT aa;
		assume ttt proves Func aa;
		require ttt_ proves eq (UINT_POW UINT_ONE aa) UINT_ONE
		by unwrap Func ttt;
		wrap Func (
			// Goal:
			// eq (UINT_POW UINT_ONE (UINT_SUCC aa)) UINT_ONE;
			
			(ttt_ > ((mul_one < (uint_pow_uint_is_uint < one_is_uint < aauint)) > eq_comm) > bin_sub_left_impl)
			>
			((pow_succ < one_is_uint < aauint) > eq_comm)
			>
			bin_sub_left_impl
		)
	);
	
	forany a:
	assume auint proves a : UINT;
	
	unwrap Func (auint > (uint_inductive < casezero < casesucc))
);

require pow_two proves forany a: (a : UINT) ->  (a ** UINT_TWO) == (a * a)
by (
	forany a:
	assume auint proves a : UINT;
	
	require aa_aa proves eq (UINT_MUL a a) (UINT_MUL a a)
	by eq_same;
	
	require a1a_aa proves eq (UINT_MUL (UINT_POW a UINT_ONE) a) (UINT_MUL a a)
	by aa_aa > (((pow_one < auint) > eq_comm) > bin_sub_left_eq) > bin_sub_left_impl;
	
	require as1_aa proves eq (UINT_POW a (UINT_SUCC UINT_ONE)) (UINT_MUL a a)
	by a1a_aa > ((pow_succ < auint < one_is_uint) > eq_comm) > bin_sub_left_impl;
	
	as1_aa > ((uint_two_eq_succ_one > eq_comm) > bin_sub_right_eq) > bin_sub_left_impl
);

require pow_add proves forany a,b,c: (a : UINT) -> (b : UINT) -> (c : UINT)  ->  (a ** (b + c)) == ((a ** b) * (a ** c))
by (
	forany a,b,c:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	assume cuint proves c : UINT;
	
	define Func cc = (a ** (b + cc)) == ((a ** b) * (a ** cc));
	
	require casezero proves Func UINT_ZERO
	by wrap Func (
		require temp1 proves (a ** (b + UINT_ZERO)) == (a ** b)
		by (
			(substitute a=(a ** b) in eq_same)
			>
			(((buint > add_zero) > eq_comm) > bin_sub_right_eq)
			>
			bin_sub_left_impl
		);
		require temp2 proves (a ** (b + UINT_ZERO)) == (a ** b) * UINT_ONE
		by (
			temp1 > (((uint_pow_uint_is_uint < auint < buint) > mul_one) > eq_comm) > bin_sub_right_impl
		);
		temp2 > (((auint > pow_zero) > eq_comm) > bin_sub_right_eq) > bin_sub_right_impl
	);
	
	require casesucc proves forany cc: cc : UINT -> Func cc -> Func (cc++)
	by (
		forany cc:
		assume ccuint proves cc : UINT;
		assume hypoth proves Func cc;
		require hypoth_ proves (a ** (b + cc)) == ((a ** b) * (a ** cc))
		by unwrap Func hypoth;
		wrap Func (
			// Goal:  (a ** (b + cc++)) == ((a ** b) * (a ** cc++))
			
			bin_sub_left_impl < (((add_succ < buint < ccuint) > eq_comm) > bin_sub_right_eq) < (
			
			// Goal:  (a ** (b + cc)++) == ((a ** b) * (a ** cc++))
			
			bin_sub_left_impl < ((pow_succ < auint < (uint_add_uint_is_uint < buint < ccuint)) > eq_comm) < (
			
			// Goal:  (a ** (b + cc)) * a == ((a ** b) * (a ** cc++))
			
			bin_sub_right_impl < (bin_sub_right_eq < ((pow_succ < auint < ccuint) > eq_comm)) < (
			
			// Goal:  (a ** (b + cc)) * a == ((a ** b) * ((a ** cc) * a))
			
			bin_sub_left_impl < (bin_sub_left_eq < (hypoth_ > eq_comm)) < (
			
			// Goal:  ((a ** b) * (a ** cc)) * a == (a ** b) * ((a ** cc) * a)
			
			bin_sub_right_impl < (mul_assoc < (uint_pow_uint_is_uint < auint < buint) < (uint_pow_uint_is_uint < auint < ccuint) < auint) < (
			
			// Goal:  ((a ** b) * (a ** cc)) * a == ((a ** b) * (a ** cc)) * a
			
			eq_same
			
			)))))
		)
	);
	
	unwrap Func (uint_inductive < casezero < casesucc < cuint)
);


























require by_example proves forany F,a: F a -> ((forany b: (F b -> FALSE)) -> FALSE)
by (
	forany F,a:
	assume FA proves F a;
	assume H proves forany b: (F b -> FALSE);
	FA > H
);

require exist_impl proves
	forany F,G:
		((forany x: (F x -> FALSE)) -> FALSE) ->
		(forany y: F y -> G y) ->
		((forany z: (G z -> FALSE)) -> FALSE)
by (
	forany F,G:
	assume exist_fx proves (forany x: (F x -> FALSE)) -> FALSE;
	assume fy_gy proves forany y: F y -> G y;
	assume notexist_gz proves forany z: (G z -> FALSE);
	(notexist_gz > (fy_gy > impl_reverse)) > exist_fx
);

require exist_exist_impl proves
	forany F,G,H:
		((forany x1: (F x1 -> FALSE)) -> FALSE) ->
		((forany x2: (G x2 -> FALSE)) -> FALSE) ->
		(forany y1,y2: F y1 -> G y2 -> H y1 y2) ->
		((forany z1,z2: (H z1 z2 -> FALSE)) -> FALSE)
by (
	forany F,G,H:
	assume exist_fx1 proves (forany x1: (F x1 -> FALSE)) -> FALSE;
	assume exist_gx2 proves (forany x2: (G x2 -> FALSE)) -> FALSE;
	assume f_g_h proves forany y1,y2: F y1 -> G y2 -> H y1 y2;
	assume not_h proves forany z1,z2: (H z1 z2 -> FALSE);
	
	define GHFunc yyy1 = (forany yyy2: G yyy2 -> H yyy1 yyy2);
	
	require ttt1 proves forany y1: F y1 -> GHFunc y1
	by (
		forany y1:
		assume Fy1 proves F y1;
		wrap GHFunc ((Fy1 > f_g_h))
	);
	
	require ttt2 proves ((forany yy1: GHFunc yy1 -> FALSE) -> FALSE)
	by ttt1 > exist_fx1 > exist_impl;
	
	require ttt3 proves (forany yy1: (forany yyy2: G yyy2 -> H yy1 yyy2) -> FALSE) -> FALSE
	by (
		assume ttt proves forany yy1: (forany yyy2: G yyy2 -> H yy1 yyy2) -> FALSE;
		
		// Goal:
		// FALSE
		
		require qqqq proves forany yyyy1: GHFunc yyyy1 -> FALSE
		by (
			forany yyyy1:
			//print (substitute yy1=yyyy1 in ttt);     // (forany yyy2: G yyy2 -> H yyyy1 yyy2) -> FALSE;
			//print (substitute x=yyyy1 in funccc);    // forany yyy2: GHFunc yyyy1 -> (G yyy2 -> H yyyy1 yyy2)
			
			require tttt proves GHFunc yyyy1 -> FALSE
			by (
				assume ttttt proves GHFunc yyyy1;
				(unwrap GHFunc ttttt) > (substitute yy1=yyyy1 in ttt)
			);
			
			tttt
		);
		
		qqqq > ttt2
	);
	
	require ttt4 proves forany yy1: (forany yyy2: G yyy2 -> H yy1 yyy2) -> FALSE
	by (
		forany yy1:
		assume ttt proves forany yyy2: G yyy2 -> H yy1 yyy2;
		not_h > (ttt > exist_gx2 > exist_impl)
	);
	
	ttt4 > ttt3
);


require exist_example proves forany F,G: ((forany x: (F x -> FALSE)) -> FALSE) -> (forany xx: F xx -> G) -> G
by (
	forany F,G:
	assume exist_fx proves (forany x: (F x -> FALSE)) -> FALSE;
	assume fxx_g proves forany xx: F xx -> G;
	
	// Goal:
	// G
	
	(
		// Goal:
		// (G -> FALSE) -> FALSE
		
		assume not_g proves G -> FALSE;
		
		// Goal:
		// FALSE
		
		(not_g > fxx_g > impl_trans) > exist_fx
		
	) > not_not_impl
);



















require eq_le proves forany a,b: a:UINT -> b:UINT -> a==b -> a<=b
by (
	forany a,b:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	assume AB proves eq a b;
	wrap uint_le (
		assume temp1 proves forany c: (AND (c : UINT) (eq b (UINT_ADD a c))) -> FALSE;
		require temp2 proves forany c: (AND (c : UINT) (eq a (UINT_ADD a c))) -> FALSE
		by (
			forany c:
			assume ttt proves AND (c : UINT) (eq a (UINT_ADD a c));
			(ttt > (AB > bin_sub_left_eq) > bin_sub_right_impl) > temp1
		);
		(((auint > add_zero) > eq_comm) > zero_is_uint > impl_impl_and) > temp2
	)
);

require le_same proves forany a: (a : UINT) -> uint_le a a
by (
	forany a:
	assume auint proves a : UINT;
	eq_same > auint > auint > eq_le
);

require zero_le proves forany b: (b : UINT) -> uint_le UINT_ZERO b
by (
	forany b:
	assume buint proves b : UINT;
	wrap uint_le (
		assume temp1 proves forany c: (AND (c : UINT) (eq b (UINT_ADD UINT_ZERO c))) -> FALSE;
		
		(((buint > zero_add) > eq_comm) > buint > impl_impl_and) > temp1
	)
);


require le_to_le_succ proves forany a,b: (a : UINT) -> (b : UINT) -> uint_le a b -> uint_le a (UINT_SUCC b)
by (
	forany a,b:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	assume AB proves uint_le a b;
	require AB_ proves (forany c: (AND (c : UINT) (eq b (UINT_ADD a c))) -> FALSE) -> FALSE
	by unwrap uint_le AB;
	
	wrap uint_le (
		// Goal:
		// (forany c: (AND (c : UINT) (eq (UINT_SUCC b) (UINT_ADD a c))) -> FALSE) -> FALSE
		
		assume ttt proves forany c: (AND (c : UINT) (eq (UINT_SUCC b) (UINT_ADD a c))) -> FALSE;
		
		// Goal:
		// FALSE
		
		AB_ < (
			// Goal:
			// forany c: (AND (c : UINT) (eq b (UINT_ADD a c))) -> FALSE
			
			forany c:
			assume ttt2 proves (AND (c : UINT) (eq b (UINT_ADD a c)));
			
			// Goal:
			// FALSE
			
			require cuint proves HAS_MEMBER UINT c    by ttt2 > and_left;
			require b_ac proves eq b (UINT_ADD a c)    by ttt2 > and_right;
			
			ttt < (
				// Goal:
				// forSOME c: AND (c : UINT) (eq (UINT_SUCC b) (UINT_ADD a c))
				
				require succ_c_uint proves HAS_MEMBER UINT (UINT_SUCC c)
				by cuint > succ_uint_is_uint;
				
				require temp proves eq (UINT_SUCC b) (UINT_ADD a (UINT_SUCC c))
				by (
					(b_ac > wrap_in_func_impl)
					>
					((cuint > auint > add_succ) > eq_comm)
					>
					bin_sub_right_impl
				);
				
				temp > succ_c_uint > impl_impl_and
			)
		)
	)
);



require le_succ_self proves forany a: (a : UINT) -> uint_le a (UINT_SUCC a)
by (
	forany a:
	assume auint proves a : UINT;
	wrap uint_le (
		assume ttt proves forany c: (AND (c : UINT) (eq (UINT_SUCC a) (UINT_ADD a c))) -> FALSE;
		
		require temp proves eq (UINT_SUCC a) (UINT_SUCC a) by eq_same;
		
		(
			(
				(temp > (((auint > add_zero) > eq_comm) > un_sub_arg) > bin_sub_right_impl)
				>
				((zero_is_uint > auint > add_succ) > eq_comm)
				>
				bin_sub_right_impl
			)
			>
			(zero_is_uint > succ_uint_is_uint)
			>
			impl_impl_and
		)
		>
		ttt
	)
);


require le_zero__is_zero proves forany a: (a : UINT) -> uint_le a UINT_ZERO -> eq a UINT_ZERO
by (
	forany a:
	assume auint proves a : UINT;
	assume temp1 proves uint_le a UINT_ZERO;
	
	require temp2 proves (forany c: (AND (c : UINT) (eq UINT_ZERO (UINT_ADD a c))) -> FALSE) -> FALSE
	by unwrap uint_le temp1;
	
	define Func x   = (AND (HAS_MEMBER UINT x) (eq UINT_ZERO (UINT_ADD a x)));
	
	require temp3 proves (forany c: (Func c -> FALSE)) -> FALSE
	by (
		assume ttt1 proves forany x: Func x -> FALSE;
		require ttt2 proves forany x: (AND (HAS_MEMBER UINT x) (eq UINT_ZERO (UINT_ADD a x))) -> FALSE
		by (
			forany x:
			assume ttt3 proves (AND (HAS_MEMBER UINT x) (eq UINT_ZERO (UINT_ADD a x)));
			(wrap Func ttt3) > ttt1
		);
		ttt2 > temp2
	);
	
	require temp4 proves forany x: Func x -> eq a UINT_ZERO
	by (
		forany x:
		assume ttt1 proves Func x;
		require xuint proves HAS_MEMBER UINT x  by  (unwrap Func ttt1) > and_left;
		require ttt2 proves eq UINT_ZERO (UINT_ADD a x)  by  (unwrap Func ttt1) > and_right;
		
		((ttt2 > eq_comm) > xuint > auint > sum_zero_both_zero) > and_left
	);
	
	temp4 > temp3 > exist_example
);

require le_trans proves forany a,b,c: (a : UINT) -> (b : UINT) -> (c : UINT) ->  a <= b  ->  b <= c  ->  a <= c
by (
	forany a,b,c:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	assume cuint proves c : UINT;
	assume ab proves a <= b;
	assume bc proves b <= c;
	require ab_ proves (forany x: (AND (HAS_MEMBER UINT x) (eq b (UINT_ADD a x))) -> FALSE) -> FALSE
	by unwrap uint_le ab;
	require bc_ proves (forany y: (AND (HAS_MEMBER UINT y) (eq c (UINT_ADD b y))) -> FALSE) -> FALSE
	by unwrap uint_le bc;
	
	define TempFuncAB p = (AND (HAS_MEMBER UINT p) (eq b (UINT_ADD a p)));
	define TempFuncBC q = (AND (HAS_MEMBER UINT q) (eq c (UINT_ADD b q)));
	define TempFuncAC p q = (AND (HAS_MEMBER UINT (UINT_ADD p q)) (eq c (UINT_ADD a (UINT_ADD p q))));
	
	require ab__ proves (forany x: TempFuncAB x -> FALSE) -> FALSE
	by (
		assume temp1 proves forany x: TempFuncAB x -> FALSE;
		require temp2 proves forany p: (AND (HAS_MEMBER UINT p) (eq b (UINT_ADD a p))) -> FALSE
		by (
			forany p:
			assume tttt proves (AND (HAS_MEMBER UINT p) (eq b (UINT_ADD a p)));
			(wrap TempFuncAB tttt) > temp1
		);
		temp2 > ab_
	);	
	require bc__ proves (forany x: TempFuncBC x -> FALSE) -> FALSE
	by (
		assume temp1 proves forany x: TempFuncBC x -> FALSE;
		require temp2 proves forany q: (AND (HAS_MEMBER UINT q) (eq c (UINT_ADD b q))) -> FALSE
		by (
			forany q:
			assume tttt proves (AND (HAS_MEMBER UINT q) (eq c (UINT_ADD b q)));
			(wrap TempFuncBC tttt) > temp1
		);
		temp2 > bc_
	);
	require tempp proves forany p,q: TempFuncAB p -> TempFuncBC q -> TempFuncAC p q
	by (
		forany p,q:
		assume abp proves TempFuncAB p;
		assume bcq proves TempFuncBC q;
		require puint proves HAS_MEMBER UINT p by (unwrap TempFuncAB abp) > and_left;
		require quint proves HAS_MEMBER UINT q by (unwrap TempFuncBC bcq) > and_left;
		require b_ap proves eq b (UINT_ADD a p) by (unwrap TempFuncAB abp) > and_right;
		require c_bq proves eq c (UINT_ADD b q) by (unwrap TempFuncBC bcq) > and_right;
		require c_apq proves eq c (UINT_ADD (UINT_ADD a p) q)
		by (
			c_bq > (
				b_ap > bin_sub_left_eq
			) > bin_sub_right_impl
		);
		wrap TempFuncAC ((c_apq > (quint > puint > auint > add_assoc) > bin_sub_right_impl) > (quint > puint > uint_add_uint_is_uint) > impl_impl_and)
	);
	
	require temp2 proves (forany z1,z2: (TempFuncAC z1 z2 -> FALSE)) -> FALSE
	by tempp > bc__ > ab__ > exist_exist_impl;
	
	require temp3 proves (forany z1,z2: ((AND (HAS_MEMBER UINT (UINT_ADD z1 z2)) (eq c (UINT_ADD a (UINT_ADD z1 z2)))) -> FALSE)) -> FALSE
	by (
		assume ttt proves (forany z1,z2: ((AND (HAS_MEMBER UINT (UINT_ADD z1 z2)) (eq c (UINT_ADD a (UINT_ADD z1 z2)))) -> FALSE));
		require tttt proves forany z1, z2: TempFuncAC z1 z2 -> FALSE
		by (
			forany z1,z2:
			assume ttttt proves TempFuncAC z1 z2;
			(unwrap TempFuncAC ttttt) > ttt
		);
		tttt > temp2
	);
	
	wrap uint_le (
		assume qqqqq proves forany cccc: (AND (HAS_MEMBER UINT cccc) (eq c (UINT_ADD a cccc))) -> FALSE;
		qqqqq > temp3
	)
);


require le_antisymm proves forany a,b: (a : UINT) -> (b : UINT) -> uint_le a b -> uint_le b a -> eq a b
by (
	forany a,b:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	assume AB proves uint_le a b;
	assume BA proves uint_le b a;
	
	require AB_ proves (forany c: (AND (c : UINT) (eq b (UINT_ADD a c))) -> FALSE) -> FALSE
	by unwrap uint_le AB;
	
	require BA_ proves (forany cc: (AND (HAS_MEMBER UINT cc) (eq a (UINT_ADD b cc))) -> FALSE) -> FALSE
	by unwrap uint_le BA;
	
	require temp1 proves forany c,cc: (c : UINT) -> (HAS_MEMBER UINT cc) -> eq b (UINT_ADD a c) -> eq a (UINT_ADD b cc) -> eq a b
	by (
		forany c,cc:
		assume cuint proves c : UINT;
		assume ccuint proves HAS_MEMBER UINT cc;
		assume b_ac proves eq b (UINT_ADD a c);
		assume a_bcc proves eq a (UINT_ADD b cc);
		
		require a_accc proves eq a (UINT_ADD (UINT_ADD a c) cc)
		by a_bcc > (b_ac > bin_sub_left_eq) > bin_sub_right_impl;
		
		require a_accc2 proves eq a (UINT_ADD a (UINT_ADD c cc))
		by a_accc > (ccuint > cuint > auint > add_assoc) > bin_sub_right_impl;
		
		require 0_ccc proves eq UINT_ZERO (UINT_ADD c cc)
		by (a_accc2 > ((auint > add_zero) > eq_comm) > bin_sub_left_impl) > ((ccuint > cuint > uint_add_uint_is_uint) > zero_is_uint > auint > same_add);
		
		require c_0 proves eq c UINT_ZERO
		by ((0_ccc > eq_comm) > ccuint > cuint > sum_zero_both_zero) > and_left;
		
		require cc_0 proves eq cc UINT_ZERO
		by ((0_ccc > eq_comm) > ccuint > cuint > sum_zero_both_zero) > and_right;
		
		(a_bcc > (cc_0 > bin_sub_right_eq) > bin_sub_right_impl)
		>
		(buint > add_zero)
		>
		bin_sub_right_impl
	);
	
	define ABFunc c  = (AND (HAS_MEMBER UINT c ) (eq b (UINT_ADD a c )));
	define BAFunc cc = (AND (HAS_MEMBER UINT cc) (eq a (UINT_ADD b cc)));
	define AnotherFunc c cc = AND (eq a b) (AND (eq c c) (eq cc cc));
	
	require temp2 proves (forany c: ABFunc c -> FALSE) -> FALSE
	by (
		assume ttt proves forany c: ABFunc c -> FALSE;
		require ttt2 proves forany c: (AND (c : UINT) (eq b (UINT_ADD a c))) -> FALSE
		by (
			forany c:
			assume ttt3 proves AND (c : UINT) (eq b (UINT_ADD a c));
			wrap ABFunc ttt3 > ttt
		);
		ttt2 > AB_
	);
	
	require temp3 proves (forany cc: BAFunc cc -> FALSE) -> FALSE
	by (
		assume ttt proves forany c: BAFunc c -> FALSE;
		require ttt2 proves forany c: (AND (c : UINT) (eq a (b + c))) -> FALSE
		by (
			forany c:
			assume ttt3 proves AND (c : UINT) (eq a (b + c));
			wrap BAFunc ttt3 > ttt
		);
		ttt2 > BA_
	);
	
	require temp4 proves forany c,cc: ABFunc c -> BAFunc cc -> AnotherFunc c cc
	by (
		forany c,cc:
		assume ab_ proves ABFunc c;
		assume ba_ proves BAFunc cc;
		
		require cuint proves HAS_MEMBER UINT c  by  (unwrap ABFunc ab_) > and_left;
		require ccuint proves HAS_MEMBER UINT cc  by  (unwrap BAFunc ba_) > and_left;
		
		require a_b proves eq a b
		by ((unwrap BAFunc ba_) > and_right) > ((unwrap ABFunc ab_) > and_right) > (ccuint > cuint > temp1);
		
		wrap AnotherFunc ((eq_same > eq_same > impl_impl_and) > a_b > impl_impl_and)
	);
	
	require temp5 proves (forany c,cc: AnotherFunc c cc -> FALSE) -> FALSE
	by temp4 > temp3 > temp2 > exist_exist_impl;
	
	require temp6 proves (forany c,cc: AND (eq a b) (AND (eq c c) (eq cc cc)) -> FALSE) -> FALSE
	by (
		assume ttt1 proves forany c,cc: AND (eq a b) (AND (eq c c) (eq cc cc)) -> FALSE;
		
		require ttt2 proves forany c,cc: AnotherFunc c cc -> FALSE
		by (
			forany c,cc:
			assume temp proves AnotherFunc c cc;
			unwrap AnotherFunc temp > ttt1
		);
		
		ttt2 > temp5
	);
	
	require temp7 proves (eq a b -> FALSE) -> FALSE
	by (
		assume ttt1 proves eq a b -> FALSE;
		require ttt2 proves forany c,cc: AND (eq a b) (AND (eq c c) (eq cc cc)) -> FALSE
		by (
			forany c,cc:
			ttt1 > (substitute b=(AND (eq c c) (eq cc cc)) in not_left__not_and)
		);
		ttt2 > temp6
	);
	
	temp7 > not_not_impl
);




require le_total proves forany a,b: (a : UINT) -> (b : UINT) -> or (uint_le a b) (uint_le b a)
by (
	define Func bb = (forany a: (a : UINT) -> or (uint_le a bb) (uint_le bb a));
	
	require casezero proves Func UINT_ZERO
	by wrap Func (
		forany a:
		assume auint proves a : UINT;
		(auint > zero_le) > (substitute a=(uint_le a UINT_ZERO) in or_right)
	);
	
	require casesucc proves forany bb: (HAS_MEMBER UINT bb) -> Func bb -> Func (UINT_SUCC bb)
	by (
		forany b:
		assume buint proves b : UINT;
		assume fb proves Func b;
		require ab_or_ba proves forany a: (a : UINT) -> or (uint_le a b) (uint_le b a)
		by unwrap Func fb;
		
		wrap Func (
			forany a:
			assume auint proves a : UINT;
			
			require from_left proves uint_le a b -> or (uint_le a (UINT_SUCC b)) (uint_le (UINT_SUCC b) a)
			by (
				assume ab proves uint_le a b;
				
				// Goal:
				// or (uint_le a (UINT_SUCC b)) (uint_le (UINT_SUCC b) a):
				
				or_left < (
					// Goal:
					// uint_le a (UINT_SUCC b)
					
					ab > buint > auint > le_to_le_succ
				)
			);
			
			require from_right proves uint_le b a -> or (uint_le a (UINT_SUCC b)) (uint_le (UINT_SUCC b) a)
			by impl_reverse_back < (
				// Goal:
				// (or (uint_le a (UINT_SUCC b)) (uint_le (UINT_SUCC b) a) -> FALSE) -> (uint_le b a -> FALSE)
				
				assume temp proves or (uint_le a (UINT_SUCC b)) (uint_le (UINT_SUCC b) a) -> FALSE;
				
				// Goal:
				// (uint_le b a -> FALSE)
				
				assume ba proves uint_le b a;
				
				// Goal:
				// FALSE
				
				require ba_ proves (forany c: (AND (c : UINT) (eq a (b + c))) -> FALSE) -> FALSE
				by unwrap uint_le ba;
				
				ba_ < (
					// Goal:
					// forany c: (AND (c : UINT) (eq a (b + c))) -> FALSE
					
					forany c:
					assume tempppp proves AND (c : UINT) (eq a (b + c));
					require cuint proves HAS_MEMBER UINT c
					by tempppp > and_left;
					require a_bc proves eq a (b + c)
					by tempppp > and_right;
					
					// Goal:
					// FALSE
					
					temp < (
						// Goal:
						// or (uint_le a (UINT_SUCC b)) (uint_le (UINT_SUCC b) a)
						
						or_cases < (cuint > uint_is_zero_or_succ) < (
							// Goal:
							// eq c UINT_ZERO   ->   or (uint_le a (UINT_SUCC b)) (uint_le (UINT_SUCC b) a)
							
							assume c_is_zero proves eq c UINT_ZERO;
							
							// Goal:
							// or (uint_le a (UINT_SUCC b)) (uint_le (UINT_SUCC b) a)
							
							require a_eq_b proves eq a b
							by (
								a_bc
								>
								(c_is_zero > bin_sub_right_eq)
								>
								bin_sub_right_impl
							) > (buint > add_zero) > bin_sub_right_impl;
							
							or_left < (
								// Goal:
								// uint_le a (UINT_SUCC b)
								
								(buint > le_succ_self) > (a_eq_b > eq_comm) > bin_sub_left_impl
							)
						) < (
							// Goal:
							// ((forany d: (HAS_MEMBER UINT d -> (eq c (UINT_SUCC d)) -> FALSE)) -> FALSE)   ->   or (uint_le a (UINT_SUCC b)) (uint_le (UINT_SUCC b) a)
							
							assume c_is_succ proves (forany d: (HAS_MEMBER UINT d -> (eq c (UINT_SUCC d)) -> FALSE)) -> FALSE;
							
							// Goal:
							// or (uint_le a (UINT_SUCC b)) (uint_le (UINT_SUCC b) a)
							
							or_right < (
								// Goal:
								// uint_le (UINT_SUCC b) a
								
								wrap uint_le (
									// Goal:
									// (forany e: (AND (e : UINT) (eq a (UINT_ADD (UINT_SUCC b) e))) -> FALSE) -> FALSE
									
									assume tempooo proves forany e: (AND (e : UINT) (eq a (UINT_ADD (UINT_SUCC b) e))) -> FALSE;
									
									// Goal:
									// FALSE
									
									c_is_succ < (
										// Goal:
										// forany d: HAS_MEMBER UINT d -> (eq c (UINT_SUCC d)) -> FALSE
										
										forany d:
										assume duint proves d : UINT;
										assume c_sd proves eq c (UINT_SUCC d);
										
										// Goal:
										// FALSE
										
										tempooo < (
											// Goal:
											// forSOME e: AND (e : UINT) (eq a (UINT_ADD (UINT_SUCC b) e))
											
											// We have:
											// a_bc proves eq a (b + c)
											// c_sd proves eq c (UINT_SUCC d)
											
											require temp1 proves eq a (UINT_ADD b (UINT_SUCC d))
											by a_bc > (c_sd > bin_sub_right_eq) > bin_sub_right_impl;
											
											require temp2 proves eq a (UINT_SUCC (UINT_ADD b d))
											by temp1 > (duint > buint > add_succ) > bin_sub_right_impl;
											
											require temp3 proves eq a (UINT_ADD (UINT_SUCC b) d)
											by temp2 > ((duint > buint > succ_add) > eq_comm) > bin_sub_right_impl;
											
											temp3 > duint > impl_impl_and
										)
									)
								)
							)
						)
					)
				)
			);
			
			from_right > from_left > (auint > ab_or_ba) > or_cases
		)
	);
	
	forany a,b:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	
	auint > unwrap Func (buint > casesucc > casezero > uint_inductive)
);






require succ_le_succ proves forany a,b: (a : UINT) -> (b : UINT) -> uint_le (UINT_SUCC a) (UINT_SUCC b) -> uint_le a b
by (
	forany a,b:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	assume sa_sb proves uint_le (UINT_SUCC a) (UINT_SUCC b);
	require sa_sb_ proves (forany c: (AND (c : UINT) (eq (UINT_SUCC b) (UINT_ADD (UINT_SUCC a) c))) -> FALSE) -> FALSE
	by unwrap uint_le sa_sb;
	wrap uint_le (
		assume temp1 proves forany c: (AND (c : UINT) (eq b (UINT_ADD a c))) -> FALSE;
		
		// Goal:
		// FALSE
		
		sa_sb_ < (
			// Goal:
			// forany d: (AND (d : UINT) (eq (UINT_SUCC b) (UINT_ADD (UINT_SUCC a) d))) -> FALSE
			
			forany d:
			assume temp2 proves AND (d : UINT) (eq (UINT_SUCC b) (UINT_ADD (UINT_SUCC a) d));
			
			// Goal:
			// FALSE
			
			require duint proves HAS_MEMBER UINT d  by  temp2 > and_left;
			require sb__sa_d proves eq (UINT_SUCC b) (UINT_ADD (UINT_SUCC a) d)  by  temp2 > and_right;
			
			temp1 < (
				// Goal:
				// forSOME c: AND (c : UINT) (eq b (UINT_ADD a c))
				
				require sb__s_ad proves  eq (UINT_SUCC b) (UINT_SUCC (UINT_ADD a d))
				by sb__sa_d > (duint > auint > succ_add) > bin_sub_right_impl;
				
				(sb__s_ad > (uint_add_uint_is_uint < auint < duint) > buint > succ_inj) > duint > impl_impl_and
			)
		)
	)
);

require succ_le proves forany a,b: (a : UINT) -> (b : UINT) -> uint_le (UINT_SUCC a) b -> uint_le a b
by (
	forany a,b:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	assume sa_sb proves uint_le (UINT_SUCC a) b;
	
	wrap uint_le (
		// Goal:
		// (forany c: ((c : UINT) && (b == (a + c))) -> FALSE) -> FALSE
		
		assume ttt proves forany c: ((c : UINT) && (b == (a + c))) -> FALSE;
		
		// Goal: FALSE
		
		unwrap uint_le sa_sb < (
			// Goal:
			// forany d: ((d : UINT) && (b == ((a++) + d))) -> FALSE
			
			forany d:
			assume vvv proves (d : UINT) && (b == ((a++) + d));
			require duint proves d : UINT  by  vvv > and_left;
			
			// Goal: FALSE
			
			ttt < (
				// Goal:
				// forSOME c: ((c : UINT) && (b == (a + c)))
				
				impl_impl_and < (succ_uint_is_uint < duint) < (
					// Goal:
					// b == a + (d++)
					
					((vvv > and_right) > (succ_add < auint < duint) > bin_sub_right_impl) > ((add_succ < auint < duint) > eq_comm) > bin_sub_right_impl
				)
			)
		)
	)
);

require succ_le_not_zero proves forany a,b: (a : UINT) -> (b : UINT) -> (a++) <= b -> b != UINT_ZERO
by (
	forany a,b:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	assume sa_sb proves uint_le (UINT_SUCC a) b;
	assume b_0 proves b == UINT_ZERO;
	
	// Goal: FALSE
	
	unwrap uint_le sa_sb < (
		// Goal:
		// forany c: (AND (c : UINT) (eq b (UINT_ADD (UINT_SUCC a) c))) -> FALSE
		
		forany c:
		assume ttt proves AND (c : UINT) (eq b (UINT_ADD (UINT_SUCC a) c));
		
		// Goal: FALSE
		
		require cuint proves c : UINT by ttt > and_left;
		
		// b = 0
		// b = a++ + c
		
		require 0__sa_c proves UINT_ZERO == ((a++) + c)
		by (ttt > and_right) > b_0 > bin_sub_left_impl;
		
		succ_not_zero < (uint_add_uint_is_uint < auint < cuint) < ((0__sa_c > (succ_add < auint < cuint) > bin_sub_right_impl) > eq_comm)
	)
);

require succ_le_succ_reverse proves forany a,b: (a : UINT)  ->  (b : UINT)  ->  a <= b  ->  a++ <= b++
by (
	forany a,b:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	assume ab proves a <= b;
	require ab_ proves (forany d: (AND (d : UINT) (eq b (UINT_ADD a d))) -> FALSE) -> FALSE
	by unwrap uint_le ab;
	wrap uint_le (
		assume temp1 proves forany c: (AND (c : UINT) (eq (UINT_SUCC b) (UINT_ADD (UINT_SUCC a) c))) -> FALSE;
		
		// Goal:
		// FALSE
		
		ab_ < (
			// Goal:
			// forany d: (AND (d : UINT) (eq b (UINT_ADD a d))) -> FALSE
			
			forany d:
			assume temp2 proves AND (d : UINT) (eq b (UINT_ADD a d));
			
			// Goal:
			// FALSE
			
			require duint proves HAS_MEMBER UINT d  by  temp2 > and_left;
			require b_ad proves eq b (UINT_ADD a d)  by  temp2 > and_right;
			
			temp1 < (
				// Goal:
				// forSOME c: AND (c : UINT) (eq (UINT_SUCC b) (UINT_ADD (UINT_SUCC a) c))
				
				require temp3 proves eq (UINT_SUCC b) (UINT_ADD (UINT_SUCC a) d)
				by (b_ad > wrap_in_func_impl) > ((duint > auint > succ_add) > eq_comm) > bin_sub_right_impl;
				
				temp3 > duint > impl_impl_and
			)
		)
	)
);



require add_le_add_right proves forany a,b,c: (a : UINT)  ->  (b : UINT)  ->  (c : UINT)  ->  (a + c) <= (b + c)  ->  a <= b
by (
	define Func c = (forany a,b: (a : UINT) -> (b : UINT) -> uint_le (UINT_ADD a c) (b + c) -> uint_le a b);
	
	require casezero proves Func UINT_ZERO
	by wrap Func (
		forany a,b:
		assume auint proves a : UINT;
		assume buint proves b : UINT;
		assume ac_le_bc proves uint_le (UINT_ADD a UINT_ZERO) (UINT_ADD b UINT_ZERO);
		
		(ac_le_bc > (auint > add_zero) > bin_sub_left_impl) > (buint > add_zero) > bin_sub_right_impl
	);
	
	require casesucc proves forany c: (c : UINT) -> Func c -> Func (UINT_SUCC c)
	by (
		forany c:
		assume cuint proves c : UINT;
		assume hypoth proves Func c;
		
		// Goal:
		// Func (UINT_SUCC c)
		
		require hypoth_ proves (forany a,b: (a : UINT) -> (b : UINT) -> uint_le (UINT_ADD a c) (b + c) -> a <= b)
		by unwrap Func hypoth;
		
		wrap Func (
			// Goal:
			// forany a,b: (a : UINT) -> (b : UINT) -> uint_le (UINT_ADD a (UINT_SUCC c)) (UINT_ADD b (UINT_SUCC c)) -> a <= b
			
			forany a,b:
			assume auint proves a : UINT;
			assume buint proves b : UINT;
			
			// Goal:
			// uint_le (UINT_ADD a (UINT_SUCC c)) (UINT_ADD b (UINT_SUCC c)) -> a <= b
			
			require hypoth__ proves uint_le (UINT_ADD a c) (b + c) -> a <= b
			by buint > auint > hypoth_;
			
			assume a_sc_le_b_sc proves uint_le (UINT_ADD a (UINT_SUCC c)) (UINT_ADD b (UINT_SUCC c));
			
			// Goal:
			// uint_le a b
			
			require s_ac_le_s_bc proves uint_le (UINT_SUCC (UINT_ADD a c)) (UINT_SUCC (b + c))
			by (a_sc_le_b_sc > (cuint > auint > add_succ) > bin_sub_left_impl) > (cuint > buint > add_succ) > bin_sub_right_impl;
			
			(s_ac_le_s_bc > (cuint > buint > uint_add_uint_is_uint) > (cuint > auint > uint_add_uint_is_uint) > succ_le_succ) > hypoth__
		)
	);
	
	forany a,b,c:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	assume cuint proves c : UINT;
	assume ac_le_bc proves uint_le (UINT_ADD a c) (b + c);
	
	ac_le_bc > buint > auint > unwrap Func (cuint > casesucc > casezero > uint_inductive)
);

require add_le_add_right_reverse proves forany a,b,c: (a : UINT) -> (b : UINT) -> (c : UINT)  ->  a <= b  ->  (a + c) <= (b + c)
by (
	define Func c = (forany a,b: (a : UINT) -> (b : UINT) -> uint_le a b -> uint_le (UINT_ADD a c) (b + c));
	
	require casezero proves Func UINT_ZERO
	by wrap Func (
		forany a,b:
		assume auint proves a : UINT;
		assume buint proves b : UINT;
		assume ab proves uint_le a b;
		
		(ab > ((auint > add_zero) > eq_comm) > bin_sub_left_impl)
		>
		((buint > add_zero) > eq_comm)
		>
		bin_sub_right_impl
	);
	
	require casesucc proves forany c: (c : UINT) -> Func c -> Func (UINT_SUCC c)
	by (
		forany c:
		assume cuint proves c : UINT;
		assume hypoth proves Func c;
		
		// Goal:
		// Func (UINT_SUCC c)
		
		require hypoth_ proves forany a,b: (a : UINT) -> (b : UINT)  ->  a <= b  ->  (a + c) <= (b + c)
		by unwrap Func hypoth;
		
		wrap Func (
			forany a,b:
			assume auint proves a : UINT;
			assume buint proves b : UINT;
			
			assume ab proves uint_le a b;
			
			// Goal:
			// uint_le (UINT_ADD a (UINT_SUCC c)) (UINT_ADD b (UINT_SUCC c))
			
			require temp1 proves uint_le (UINT_ADD a c) (b + c)
			by ab > buint > auint > hypoth_;
			
			
			((temp1 > (uint_add_uint_is_uint < buint < cuint) > (uint_add_uint_is_uint < auint < cuint) > succ_le_succ_reverse) > ((cuint > auint > add_succ) > eq_comm) > bin_sub_left_impl)
			>
			((cuint > buint > add_succ) > eq_comm)
			>
			bin_sub_right_impl
		)
	);
	
	forany a,b,c:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	assume cuint proves c : UINT;
	assume ab proves uint_le a b;
	
	ab > buint > auint > unwrap Func (cuint > casesucc > casezero > uint_inductive)
);

require add_le_add_right_eq proves forany a,b,c: (a : UINT) -> (b : UINT) -> (c : UINT) -> eq (uint_le (UINT_ADD a c) (b + c)) (uint_le a b)
by (
	forany a,b,c:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	assume cuint proves c : UINT;
	
	wrap eq (impl_impl_and < (add_le_add_right < auint < buint < cuint) < (add_le_add_right_reverse < auint < buint < cuint))
);

require uint_le_one__zero_or_one proves forany a: (a : UINT)  ->  a <= UINT_ONE  ->  (a == UINT_ZERO) || (a == UINT_ONE)
by (
	forany a:
	assume auint proves a : UINT;
	assume a_le_1 proves a <= UINT_ONE;
	
	require a_le_s0 proves uint_le a (UINT_SUCC UINT_ZERO)
	by a_le_1 > uint_one_eq_succ_zero > bin_sub_right_impl;
	
	require a_le_s0_ proves (forany c: (AND (c : UINT) (eq (UINT_SUCC UINT_ZERO) (UINT_ADD a c))) -> FALSE) -> FALSE
	by unwrap uint_le a_le_s0;
	
	or_cases < (auint > uint_is_zero_or_succ) < (
		assume a_is_zero proves eq a UINT_ZERO;
		a_is_zero > or_left
	) < (
		assume a_is_succ proves (forany d: (HAS_MEMBER UINT d -> (eq a (UINT_SUCC d)) -> FALSE)) -> FALSE;
		
		// Goal:
		// or (eq a UINT_ZERO) (eq a UINT_ONE)
		
		or_right < (
			// Goal:
			// eq a UINT_ONE
			
			not_not_impl < (
				// Goal:
				// (eq a UINT_ONE -> FALSE) -> FALSE
				
				assume a_not_1 proves eq a UINT_ONE -> FALSE;
				
				// Goal:
				// FALSE
				
				a_is_succ < (
					// Goal:
					// forany d: HAS_MEMBER UINT d -> (eq a (UINT_SUCC d)) -> FALSE;
					
					forany d:
					assume duint proves d : UINT;
					assume a_sd proves eq a (UINT_SUCC d);
					
					// Goal:
					// FALSE
					
					require temp1 proves uint_le (UINT_SUCC d) (UINT_SUCC UINT_ZERO)
					by a_le_s0 > a_sd > bin_sub_left_impl;
					require temp2 proves uint_le d UINT_ZERO
					by temp1 > zero_is_uint > duint > succ_le_succ;
					require temp3 proves eq d UINT_ZERO
					by temp2 > duint > le_zero__is_zero;
					
					require a_s0 proves eq a (UINT_SUCC UINT_ZERO)
					by a_sd > (temp3 > un_sub_arg) > bin_sub_right_impl;
					
					require a_1 proves eq a UINT_ONE
					by a_s0 > (uint_one_eq_succ_zero > eq_comm) > bin_sub_right_impl;
					
					a_1 > a_not_1
				)
			)
		)
	)
);

require not_zero__one_le proves forany a: (a : UINT)  ->  (eq a UINT_ZERO -> FALSE)  ->  UINT_ONE <= a
by (
	forany a:
	assume auint proves a : UINT;
	assume a_not_0 proves eq a UINT_ZERO -> FALSE;
	wrap uint_le (
		assume temp1 proves forany c: AND (c : UINT) (eq a (UINT_ADD UINT_ONE c)) -> FALSE;
		
		// Goal:
		// FALSE
		
		or_cases < (auint > uint_is_zero_or_succ) < (
			assume a_0 proves eq a UINT_ZERO;
			a_0 > a_not_0
		) < (
			assume a_is_succ proves (forany d: (HAS_MEMBER UINT d -> (eq a (UINT_SUCC d)) -> FALSE)) -> FALSE;
			
			a_is_succ < (
				// Goal:
				// forany d: HAS_MEMBER UINT d -> (eq a (UINT_SUCC d)) -> FALSE
				
				forany d:
				assume duint proves d : UINT;
				assume a_sd proves eq a (UINT_SUCC d);
				
				// Goal:
				// FALSE
				
				temp1 < (
					// Goal:
					// forSOME c: AND (c : UINT) (eq a (UINT_ADD UINT_ONE c))
					
					require temp2 proves eq a (UINT_ADD UINT_ONE d)
					by a_sd > ((duint > one_add_eq_succ) > eq_comm) > bin_sub_right_impl;
					
					impl_impl_and < duint < temp2
				)
			)
		)
	)
);

require one_le__not_zero proves forany a: a : UINT  ->  UINT_ONE <= a  ->  a != UINT_ZERO
by (
	forany a:
	assume auint proves a : UINT;
	assume 1_le_a proves UINT_ONE <= a;
	assume a_0 proves a == UINT_ZERO;
	
	// Goal: FALSE
	
	require temp1 proves UINT_ONE == UINT_ZERO
	by le_zero__is_zero < one_is_uint < (1_le_a > a_0 > bin_sub_right_impl);
		
	(temp1 > uint_one_eq_succ_zero > bin_sub_left_impl) > zero_is_uint > succ_not_zero
);














require mul_le_mul_right proves forany a,b,c: (a : UINT) -> (b : UINT) -> (c : UINT)  ->  a <= b  ->  (a * c) <= (b * c)
by (
	forany a,b,c:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	assume cuint proves c : UINT;
	assume ab proves uint_le a b;
	
	require ab_ proves (forany d: (AND (d : UINT) (eq b (UINT_ADD a d))) -> FALSE) -> FALSE
	by unwrap uint_le ab;
	
	wrap uint_le (
		assume ttt proves forany e: (AND (e : UINT) (eq (UINT_MUL b c) (UINT_ADD (UINT_MUL a c) e))) -> FALSE;
		
		ab_ < (
			// Goal:
			// forany d: (AND (d : UINT) (eq b (UINT_ADD a d))) -> FALSE
			
			forany d:
			assume temp1 proves AND (d : UINT) (eq b (UINT_ADD a d));
			
			// Goal:
			// FALSE
			
			require duint proves HAS_MEMBER UINT d  by  temp1 > and_left;
			require b_ad proves eq b (UINT_ADD a d)  by  temp1 > and_right;
			
			ttt < (
				// Goal:
				// forSOME e: AND (e : UINT) (eq (UINT_MUL b c) (UINT_ADD (UINT_MUL a c) e))
				
				require temp2 proves eq (UINT_MUL b c) (UINT_MUL (UINT_ADD a d) c)
				by b_ad > wrap_in_bin_func_lhs;
				
				require temp3 proves eq (UINT_MUL b c) (UINT_ADD (UINT_MUL a c) (UINT_MUL d c))
				by temp2 > (add_mul < auint < duint < cuint) > bin_sub_right_impl;
				
				impl_impl_and < (
					uint_mul_uint_is_uint < duint < cuint
				) < (
					temp3
				)
			)
		)
	)
);

require mul_le_mul_left proves forany a,b,c: (a : UINT) -> (b : UINT) -> (c : UINT)  ->  a <= b  ->  (c * a) <= (c * b)
by (
	forany a,b,c:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	assume cuint proves c : UINT;
	assume ab proves uint_le a b;
	((mul_le_mul_right < auint < buint < cuint < ab) > (mul_comm < auint < cuint) > bin_sub_left_impl)
	> (mul_comm < buint < cuint) > bin_sub_right_impl
);

require mul_not_zero__left_le_mul proves forany a,b: (a : UINT) -> (b : UINT) -> ((a * b) != UINT_ZERO)  ->  a <= (a * b)
by (
	forany a,b:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	assume mul_not_zero proves eq (UINT_MUL a b) UINT_ZERO -> FALSE;
	
	require temp1 proves eq (UINT_MUL b a) UINT_ZERO -> FALSE
	by mul_not_zero > ((buint > auint > mul_comm) > bin_sub_left_eq) > bin_sub_left_impl;
	
	require b_not_zero proves eq b UINT_ZERO -> FALSE
	by mul_not_zero__left_not_zero < buint < auint < temp1;
	
	require one_le_b proves uint_le UINT_ONE b
	by not_zero__one_le < buint < b_not_zero;
	
	require one_a__le__b_a proves uint_le (UINT_MUL UINT_ONE a) (UINT_MUL b a)
	by mul_le_mul_right < one_is_uint < buint < auint < one_le_b;
	
	(one_a__le__b_a > (auint > one_mul) > bin_sub_left_impl)
	>
	(auint > buint > mul_comm)
	>
	bin_sub_right_impl
);

require mul_not_zero__right_le_mul proves forany a,b: (a : UINT) -> (b : UINT) -> ((a * b) != UINT_ZERO)  ->  b <= (a * b)
by (
	forany a,b:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	assume ab_not_zero proves eq (UINT_MUL a b) UINT_ZERO -> FALSE;
	
	require temp proves b * a != UINT_ZERO
	by ab_not_zero > ((mul_comm < auint < buint) > bin_sub_left_eq) > bin_sub_left_impl;
	
	(mul_not_zero__left_le_mul < buint < auint < temp) > (mul_comm < buint < auint) > bin_sub_right_impl
);

require right_not_zero__left_le_mul proves forany a,b: (a : UINT) -> (b : UINT) -> (b != UINT_ZERO)  ->  a <= (a * b)
by (
	forany a,b:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	assume b_not_0 proves b != UINT_ZERO;
	or_cases < yay_or_nay < (
		assume a_0 proves a == UINT_ZERO;
		(zero_le < (uint_mul_uint_is_uint < auint < buint)) > (a_0 > eq_comm) > bin_sub_left_impl
	) < (
		assume a_not_0 proves a != UINT_ZERO;
		mul_not_zero__left_le_mul < auint < buint < (both_not_zero__mul_not_zero < auint < buint < a_not_0 < b_not_0)
	)
);

require mul_is_one__left_is_one proves forany a,b: (a : UINT)  ->  (b : UINT)  ->  ((a * b) == UINT_ONE)  ->  a == UINT_ONE
by (
	forany a,b:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	assume ab_1 proves eq (UINT_MUL a b) UINT_ONE;
	
	require ab_not_0 proves eq (UINT_MUL a b) UINT_ZERO -> FALSE
	by (
		assume ttt proves eq (UINT_MUL a b) UINT_ZERO;
		succ_not_zero < zero_is_uint < (
			(ttt > (eq_trans < ab_1 < uint_one_eq_succ_zero) > bin_sub_left_impl)
		)
	);
	
	require a_le_ab proves uint_le a (UINT_MUL a b)
	by mul_not_zero__left_le_mul < auint < buint < ab_not_0;
	
	require a_le_1 proves uint_le a UINT_ONE
	by a_le_ab > ab_1 > bin_sub_right_impl;
	
	require a_0_or_1 proves or (eq a UINT_ZERO) (eq a UINT_ONE)
	by uint_le_one__zero_or_one < auint < a_le_1;
	
	require a_not_0 proves eq a UINT_ZERO -> FALSE
	by mul_not_zero__left_not_zero < auint < buint < ab_not_0;
	
	or__not_left__right < a_0_or_1 < a_not_0
);

require mul_left_cancel proves forany a,b,c: (a : UINT)  ->  (b : UINT)  ->  (c : UINT)  ->  ((a * b) == (a * c))  ->  (a != UINT_ZERO)  ->  b == c
by (
	forany a,b,c:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	assume cuint proves c : UINT;
	
	define Func bb = forany c: (c : UINT) -> eq (UINT_MUL a bb) (UINT_MUL a c) -> (eq a UINT_ZERO -> FALSE) -> eq bb c;
	
	require casezero proves Func UINT_ZERO
	by wrap Func (
		forany c:
		assume cuint proves c : UINT;
		assume a0_ac proves eq (UINT_MUL a UINT_ZERO) (UINT_MUL a c);
		assume a_not_0 proves eq a UINT_ZERO -> FALSE;
		
		// Goal:
		// eq UINT_ZERO c
		
		require ac_0 proves eq (UINT_MUL a c) UINT_ZERO
		by (a0_ac > (auint > mul_zero) > bin_sub_left_impl) > eq_comm;
		
		require c_0 proves eq c UINT_ZERO
		by or__not_left__right < (mul_is_zero__either_is_zero < auint < cuint < ac_0) < a_not_0;
		
		c_0 > eq_comm
	);
	
	require casesucc proves forany e: HAS_MEMBER UINT e -> Func e -> Func (UINT_SUCC e)
	by (
		forany e:
		assume euint proves e : UINT;
		assume ttt proves Func e;
		require ttt_ proves forany cc: (HAS_MEMBER UINT cc) -> eq (UINT_MUL a e) (UINT_MUL a cc) -> (eq a UINT_ZERO -> FALSE) -> eq e cc
		by unwrap Func ttt;
		
		wrap Func (
			forany c:
			assume cuint proves c : UINT;
			assume a_se__ac proves eq (UINT_MUL a (UINT_SUCC e)) (UINT_MUL a c);
			assume a_not_0 proves eq a UINT_ZERO -> FALSE;
			
			// Goal:
			// eq (UINT_SUCC e) c
			
			or_cases < (uint_is_zero_or_succ < cuint) < (
				assume c_0 proves eq c UINT_ZERO;
				
				require a_se__0 proves eq (UINT_MUL a (UINT_SUCC e)) UINT_ZERO
				by (a_se__ac > (c_0 > bin_sub_right_eq) > bin_sub_right_impl) > (mul_zero < auint) > bin_sub_right_impl;
				
				require se_0 proves eq (UINT_SUCC e) UINT_ZERO
				by or__not_left__right < (mul_is_zero__either_is_zero < auint < (succ_uint_is_uint < euint) < a_se__0) < a_not_0;
				
				eq_trans < se_0 < (c_0 > eq_comm)
			) < (
				assume c_is_succ proves (forany d: (HAS_MEMBER UINT d -> (eq c (UINT_SUCC d)) -> FALSE)) -> FALSE;
				
				// Goal:
				// eq (UINT_SUCC e) c
				
				not_not_impl < (
					assume se_neq_c proves eq (UINT_SUCC e) c -> FALSE;
					
					// Goal:
					// FALSE
					
					c_is_succ < (
						forany d:
						assume duint proves d : UINT;
						assume c_sd proves eq c (UINT_SUCC d);
						
						// Goal:
						// FALSE
						
						// c_sd       c = S(d)
						// se_neq_c   S(e) != c
						// a_not_0    a != 0
						// a_se__ac   a * S(e) = a * c
						
						se_neq_c < (
							// Goal:
							// eq (UINT_SUCC e) c
							
							bin_sub_right_impl < (c_sd > eq_comm) < (
								// Goal:
								// eq (UINT_SUCC e) (UINT_SUCC d)
								
								require a_se__a_sd proves eq (UINT_MUL a (UINT_SUCC e)) (UINT_MUL a (UINT_SUCC d))
								by a_se__ac > (c_sd > bin_sub_right_eq) > bin_sub_right_impl;
								
								require temp1 proves eq (UINT_ADD (UINT_MUL a e) a) (UINT_ADD (UINT_MUL a d) a)
								by (a_se__a_sd > (mul_succ < auint < euint) > bin_sub_left_impl) > (mul_succ < auint < duint) > bin_sub_right_impl;
								
								require temp2 proves eq (UINT_MUL a e) (UINT_MUL a d)
								by add_right_cancel < (uint_mul_uint_is_uint < auint < euint) < (uint_mul_uint_is_uint < auint < duint) < auint < temp1;
								
								(ttt_ < duint < temp2 < a_not_0) > wrap_in_func_impl
							)
						)
					)
				)
			)
		)
	);
	
	unwrap Func (uint_inductive < casezero < casesucc < buint) < cuint
);

require mul_right_cancel proves forany a,b,c: (a : UINT)  ->  (b : UINT)  ->  (c : UINT)  ->  ((a * c) == (b * c))  ->  (c != UINT_ZERO)  ->  a == b
by (
	forany a,b,c:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	assume cuint proves c : UINT;
	assume ac_bc proves eq (UINT_MUL a c) (UINT_MUL b c);
	assume c_not_0 proves eq c UINT_ZERO -> FALSE;
	mul_left_cancel < cuint < auint < buint < ((ac_bc > (mul_comm < auint < cuint) > bin_sub_left_impl) > (mul_comm < buint < cuint) > bin_sub_right_impl) < c_not_0
);



























require add_satsub_same proves forany a,b: a : UINT  ->  b : UINT  ->  a + b - b == a
by (
	forany a,b:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	
	define Func bb = a + bb - bb == a;
	
	require casezero proves Func UINT_ZERO
	by wrap Func (
		(eq_same > ((add_zero < auint) > eq_comm) > bin_sub_left_impl) > ((satsub_zero < (uint_add_uint_is_uint < auint < zero_is_uint)) > eq_comm) > bin_sub_left_impl
	);
	
	require casesucc proves forany bb: bb : UINT -> Func bb -> Func (bb++)
	by (
		forany bb:
		assume bbuint proves bb : UINT;
		assume ttt proves Func bb;
		require ttt_ proves a + bb - bb == a
		by unwrap Func ttt;
		wrap Func (
			// Goal:
			// (a + (bb++)) - (bb++) == a
			
			(ttt_ > ((succ_satsub_succ < (uint_add_uint_is_uint < auint < bbuint) < bbuint) > eq_comm) > bin_sub_left_impl)
			>
			(((add_succ < auint < bbuint) > eq_comm) > bin_sub_left_eq)
			>
			bin_sub_left_impl
		)
	);
	
	unwrap Func (uint_inductive < casezero < casesucc < buint)
);

require eq_add__to__satsub_eq proves forany a,b,c: a : UINT  ->  b : UINT  ->  c : UINT  ->  a == b + c  ->  a - c == b
by (
	forany a,b,c:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	assume cuint proves c : UINT;
	
	// a == b + c
	// pred(a) == pred(b + c)
	
	define Func cc = a == b + cc  ->  a - cc == b;
	
	require casezero proves Func UINT_ZERO
	by wrap Func (
		assume a_bc proves a == b + UINT_ZERO;
		(a_bc > (add_zero < buint) > bin_sub_right_impl) > ((satsub_zero < auint) > eq_comm) > bin_sub_left_impl
	);
	
	require casesucc proves forany cc: cc : UINT -> Func cc -> Func (cc++)
	by (
		forany cc:
		assume ccuint proves cc : UINT;
		assume ttt proves Func cc;
		require ttt_ proves a == b + cc  ->  a - cc == b  // lol wait i didn't even use this xd
		by unwrap Func ttt;
		// a++ == (b + cc)++  ->  a - cc == b
		
		wrap Func (
			assume vvv proves a == b + (cc++);
			
			// Goal:
			// a - (cc++) == b
			
			require sbc_a proves (b + cc)++ == a
			by ((vvv > (add_succ < buint < ccuint) > bin_sub_right_impl) > eq_comm);
			
			require a_not_0 proves a != UINT_ZERO
			by ((substitute a=b+cc in succ_not_zero) < (uint_add_uint_is_uint < buint < ccuint)) > (sbc_a > bin_sub_left_eq) > bin_sub_left_impl;
			
			not_not_impl < (
				// Goal:
				// ((a - (cc++) == b) -> FALSE) -> FALSE
				
				assume qqq proves (a - (cc++) == b) -> FALSE;
				
				// Goal: FALSE
				
				print (or__not_left__right < (uint_is_zero_or_succ < auint) < a_not_0);
				
				require a_is_succ proves (forany aa: aa : UINT  ->  a == (aa++)  ->  FALSE) -> FALSE
				by (or__not_left__right < (uint_is_zero_or_succ < auint) < a_not_0);
				
				a_is_succ < (
					// Goal:
					// forany aa:  aa : UINT  ->  a == (aa++)  ->  FALSE
					
					forany aa:
					assume aauint proves aa : UINT;
					assume a_saa proves a == aa++;
					
					// Goal: FALSE
					
					require vvv2 proves aa++ == b + cc++
					by vvv > a_saa > bin_sub_left_impl;
					
					require aa_bcc proves aa == b + cc
					by (vvv2 > (add_succ < buint < ccuint) > bin_sub_right_impl) > (uint_add_uint_is_uint < buint < ccuint) > aauint > succ_inj;
					
					// aa = b + cc
					// a = aa++
					// a != 0
					// a == b + (cc++)
					// aa++ == b + (cc++)
					
					qqq < (
						// Goal:
						// a - (cc++) == b
						
						// a == b + (cc++)
						// a - (cc++) == b + (cc++) - (cc++)
						// a - (cc++) == b
						
						require temp2 proves a - cc++  ==  (b + cc++) - cc++
						by vvv > (substitute f=UINT_SATSUB,c=cc++ in wrap_in_bin_func_lhs);
						
						temp2 > (add_satsub_same < buint < (succ_uint_is_uint < ccuint)) > bin_sub_right_impl
					)
				)
			)
		)
	);
	
	unwrap Func (uint_inductive < casezero < casesucc < cuint)
);

require satsub_same proves forany a: a : UINT  ->  a - a == UINT_ZERO
by (
	forany a,b:
	assume auint proves a : UINT;
	
	define Func aa = aa - aa == UINT_ZERO;
	
	require casezero proves Func UINT_ZERO
	by wrap Func (
		zero_is_uint > satsub_zero
	);
	
	require casesucc proves forany aa: aa : UINT -> Func aa -> Func aa++
	by (
		forany aa:
		assume aauint proves aa : UINT;
		assume hypoth proves Func aa;
		wrap Func (
			// Goal:
			// aa++ - aa++ == UINT_ZERO
			(unwrap Func hypoth) > ((succ_satsub_succ < aauint < aauint) > eq_comm) > bin_sub_left_impl
		)
	);
	
	unwrap Func (uint_inductive < casezero < casesucc < auint)
);

require a_not_b__a_le_b__succ_a_le_b proves forany a,b: a : UINT  ->  b : UINT  ->  a != b  ->  a <= b  ->  a++ <= b
by (
	forany a,b:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	
	assume a_not_b proves a != b;
	assume a_le_b proves a <= b;
	
	wrap uint_le (
		// Goal:
		// (forany c: ((c : UINT) && (b == (a++ + c))) -> FALSE) -> FALSE
		
		assume ccc proves forany c: ((c : UINT) && (b == (a++ + c))) -> FALSE;
		
		// Goal: FALSE
		
		unwrap uint_le a_le_b < (
			// Goal:
			// forany d: ((d : UINT) && (b == (a + d))) -> FALSE
			
			forany d:
			assume ddd proves (d : UINT) && (b == (a + d));
			
			require duint proves d : UINT  by ddd > and_left;
			require b_ad proves b == a + d  by  ddd > and_right;
			
			// Goal: FALSE
			
			or_cases < (uint_is_zero_or_succ < auint) < (
				assume a_0 proves a == UINT_ZERO;
				
				require b_not_0 proves b != UINT_ZERO
				by (a_not_b > (a_0 > bin_sub_left_eq) > bin_sub_left_impl) > neq_comm;
				
				print or__not_left__right < (uint_is_zero_or_succ < buint) < ((a_not_b > (a_0 > bin_sub_left_eq) > bin_sub_left_impl) > neq_comm);
				
				require kkk proves (forany k: (k: UINT -> (eq b k++) -> FALSE)) -> FALSE
				by or__not_left__right < (uint_is_zero_or_succ < buint) < ((a_not_b > (a_0 > bin_sub_left_eq) > bin_sub_left_impl) > neq_comm);
				
				kkk < (
					// Goal:
					// forany k: (k: UINT -> (b == k++) -> FALSE)
					
					forany k:
					assume kuint proves k : UINT;
					assume b_sk proves b == k++;
					
					// Goal: FALSE
					
					ccc < (
						// Goal:
						// forSOME c: (c : UINT) && (b == (a++ + c))
						
						// forSOME c: (c : UINT) && (b == (a++ + c))
						// forSOME c: (c : UINT) && (b == (UINT_ZERO++ + c))
						// forSOME c: (c : UINT) && (k++ == (UINT_ZERO++ + c))
						// forSOME c: (k : UINT) && (k++ == (UINT_ZERO++ + k))
						// forSOME c: (k : UINT) && (k++ == (UINT_ZERO + k)++)
						// forSOME c: (k : UINT) && (k++ == k++)
						
						require temp1 proves k++ == (UINT_ZERO + k)++
						by eq_same > (((zero_add < kuint) > eq_comm) > un_sub_arg) > bin_sub_right_impl;
						
						require temp2 proves k++ == (UINT_ZERO++ + k)
						by temp1 > ((succ_add < zero_is_uint < kuint) > eq_comm) > bin_sub_right_impl;
						
						require temp3 proves b == (UINT_ZERO++ + k)
						by temp2 > (b_sk > eq_comm) > bin_sub_left_impl;
						
						require temp4 proves b == (a++ + k)
						by temp3 > (((a_0 > eq_comm) > un_sub_arg) > bin_sub_left_eq) > bin_sub_right_impl;
						
						impl_impl_and < kuint < temp4
					)
				)
			) < (
				assume a_is_succ proves (forany h: (h : UINT -> (a == h++) -> FALSE)) -> FALSE;
				
				// Goal: FALSE
				
				a_is_succ < (
					// Goal:
					// forany h: h : UINT -> (a == h++) -> FALSE
					
					forany h:
					assume huint proves h : UINT;
					assume a_sh proves a == h++;
					
					// Goal: FALSE
					
					require d_not_0 proves d != UINT_ZERO
					by (
						assume d_0 proves d == UINT_ZERO;
						require ba proves b == a
						by (b_ad > (d_0 > bin_sub_right_eq) > bin_sub_right_impl) > (add_zero < auint) > bin_sub_right_impl;
						
						(ba > eq_comm) > a_not_b
					);
					
					require d_is_succ proves (forany r: (r : UINT -> (d == r++) -> FALSE)) -> FALSE
					by or__not_left__right < (uint_is_zero_or_succ < duint) < d_not_0;
					
					d_is_succ < (
						// Goal:
						// forany r: (r : UINT -> (d == r++) -> FALSE)
						
						forany r:
						assume ruint proves r : UINT;
						assume d_sr proves d == r++;
						
						// Goal: FALSE
						
						ccc < (
							// Goal:
							// forSOME c: (c : UINT) && (b == (a++ + c))
							
							// d != 0
							// a != b
							// b = (a + d)
							// a = h++
							// d = r++
							
							// b = a + d
							// b = a + r++
							// b = (a + r)++
							// b = a++ + r
							
							require temp1 proves b == a + r++
							by b_ad > (d_sr > bin_sub_right_eq) > bin_sub_right_impl;
							
							require temp2 proves b == (a + r)++
							by temp1 > (add_succ < auint < ruint) > bin_sub_right_impl;
							
							require temp3 proves b == a++ + r
							by temp2 > ((succ_add < auint < ruint) > eq_comm) > bin_sub_right_impl;
							
							impl_impl_and < ruint < temp3
						)
					)
				)
			)
		)
	)
);

require a_le_b__a_eq_b__or__succ_a_le_b proves forany a,b: a : UINT  ->  b : UINT  ->  a <= b  ->  (a == b) || (a++ <= b)
by (
	forany a,b:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	assume a_leq_b proves a <= b;
	(or_cases < yay_or_nay) < (
		assume ab proves a == b;
		ab > or_left
	) < (
		assume a_not_b proves a != b;
		(a_not_b__a_le_b__succ_a_le_b < auint < buint < a_not_b < a_leq_b) > or_right
	)
);

require succ_satsub_eq_zero proves forany a,b: a : UINT  ->  b : UINT  ->  a++ - b == UINT_ZERO  ->  a - b == UINT_ZERO
by (
	forany a,b:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	
	assume ttt proves a++ - b == UINT_ZERO;
	
	require temp1 proves UINT_SATPRED (a++ - b) == UINT_SATPRED UINT_ZERO
	by (substitute f=UINT_SATPRED in wrap_in_func_impl) < ttt;
	
	require temp2 proves UINT_SATPRED (a++ - b) == UINT_ZERO
	by temp1 > sat_pred_zero_is_zero > bin_sub_right_impl;
	
	temp2 > (sat_pred__succ_satsub < auint < buint) > bin_sub_left_impl
);

require satsub_eq_zero proves forany a,b: a : UINT  ->  b : UINT  ->  a - b == UINT_ZERO  ->  a - (b++) == UINT_ZERO
by (
	forany a,b:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	
	define Func aa = aa - b == UINT_ZERO  ->  aa - (b++) == UINT_ZERO;
	
	require casezero proves Func UINT_ZERO
	by wrap Func (
		assume _ proves UINT_ZERO - b == UINT_ZERO;
		zero_satsub < (succ_uint_is_uint < buint)
	);
	
	require casesucc proves forany aa: aa : UINT -> Func aa -> Func (aa++)
	by (
		forany aa:
		assume aauint proves aa : UINT;
		assume ttt proves Func aa;
		require ttt_ proves aa - b == UINT_ZERO  ->  aa - (b++) == UINT_ZERO   by unwrap Func ttt;
		wrap Func (
			// Goal:
			// aa++ - b == UINT_ZERO  ->  aa++ - (b++) == UINT_ZERO;
			
			assume yyy proves aa++ - b == UINT_ZERO;
			
			require jjj proves  aa - b == UINT_ZERO
			by succ_satsub_eq_zero < aauint < buint < yyy;
			
			// Goal:
			// aa++ - (b++) == UINT_ZERO
			
			jjj > ((succ_satsub_succ < aauint < buint) > eq_comm) > bin_sub_left_impl
		)
	);
	
	unwrap Func (uint_inductive < casezero < casesucc < auint)
);



require uint_satsub_uint_is_uint proves forany a,b: a : UINT  ->  b : UINT  ->  (a - b) : UINT
by (
	forany a,b:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	
	define Func bb = (a - bb) : UINT;
	
	require casezero proves Func UINT_ZERO
	by wrap Func (
		auint > ((satsub_zero < auint) > eq_comm) > bin_sub_right_impl
	);
	
	require casesucc proves forany bb: bb : UINT -> Func bb -> Func (bb++)
	by (
		forany bb:
		assume bbuint proves bb : UINT;
		assume ttt proves Func bb;
		require ttt_ proves (a - bb) : UINT
		by unwrap Func ttt;
		wrap Func (
			// Goal:
			// (a - bb++) : UINT
			
			(ttt_ > satpred_uint_is_uint) > ((satsub_succ__satpred_satsub < auint < bbuint) > eq_comm) > bin_sub_right_impl
		)
	);
	
	unwrap Func (uint_inductive < casezero < casesucc < buint)
);

require satsub_saturates proves forany a,b: a : UINT  ->  b : UINT  ->  a <= b  ->  a - b == UINT_ZERO
by (
	forany a,b:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	
	impl_reverse_back < (
		// Goal:
		// (a - b == UINT_ZERO -> FALSE) -> (a <= b -> FALSE)
		
		assume ttt proves (a - b == UINT_ZERO -> FALSE);
		assume kkk proves a <= b;
		require kkk_ proves (forany c: (AND (c : UINT) (eq b (UINT_ADD a c))) -> FALSE) -> FALSE
		by unwrap uint_le kkk;
		
		kkk_ < (
			// Goal:
			// forany c: (AND (c : UINT) (eq b (UINT_ADD a c))) -> FALSE
			
			forany c:
			assume qqq proves (c : UINT) && (b == (a + c));
			
			require cuint proves c : UINT by qqq > and_left;
			
			ttt < (
				// Goal:
				// a - b == UINT_ZERO
				
				define Func aa = aa - (aa + c) == UINT_ZERO;
				require casezero proves Func UINT_ZERO
				by wrap Func (
					zero_satsub < (uint_add_uint_is_uint < zero_is_uint < cuint)
				);
				require casesucc proves forany aa: aa : UINT -> Func aa -> Func (aa++)
				by (
					forany aa:
					assume aauint proves aa : UINT;
					assume tttt proves Func aa;
					require tttt_ proves aa - (aa + c) == UINT_ZERO
					by unwrap Func tttt;
					
					// Goal:
					// aa++ - (aa++ + c) == UINT_ZERO
					
					require temp1 proves aa++ - (aa + c)++ == UINT_ZERO
					by tttt_ > ((succ_satsub_succ < aauint < (uint_add_uint_is_uint < aauint < cuint)) > eq_comm) > bin_sub_left_impl;
					
					wrap Func (temp1 > (((succ_add < aauint < cuint) > eq_comm) > bin_sub_right_eq) > bin_sub_left_impl)
				);
				
				require temp2 proves a - (a + c) == UINT_ZERO
				by unwrap Func (uint_inductive < casezero < casesucc < auint);
				
				temp2 > (((qqq > and_right) > eq_comm) > bin_sub_right_eq) > bin_sub_left_impl
			)
		)
	)
);

require pred_mul proves forany a,b: a : UINT -> b : UINT ->  (UINT_SATPRED a) * b == a * b - b
by (
	forany a,b:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	
	or_cases < (uint_is_zero_or_succ < auint) < (
		assume a_0 proves a == UINT_ZERO;
		
		// Goal:
		// (UINT_SATPRED a) * b == a * b - b
		
		require temp1 proves UINT_ZERO == UINT_ZERO - b
		by ((substitute a=UINT_ZERO in eq_same) > ((zero_satsub < buint) > eq_comm) > bin_sub_right_impl);
		
		require temp2 proves UINT_ZERO * b == UINT_ZERO - b
		by temp1 > ((zero_mul < buint) > eq_comm) > bin_sub_left_impl;
		
		require temp3 proves UINT_ZERO * b == (UINT_ZERO * b) - b
		by temp2 > (((zero_mul < buint) > eq_comm) > bin_sub_left_eq) > bin_sub_right_impl;
		
		require temp4 proves (UINT_SATPRED UINT_ZERO) * b == UINT_ZERO * b - b
		by temp3 > ((sat_pred_zero_is_zero > eq_comm) > bin_sub_left_eq) > bin_sub_left_impl;
		
		(temp4 > (((a_0 > eq_comm) > un_sub_arg) > bin_sub_left_eq) > bin_sub_left_impl) > (((a_0 > eq_comm) > bin_sub_left_eq) > bin_sub_left_eq) > bin_sub_right_impl
	) < (
		assume a_is_succ proves (forany x: (HAS_MEMBER UINT x -> (eq a (UINT_SUCC x)) -> FALSE)) -> FALSE;
		
		// Goal:
		// (UINT_SATPRED a) * b == a * b - b
		
		not_not_impl < (
			// Goal:
			// (((UINT_SATPRED a) * b == a * b - b) -> FALSE) -> FALSE
			
			assume ttt proves ((UINT_SATPRED a) * b == a * b - b) -> FALSE;
			
			// Goal: FALSE
			
			a_is_succ < (
				// Goal:
				// forany x: (HAS_MEMBER UINT x -> (eq a (UINT_SUCC x)) -> FALSE)
				
				forany x:
				assume xuint proves HAS_MEMBER UINT x;
				assume qqq proves a == x++;
				
				// Goal: FALSE
				
				ttt < (
					// Goal:
					// (UINT_SATPRED a) * b == a * b - b
					
					require temp1 proves x * b == x * b + b - b
					by (substitute a=x*b in eq_same) > ((add_satsub_same < (uint_mul_uint_is_uint < xuint < buint) < buint) > eq_comm) > bin_sub_right_impl;
					
					require temp2 proves x * b == (x++ * b) - b
					by temp1 > (((succ_mul < xuint < buint) > eq_comm) > bin_sub_left_eq) > bin_sub_right_impl;
					
					require temp3 proves (UINT_SATPRED x++) * b == (x++ * b) - b
					by temp2 > (((sat_pred_succ < xuint) > eq_comm) > bin_sub_left_eq) > bin_sub_left_impl;
					
					(temp3 > (((qqq > eq_comm) > un_sub_arg) > bin_sub_left_eq) > bin_sub_left_impl) > (((qqq > eq_comm) > bin_sub_left_eq) > bin_sub_left_eq) > bin_sub_right_impl
				)
			)
		)
	)
);

require satsub_satsub proves forany a,b,c: a : UINT -> b : UINT -> c : UINT  ->  (a - b) - c == a - (b + c)
by (
	forany a,b,c:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	assume cuint proves c : UINT;
	
	define Func cc = (a - b) - cc == a - (b + cc);
	
	require casezero proves Func UINT_ZERO
	by wrap Func (
		((substitute a=a-b in eq_same) > ((satsub_zero < (uint_satsub_uint_is_uint < auint < buint)) > eq_comm) > bin_sub_left_impl)
		>
		((((add_zero < buint) > eq_comm) > bin_sub_right_eq))
		>
		bin_sub_right_impl
	);
	
	require casesucc proves forany cc: cc : UINT -> Func cc -> Func (cc++)
	by (
		forany cc:
		assume ccuint proves cc : UINT;
		assume hypoth proves Func cc;
		require hypoth_ proves (a - b) - cc == a - (b + cc)
		by unwrap Func hypoth;
		wrap Func (
			// Goal:
			// (a - b) - cc++ == a - (b + cc++)
			
			require temp1 proves (UINT_SATPRED (a - (b + cc))) == (UINT_SATPRED (a - (b + cc)))
			by eq_same;
			
			require temp2 proves (UINT_SATPRED ((a - b) - cc)) == (UINT_SATPRED (a - (b + cc)))
			by temp1 > ((hypoth_ > eq_comm) > un_sub_arg) > bin_sub_left_impl;
			
			require temp3 proves (UINT_SATPRED ((a - b) - cc)) == a - ((b + cc)++)
			by temp2 > ((satsub_succ__satpred_satsub < auint < (uint_add_uint_is_uint < buint < ccuint)) > eq_comm) > bin_sub_right_impl;
			
			require temp4 proves (a - b) - cc++ == a - ((b + cc)++)
			by temp3 > ((satsub_succ__satpred_satsub < (uint_satsub_uint_is_uint < auint < buint) < ccuint) > eq_comm) > bin_sub_left_impl;
			
			require temp5 proves (a - b) - cc++ == a - (b + cc++)
			by temp4 > (((add_succ < buint < ccuint) > eq_comm) > bin_sub_right_eq) > bin_sub_right_impl;
			
			temp5
		)
	);
	
	unwrap Func (uint_inductive < casezero < casesucc < cuint)
);

require not_zero_not_one__2_le proves forany a: a : UINT  ->     a != UINT_ZERO  ->  a != UINT_ONE  ->  UINT_TWO <= a
by (
	forany a:
	assume auint proves a : UINT;
	assume a_not_0 proves a != UINT_ZERO;
	assume a_not_1 proves a != UINT_ONE;
	
	require 1_le_a proves UINT_ONE <= a
	by not_zero__one_le < auint < a_not_0;
	
	(a_not_b__a_le_b__succ_a_le_b < one_is_uint < auint < (a_not_1 > neq_comm) < 1_le_a) > (uint_two_eq_succ_one > eq_comm) > bin_sub_left_impl
);


require satsub_mul proves forany a,b,c: a : UINT -> b : UINT -> c : UINT  ->  (a - b) * c == a * c  -  b * c
by (
	forany a,b,c:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	assume cuint proves c : UINT;
	
	define Func bb = (a - bb) * c == a * c  -  bb * c;
	
	require casezero proves Func UINT_ZERO
	by wrap Func (
		// Goal:
		// (a - UINT_ZERO) * c == a * c  -  UINT_ZERO * c
		
		(
		((substitute a=a*c in eq_same) > (((satsub_zero < auint) > eq_comm) > bin_sub_left_eq) > bin_sub_left_impl)
		>
		((satsub_zero < (uint_mul_uint_is_uint < auint < cuint)) > eq_comm)
		>
		bin_sub_right_impl
		)
		>
		(((zero_mul < cuint) > eq_comm) > bin_sub_right_eq)
		>
		bin_sub_right_impl
	);
	
	require casesucc proves forany bb: bb : UINT -> Func bb -> Func (bb++)
	by (
		forany bb:
		assume bbuint proves bb : UINT;
		assume ttt proves Func bb;
		require ttt_ proves (a - bb) * c == a * c  -  bb * c
		by unwrap Func ttt;
		
		wrap Func (
			// Goal:
			// (a - bb++) * c == a * c  -  bb++ * c
			
			require temp1 proves a * c - (bb * c + c) == a * c - (bb * c + c)
			by eq_same;
			
			require temp2 proves (a * c - bb * c) - c == a * c - (bb * c + c)
			by temp1 > ((satsub_satsub < (uint_mul_uint_is_uint < auint < cuint) < (uint_mul_uint_is_uint < bbuint < cuint) < cuint) > eq_comm) > bin_sub_left_impl;
			
			require temp3 proves (a * c - bb * c) - c == a * c - (bb++ * c)
			by temp2 > (((succ_mul < bbuint < cuint) > eq_comm) > bin_sub_right_eq) > bin_sub_right_impl;
			
			require temp4 proves (a - bb) * c - c == a * c - (bb++ * c)
			by temp3 > ((ttt_ > eq_comm) > bin_sub_left_eq) > bin_sub_left_impl;
			
			require temp5 proves (UINT_SATPRED (a - bb)) * c == a * c - (bb++ * c)
			by temp4 > ((pred_mul < (uint_satsub_uint_is_uint < auint < bbuint) < cuint) > eq_comm) > bin_sub_left_impl;
			
			require temp6 proves (a - bb++) * c == a * c - (bb++ * c)
			by temp5 > (((satsub_succ__satpred_satsub < auint < bbuint) > eq_comm) > bin_sub_left_eq) > bin_sub_left_impl;
			
			temp6
		)
	);
	
	unwrap Func (uint_inductive < casezero < casesucc < buint)
);

require mul_satsub proves forany a,b,c: a : UINT -> b : UINT -> c : UINT  ->  c * (a - b) == c * a  -  c * b
by (
	forany a,b,c:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	assume cuint proves c : UINT;
	
	(((satsub_mul < auint < buint < cuint) > (mul_comm < (uint_satsub_uint_is_uint < auint < buint) < cuint) > bin_sub_left_impl)
	>
	((mul_comm < auint < cuint) > bin_sub_left_eq)
	>
	bin_sub_right_impl)
	>
	((mul_comm < buint < cuint) > bin_sub_right_eq)
	>
	bin_sub_right_impl
);


require satsub_add_same proves forany a,b: a : UINT  ->  b : UINT ->   b <= a  ->  ((a - b) + b) == a
by (
	forany a,b:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	assume b_le_a proves b <= a;
	not_not_impl < (
		assume ttt proves ((a - b) + b) != a;
		
		// Goal: FALSE
		
		unwrap uint_le b_le_a < (
			// Goal:
			// forany c: ((c : UINT) && (a == (b + c))) -> FALSE
			
			forany c:
			assume ccc proves (c : UINT) && (a == (b + c));
			
			require cuint proves c : UINT  by  ccc > and_left;
			
			ttt < (
				// Goal:
				// ((a - b) + b) == a
				
				require temp1 proves c + b == a
				by ((ccc > and_right) > eq_comm) > (add_comm < buint < cuint) > bin_sub_left_impl;
				
				require temp2 proves (((c + b) - b) + b) == a
				by temp1 > (((add_satsub_same < cuint < buint) > eq_comm) > bin_sub_left_eq) > bin_sub_left_impl;
				
				require temp3 proves (((b + c) - b) + b) == a
				by temp2 > (((add_comm < cuint < buint) > bin_sub_left_eq) > bin_sub_left_eq) > bin_sub_left_impl;
				
				require temp4 proves ((a - b) + b) == a
				by temp3 > ((((ccc > and_right) > eq_comm) > bin_sub_left_eq) > bin_sub_left_eq) > bin_sub_left_impl;
				
				temp4
			)
		)
	)
);

require not_le__neq_and_le proves forany a,b: a : UINT  ->  b : UINT ->  !(a <= b)  ->  (a != b  &&  b <= a)
by (
	forany a,b:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	assume not_a_le_b proves !(a <= b);
	
	require a_neq_b proves a != b
	by (
		assume a_b proves a == b;
		
		not_a_le_b < ((le_same < auint) > a_b > bin_sub_right_impl)
	);
	
	require b_le_a proves b <= a
	by or__not_left__right < (le_total < auint < buint) < not_a_le_b;
	
	
	impl_impl_and < a_neq_b < b_le_a
);

require succ_satsub proves forany a,b:  a : UINT  ->  b : UINT  ->  b <= a  ->  (a++ - b) == (a - b)++
by (
	forany a,b:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	assume b_leq_a proves b <= a;
	
	// Goal:
	// (a++ - b) == (a - b)++
	
	not_not_impl < (
		// Goal: 
		// (((a++ - b) == (a - b)++) -> FALSE) -> FALSE
		
		assume ttt proves ((a++ - b) == (a - b)++) -> FALSE;
		
		// Goal: FALSE
		
		unwrap uint_le b_leq_a < (
			// Goal:
			// forany c: ((c : UINT) && (a == b + c)) -> FALSE
			
			forany c:
			assume ccc proves (c : UINT) && (a == b + c);
			
			require cuint proves c : UINT by  ccc > and_left;
			
			// Goal: FALSE
			
			ttt < (
				// Goal:
				// (a++ - b) == (a - b)++
				
				require temp1 proves c++ == c++
				by eq_same;
				
				require temp2 proves b + c++ - b == c++
				by (temp1 > ((add_satsub_same < (succ_uint_is_uint < cuint) < buint) > eq_comm) > bin_sub_left_impl) > ((add_comm < (succ_uint_is_uint < cuint) < buint) > bin_sub_left_eq) > bin_sub_left_impl;
				
				require temp3 proves (b + c)++ - b == c++
				by temp2 > ((add_succ < buint < cuint) > bin_sub_left_eq) > bin_sub_left_impl;
				
				require temp4 proves (b + c)++ - b == (b + c - b)++
				by (temp3 > (((add_satsub_same < cuint < buint) > eq_comm) > un_sub_arg) > bin_sub_right_impl) > (((add_comm < cuint < buint) > bin_sub_left_eq) > un_sub_arg) > bin_sub_right_impl;
				
				require temp5 proves a++ - b == (a - b)++
				by (temp4 > ((((ccc > and_right) > eq_comm) > un_sub_arg) > bin_sub_left_eq) > bin_sub_left_impl) > ((((ccc > and_right) > eq_comm) > bin_sub_left_eq) > un_sub_arg) > bin_sub_right_impl;
				
				temp5
			)
		)
	)
);

require nonzero_satsub_notzero__neq proves forany a,b: a : UINT  ->  b : UINT  ->  a != UINT_ZERO  ->  b != UINT_ZERO  ->  (a - b) != a
by (
	forany a,b:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	assume a_not_0 proves a != UINT_ZERO;
	assume b_not_0 proves b != UINT_ZERO;
	
	or_cases < yay_or_nay < (
		assume a_le_b proves a <= b;
		
		require a_sub_b_is_0 proves a - b == UINT_ZERO
		by satsub_saturates < auint < buint < a_le_b;
		
		(a_not_0 > ((a_sub_b_is_0 > eq_comm) > bin_sub_right_eq) > bin_sub_left_impl) > neq_comm
	) < (
		assume not_a_le_b proves !(a <= b);
		
		require b_le_a proves b <= a
		by (not_le__neq_and_le < auint < buint < not_a_le_b) > and_right;
		
		require a_not_b proves a != b
		by (not_le__neq_and_le < auint < buint < not_a_le_b) > and_left;
		
		assume ab_a proves a - b == a;
		
		// Goal: FALSE
		
		unwrap uint_le b_le_a < (
			// Goal:
			// forany c: ((c : UINT) && (a == (b + c))) -> FALSE;
			
			forany c:
			assume ccc proves (c : UINT) && (a == (b + c));
			
			// Goal: FALSE
			
			require cuint proves c : UINT  by  ccc > and_left;
			
			// a = b + c
			// a - b = a
			
			// b + c - b = a
			// c = a
			// a = b + a
			//   add_left_eq_self
			// b = 0
			
			require temp1 proves b + c - b == a
			by ab_a > ((ccc > and_right) > bin_sub_left_eq) > bin_sub_left_impl;
			
			require temp2 proves c + b - b == a
			by temp1 > ((add_comm < buint < cuint) > bin_sub_left_eq) > bin_sub_left_impl;
			
			require temp3 proves c == a
			by temp2 > (add_satsub_same < cuint < buint) > bin_sub_left_impl;
			
			require temp4 proves a == b + a
			by (ccc > and_right) > (temp3 > bin_sub_right_eq) > bin_sub_right_impl;
			
			require temp5 proves b == UINT_ZERO
			by add_left_eq_self < buint < auint < (temp4 > eq_comm);
			
			b_not_0 < temp5
		)
	)
);

require satsub_le_left proves forany a,b: a : UINT  ->  b : UINT ->  (a - b) <= a
by (
	forany a,b:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	wrap uint_le (
		assume bbb proves forany c: ((c : UINT) && (a == ((a - b) + c))) -> FALSE;
		
		// Goal: FALSE
		
		or_cases < yay_or_nay < (
			assume ab proves a <= b;
			
			unwrap uint_le ab < (
				// Goal:
				// forany d: ((d : UINT) && (b == (a + d))) -> FALSE
				
				forany d:
				assume ddd proves (d : UINT) && (b == (a + d));
				
				// Goal: FALSE
				
				bbb < (
					// Goal:
					// forSOME c: (c : UINT) && (a == ((a - b) + c))
					
					// b = a + d
					
					// satsub_saturates          a <= b  ->  a - b == 0
					require a_minus_b__0 proves a - b == UINT_ZERO
					by satsub_saturates < auint < buint < ab;
					
					require temp1 proves a == a   by eq_same;
					require temp2 proves a == UINT_ZERO + a   by temp1 > ((zero_add < auint) > eq_comm) > bin_sub_right_impl;
					require temp3 proves a == (a - b) + a  by temp2 > ((a_minus_b__0 > eq_comm) > bin_sub_left_eq) > bin_sub_right_impl;
					
					impl_impl_and < auint < temp3
				)
			)
		) < (
			assume not_ab proves (a <= b) -> FALSE;
			
			require ba proves b <= a  by  (not_le__neq_and_le < auint < buint < not_ab) > and_right;
			
			// Goal: FALSE
			
			unwrap uint_le ba < (
				// Goal:
				// forany e: ((e : UINT) && (a == (b + e))) -> FALSE
				
				forany e:
				assume eee proves (e : UINT) && (a == (b + e));
				
				// Goal: FALSE
				
				bbb < (
					// Goal:
					// forSOME c: (c : UINT) && (a == ((a - b) + c))
					
					// a == b + e
					
					require temp2 proves a == (a - b) + b
					by (satsub_add_same < auint < buint < ba) > eq_comm;
					
					impl_impl_and < buint < temp2
				)
			)
		)
	)
);

require satsub__same_satsub proves forany a,b: a : UINT  ->  b : UINT  ->  b <= a  ->  a - (a - b) == b
by (
	forany a,b:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	assume b_le_a proves b <= a;
	
	not_not_impl < (
		assume ttt proves a - (a - b) != b;
		
		// Goal: FALSE
		
		unwrap uint_le b_le_a < (
			forany c:
			assume ccc proves (c : UINT) && (a == (b + c));
			
			// Goal: FALSE
			
			require cuint proves c : UINT  by ccc > and_left;
			require a_bc proves a == b + c  by ccc > and_right;
			
			ttt < (
				// Goal:
				// a - (a - b) == b
				
				require temp1 proves b + c - c == b by add_satsub_same < buint < cuint;
				require temp2 proves a - c == b  by temp1 > ((a_bc > eq_comm) > bin_sub_left_eq) > bin_sub_left_impl;
				require temp3 proves a - (c + b - b) == b by temp2 > (((add_satsub_same < cuint < buint) > eq_comm) > bin_sub_right_eq) > bin_sub_left_impl;
				require temp4 proves a - (b + c - b) == b by temp3 > (((add_comm < cuint < buint) > bin_sub_left_eq) > bin_sub_right_eq) > bin_sub_left_impl;
				require temp5 proves a - (a - b) == b by temp4 > (((a_bc > eq_comm) > bin_sub_left_eq) > bin_sub_right_eq) > bin_sub_left_impl;
				
				temp5
				
				// b = b
				// b + c - c == b
				// a - c == b
				// a - (c + b - b) == b
				// a - (b + c - b) == b
				// a - (a - b) == b
			)
		)
	)
);


















require everything_divisible_by_one proves forany n:  n : UINT  ->  is_divisible_by n UINT_ONE
by (
	forany n:
	assume nuint proves n : UINT;
	wrap is_divisible_by (impl_impl_and < (impl_impl_and < nuint < one_is_uint) < (
		// Goal:
		// !(forany x: !((x : UINT) && x * UINT_ONE == n))
		
		assume ttt proves forany x: !((x : UINT) && x * UINT_ONE == n);
		
		// Goal: FALSE
		
		ttt < (
			// forSOME x: (x : UINT)  &&  x * UINT_ONE == n
			impl_impl_and < nuint < (mul_one < nuint)
		)
	))
);

require zero_divisible_by_everything proves forany n:  n : UINT  ->  is_divisible_by UINT_ZERO n
by (
	forany n:
	assume nuint proves n : UINT;
	wrap is_divisible_by (impl_impl_and < (impl_impl_and < zero_is_uint < nuint) < (
		// Goal:
		// !(forany x: !((x : UINT) && x * n == UINT_ZERO))
		
		assume ttt proves forany x: !((x : UINT) && x * n == UINT_ZERO);
		
		// Goal: FALSE
		
		ttt < (
			// forSOME x: (x : UINT)  &&  x * n == UINT_ZERO
			impl_impl_and < zero_is_uint < (zero_mul < nuint)
		)
	))
);


require divisible_by_self proves forany n:  n : UINT  ->  is_divisible_by n n
by (
	forany n:
	assume nuint proves n : UINT;
	wrap is_divisible_by (impl_impl_and < (impl_impl_and < nuint < nuint) < (
		// Goal:
		// !(forany x: !((x : UINT) && x * n == n))
		
		assume ttt proves forany x: !((x : UINT) && x * n == n);
		
		// Goal: FALSE
		
		ttt < (
			// forSOME x: (x : UINT)  &&  x * n == n
			impl_impl_and < one_is_uint < (one_mul < nuint)
		)
	))
);

require divisible__multiple_also_divisible proves forany n,o,p:  p : UINT  ->  is_divisible_by n o  ->  is_divisible_by (n*p) o
by (
	forany n,o,p:
	assume puint proves p : UINT;
	assume NO proves is_divisible_by n o;
	require NO_ proves (n : UINT) && (o : UINT) && !(forany x: !((x : UINT) && x * o == n))
	by unwrap is_divisible_by NO;
	require nuint proves n : UINT  by  (NO_ > and_left) > and_left;
	require ouint proves o : UINT  by  (NO_ > and_left) > and_right;
	wrap is_divisible_by (impl_impl_and < (impl_impl_and < (uint_mul_uint_is_uint < nuint < puint) < ouint) < (
		// Goal:
		// !(forany x: !((x : UINT) && x * o == (n*p)))
		
		assume ttt proves forany x: !((x : UINT) && x * o == (n*p));
		
		// Goal:
		// FALSE
		
		(NO_ > and_right) < (
			// Goal:
			// forany xx: !((xx : UINT) && xx * o == n)
			
			forany xx:
			assume temp2 proves (xx : UINT) && xx * o == n;
			
			// Goal:
			// FALSE
			
			ttt < (
				// Goal:
				// forSOME x: (x : UINT) && x * o == (n*p)
				
				require xxuint proves xx : UINT  by  temp2 > and_left;
				
				impl_impl_and
				<
				(uint_mul_uint_is_uint < xxuint < puint)
				<
				(
					(
						(
							((temp2 > and_right) > (substitute f=UINT_MUL, c=p in wrap_in_bin_func_lhs))
							>
							(mul_assoc < xxuint < ouint < puint)
							>
							bin_sub_left_impl
						)
						>
						((mul_comm < ouint < puint) > bin_sub_right_eq)
						>
						bin_sub_left_impl
					)
					>
					((mul_assoc < xxuint < puint < ouint) > eq_comm)
					>
					bin_sub_left_impl
				)
			)
		)
	))
);

require mul_not_divisible__left proves forany n,o,p:  o : UINT  ->  !(is_divisible_by (n*o) p)  ->  !(is_divisible_by n p)
by (
	forany o:
	assume ouint proves o : UINT;
	
	(ouint > divisible__multiple_also_divisible) > impl_reverse
);

require divisible_by_same__sum_too proves forany n,o,p:   is_divisible_by n p  ->  is_divisible_by o p  ->  is_divisible_by (n+o) p
by (
	forany n,o,p:
	assume NP proves is_divisible_by n p;
	assume OP proves is_divisible_by o p;
	
	require nuint proves n : UINT by (unwrap is_divisible_by NP > and_left) > and_left;
	require ouint proves o : UINT by (unwrap is_divisible_by OP > and_left) > and_left;
	require puint proves p : UINT by (unwrap is_divisible_by NP > and_left) > and_right;
	
	wrap is_divisible_by (
		// Goal:
		// ((n+o) : UINT) && (p : UINT) && !(forany x: !((x : UINT) && x * p == (n+o)));
		
		impl_impl_and < (impl_impl_and < (uint_add_uint_is_uint < nuint < ouint) < puint) < (
			// Goal:
			// !(forany x: !((x : UINT) && x * p == (n+o)))
			
			assume ttt proves forany x: !((x : UINT) && x * p == (n+o));
			
			// Goal: FALSE
			
			(unwrap is_divisible_by NP > and_right) < (
				// Goal:
				// forany y: !((y : UINT) && y * p == n)
				
				forany y:
				assume uuu proves (y : UINT) && y * p == n;
				
				require yuint proves y : UINT by uuu > and_left;
				
				// Goal: FALSE
				
				(unwrap is_divisible_by OP > and_right) < (
					// Goal:
					// forany z: !((z : UINT) && z * p == o)
					
					forany z:
					assume vvv proves (z : UINT) && z * p == o;
					
					require zuint proves z : UINT by vvv > and_left;
					
					// Goal: FALSE
					
					ttt < (
						// Goal:
						// forSOME x: (x : UINT) && x * p == (n+o)
						
						// y * p = n
						// z * p = o
						
						require temp1 proves y * p + o  ==  n + o
						by add_same_impl_rev < (uint_mul_uint_is_uint < yuint < puint) < nuint < ouint < (uuu > and_right);
						
						require temp2 proves y * p + z * p == n + o
						by temp1 > (((vvv > and_right) > eq_comm) > bin_sub_right_eq) > bin_sub_left_impl;
						
						require temp3 proves (y + z) * p == n + o
						by temp2 > ((add_mul < yuint < zuint < puint) > eq_comm) > bin_sub_left_impl;
						
						impl_impl_and < (uint_add_uint_is_uint < yuint < zuint) < temp3
					)
				)
			)
		)
	)
);

require mul_is_divisible_right proves forany n,o: n : UINT  ->  o : UINT  ->  is_divisible_by (n*o) o
by (
	forany n,o:
	assume nuint proves n : UINT;
	assume ouint proves o : UINT;
	wrap is_divisible_by (
		impl_impl_and < (impl_impl_and < (uint_mul_uint_is_uint < nuint < ouint) < ouint) < (
			// Goal:
			// !(forany x: !((x : UINT) && x * o == (n*o)))
			assume ttt proves forany x: !((x : UINT) && x * o == (n*o));
			// Goal: FALSE
			ttt < (
				// Goal:
				// forSOME x: (x : UINT) && x * o == (n*o)
				impl_impl_and < nuint < eq_same
			)
		)
	)
);

require divisible_by_same__satsub_too proves forany n,o,p:   is_divisible_by n p  ->  is_divisible_by o p  ->  is_divisible_by (n - o) p
by (
	forany n,o,p:
	assume NP proves is_divisible_by n p;
	assume OP proves is_divisible_by o p;
	
	require nuint proves n : UINT by (unwrap is_divisible_by NP > and_left) > and_left;
	require ouint proves o : UINT by (unwrap is_divisible_by OP > and_left) > and_left;
	require puint proves p : UINT by (unwrap is_divisible_by NP > and_left) > and_right;
	
	wrap is_divisible_by (
		// Goal:
		// ((n - o) : UINT) && (p : UINT) && !(forany x: !((x : UINT) && x * p == (n - o)))
		
		impl_impl_and < (impl_impl_and < (uint_satsub_uint_is_uint < nuint < ouint) < puint) < (
			// Goal:
			// !(forany x: !((x : UINT) && x * p == (n - o)))
			
			assume xxx proves forany x: !((x : UINT) && x * p == (n - o));
			
			// Goal: FALSE
			
			or_cases < (le_total < nuint < ouint) < (
				assume NO proves n <= o;
				
				// Goal: FALSE
				
				require no_0 proves n - o == UINT_ZERO
				by satsub_saturates < nuint < ouint < NO;
				
				xxx < (
					// Goal:
					// forSOME x: (x : UINT) && x * p == (n - o)
					impl_impl_and < zero_is_uint < (
						// Goal:
						// UINT_ZERO * p == (n - o)
						
						((substitute a=n-o in eq_same) > no_0 > bin_sub_left_impl) > ((zero_mul < puint) > eq_comm) > bin_sub_left_impl
					)
				)
			) < (
				assume NO proves o <= n;
				
				// Goal: FALSE
				
				(unwrap is_divisible_by NP > and_right) < (
					// Goal:
					// forany z: !((z : UINT) && z * p == n)
					
					forany z:
					assume zzz proves (z : UINT) && z * p == n;
					
					require zuint proves z : UINT  by zzz > and_left;
					
					// Goal: FALSE
					
					(unwrap is_divisible_by OP > and_right) < (
						// Goal:
						// forany y: !((y : UINT) && y * p == o)
						
						forany y:
						assume yyy proves (y : UINT) && y * p == o;
						
						require yuint proves y : UINT  by yyy > and_left;
						
						// Goal: FALSE
						
						(unwrap uint_le NO) < (
							// Goal:
							// forany c: ((c : UINT) && (n == (o + c))) -> FALSE
							
							forany c:
							assume ccc proves (c : UINT) && (n == (o + c));
							
							// Goal: FALSE
							
							xxx < (
								// Goal:
								// forSOME x: (x : UINT) && x * p == (n - o)
								
								bin_sub_right_impl < (bin_sub_right_eq < (bin_sub_left_eq < (zzz > and_right))) < (
									// Goal:
									// forSOME x: (x : UINT) && x * p == (z * p - o)
									
									bin_sub_right_impl < (bin_sub_right_eq < (bin_sub_right_eq < (yyy > and_right))) < (
										// Goal:
										// forSOME x: (x : UINT) && x * p == (z * p - y * p)
										
										// Goal:
										// forSOME x: ((z - y) : UINT) && (z - y) * p == (z * p - y * p)
										
										require temp1 proves (z * p - y * p) == (z * p - y * p)
										by eq_same;
										
										require temp2 proves (z - y) * p == (z * p - y * p)
										by temp1 > ((satsub_mul < zuint < yuint < puint) > eq_comm) > bin_sub_left_impl;
										
										impl_impl_and < (uint_satsub_uint_is_uint < zuint < yuint) < temp2
									)
								)
							)
						)
					)
				)
			)
		)
	)
);

require num_plus_denom proves forany n,o: n : UINT -> o != UINT_ZERO -> is_divisible_by (n+o) o  ->  is_divisible_by n o
by (
	forany n,o:
	assume nuint proves n : UINT;
	assume o_not_0 proves o != UINT_ZERO;
	
	impl_reverse_back < (
		// Goal:
		// !is_divisible_by n o   ->   !is_divisible_by (n+o) o
		
		assume not_no proves is_divisible_by n o -> FALSE;
		assume no_o proves is_divisible_by (n+o) o;
		require no_o_ proves ((n+o) : UINT) && (o : UINT) && !(forany x: !((x : UINT) && x * o == (n+o)))
		by unwrap is_divisible_by no_o;
		require ouint proves o : UINT by (no_o_ > and_left) > and_right;
		
		// Goal: FALSE
		
		not_no < (
			// Goal:
			// is_divisible_by n o
			
			wrap is_divisible_by (
				// Goal:
				// (n : UINT) && (o : UINT) && !(forany x: !((x : UINT) && x * o == n))
				
				impl_impl_and < (impl_impl_and < nuint < ouint) < (
					// Goal:
					// !(forany x: !((x : UINT) && x * o == n))
					
					assume ttt proves forany x: !((x : UINT) && x * o == n);
					
					// Goal: FALSE
					
					(no_o_ > and_right) < (
						// Goal:
						// forany z: !((z : UINT) && z * o == (n+o))
						forany z:
						assume uuu proves (z : UINT) && z * o == n + o;
						
						// Goal: FALSE
						
						require zuint proves z : UINT by uuu > and_left;
						
						require zo_not_0 proves z * o != UINT_ZERO
						by (add_nonzero_right < nuint < ouint < o_not_0) > (((uuu > and_right) > eq_comm) > bin_sub_left_eq) > bin_sub_left_impl;
						
						require z_not_0 proves z != UINT_ZERO
						by mul_not_zero__left_not_zero < zuint < ouint < zo_not_0;
						
						or__not_left__right < (uint_is_zero_or_succ < zuint) < z_not_0 < (
							// Goal:
							// forany b: HAS_MEMBER UINT b -> (eq z (UINT_SUCC b)) -> FALSE
							forany b:
							assume buint proves b : UINT;
							assume z_sb proves z == b++;
							
							// Goal: FALSE
							
							ttt < (
								// Goal:
								// forSOME x: (x : UINT) && x * o == n
								
								require temp1 proves (b++) * o == n + o
								by (uuu > and_right) > (z_sb > bin_sub_left_eq) > bin_sub_left_impl;
								
								require temp2 proves b * o + o == n + o
								by temp1 > (succ_mul < buint < ouint) > bin_sub_left_impl;
								
								require temp3 proves b * o == n
								by add_same_impl < (uint_mul_uint_is_uint < buint < ouint) < nuint < ouint < temp2;
								
								impl_impl_and < buint < temp3
							)
						)
					)
				)
			)
		)
	)
);

require one_divisible__divisor_is_one proves forany n: is_divisible_by UINT_ONE n  ->  n == UINT_ONE
by (
	forany n:
	assume ttt proves is_divisible_by UINT_ONE n;
	require ttt_ proves (UINT_ONE : UINT) && (n : UINT) && !(forany x: !((x : UINT) && x * n == UINT_ONE))    by unwrap is_divisible_by ttt;
	require nuint proves n : UINT  by  (ttt_ > and_left) > and_right;
	
	not_not_impl < (
		// Goal:
		// ((n == UINT_ONE) -> FALSE) -> FALSE
		
		assume uuu proves (n == UINT_ONE) -> FALSE;
		
		// Goal: FALSE
		
		(ttt_ > and_right) < (
			// Goal:
			// forany x: !((x : UINT) && x * n == UINT_ONE)
			
			forany x:
			assume qqq proves (x : UINT) && x * n == UINT_ONE;
			
			require xuint proves x : UINT by  qqq > and_left;
			
			// Goal: FALSE
			
			uuu < (
				// Goal:
				// n == UINT_ONE
				
				require nx_1 proves n * x == UINT_ONE
				by (qqq > and_right) > (mul_comm < xuint < nuint) > bin_sub_left_impl;
				
				mul_is_one__left_is_one < nuint < xuint < nx_1
			)
		)
	)
);

require if_divisible_then_succ_not_divisible proves forany n,o:  is_divisible_by n o  ->   o != UINT_ONE  ->  !(is_divisible_by (n++) o)
by (
	forany n,o:
	assume NO proves is_divisible_by n o;
	assume O_not_1 proves o != UINT_ONE;
	assume SNO proves is_divisible_by (n++) o;
	
	require nuint proves n : UINT  by  (unwrap is_divisible_by NO > and_left) > and_left;
	require ouint proves o : UINT  by  (unwrap is_divisible_by NO > and_left) > and_right;
	
	require temp1 proves is_divisible_by (n++ - n) o
	by divisible_by_same__satsub_too < SNO < NO;
	
	require temp2 proves is_divisible_by (UINT_ZERO++) o
	by (temp1 > (succ_satsub < nuint < nuint < (le_same < nuint)) > bin_sub_left_impl) > ((satsub_same < nuint) > un_sub_arg) > bin_sub_left_impl;
	
	require temp3 proves o == UINT_ONE
	by (temp2 > (uint_one_eq_succ_zero > eq_comm) > bin_sub_left_impl) > one_divisible__divisor_is_one;
	
	temp3 > O_not_1
);

require not_divisible_by_bigger proves forany n,o: n : UINT  ->  o : UINT  ->  (n != UINT_ZERO)  ->  (n <= o)  ->  (n != o)  ->  !(is_divisible_by n o)
by (
	forany n,o:
	assume nuint proves n : UINT;
	assume ouint proves o : UINT;
	assume n_not_0 proves n != UINT_ZERO;
	assume n_le_o proves n <= o;
	assume n_not_o proves n != o;
	assume ttt proves is_divisible_by n o;
	
	require o_not_n proves o != n  by  n_not_o > eq_comm_eq > bin_sub_left_impl;
	
	// Goal: FALSE
	
	(unwrap is_divisible_by ttt > and_right) < (
		// Goal:
		// forany x: !((x : UINT) && x * o == n)
		
		forany x:
		assume yyy proves (x : UINT) && x * o == n;
		
		require xuint proves x : UINT    by yyy > and_left;
		require xo_n proves x * o == n   by yyy > and_right;
		
		// Goal: FALSE
		
		unwrap uint_le n_le_o < (
			// Goal:
			// forany c: ((c : UINT) && (o == (n + c))) -> FALSE
			
			forany c:
			assume uuu proves (c : UINT) && (o == (n + c));
			
			require o_nc proves o == n + c   by uuu > and_right;
			require cuint proves c: UINT     by uuu > and_left;
			
			// Goal: FALSE
			
			require 1_le_n proves UINT_ONE <= n
			by not_zero__one_le < nuint < n_not_0;
			
			// 1 <= n
			// o != n
			// n != 0
			// o = n + c
			// x * o = n
			
			unwrap uint_le 1_le_n < (
				// Goal:
				// forany r: ((r : UINT) && (n == (UINT_ONE + r))) -> FALSE
				
				forany r:
				assume rrr proves (r : UINT) && (n == (UINT_ONE + r));
				
				require ruint proves r : UINT  by  rrr > and_left;
				
				require rrr_ proves n == r++
				by (rrr > and_right) > (one_add_eq_succ < ruint) > bin_sub_right_impl;
				
				// Goal: FALSE
				
				require 1_le_o proves UINT_ONE <= o
				by le_trans < one_is_uint < nuint < ouint < 1_le_n < n_le_o;
				
				require x_not_0 proves x != UINT_ZERO
				by mul_not_zero__left_not_zero < xuint < ouint < (n_not_0 > ((xo_n > eq_comm) > bin_sub_left_eq) > bin_sub_left_impl);
				
				require o_not_0 proves o != UINT_ZERO
				by one_le__not_zero < ouint < 1_le_o;
				
				// 1 <= o
				// 1 <= n
				// n <= o
				
				// x != 0
				// o != 0
				// n != 0
				// o != n
				
				// n = r++
				// o = n + c
				// x * o = n
				
				// Consider three cases for x:
				// if x == 0, then by x*o = n we get n = 0, which contradicts n != 0
				// if x == 1, then by x*o = n we get n = o, which contradicts o != n
				// if x >= 2
				
				or_cases < (uint_is_zero_or_succ < xuint) < (
					assume x_0 proves x == UINT_ZERO;
					x_0 > x_not_0
				) < (
					assume x_is_succ proves (forany j: (HAS_MEMBER UINT j -> (x == j++) -> FALSE)) -> FALSE;
					
					x_is_succ < (
						// Goal:
						// forany j: HAS_MEMBER UINT j -> (x == j++) -> FALSE
						
						forany j:
						assume juint proves j : UINT;
						assume x_sj proves x == j++;
						
						// Goal: FALSE
						
						or_cases < (uint_is_zero_or_succ < juint) < (
							assume j_0 proves j == UINT_ZERO;
							
							require x_1 proves x == UINT_ONE
							by (x_sj > (j_0 > un_sub_arg) > bin_sub_right_impl) > (uint_one_eq_succ_zero > eq_comm) > bin_sub_right_impl;
							
							require o_n proves o == n
							by (xo_n > (x_1 > bin_sub_left_eq) > bin_sub_left_impl) > (one_mul < ouint) > bin_sub_left_impl;
							
							o_n > o_not_n
						) < (
							assume j_is_succ proves (forany q: (HAS_MEMBER UINT q -> (j == q++) -> FALSE)) -> FALSE;
							
							j_is_succ < (
								// Goal:
								// forany q: (HAS_MEMBER UINT q -> (j == q++) -> FALSE)
								
								forany q:
								assume quint proves q : UINT;
								assume j_sq proves j == q++;
								
								// Goal: FALSE
								
								require temp1 proves (j++) * o == n
								by xo_n > (x_sj > bin_sub_left_eq) > bin_sub_left_impl;
								
								require temp2 proves j * o + o == n
								by temp1 > (succ_mul < juint < ouint) > bin_sub_left_impl;
								
								require temp3 proves j * o + (n + c) == n
								by (temp2 > (o_nc > bin_sub_right_eq) > bin_sub_left_impl);
								
								require temp4 proves j * o + (c + n) == n
								by temp3 > ((add_comm < nuint < cuint) > bin_sub_right_eq) > bin_sub_left_impl;
								
								require temp5 proves j * o + c + n == n
								by temp4 > ((add_assoc < (uint_mul_uint_is_uint < juint < ouint) < cuint < nuint) > eq_comm) > bin_sub_left_impl;
								
								require temp6 proves j * o + c == UINT_ZERO
								by temp5 > (add_left_eq_self < (uint_add_uint_is_uint < (uint_mul_uint_is_uint < juint < ouint) < cuint) < nuint);
								
								require temp7 proves j * o == UINT_ZERO
								by (sum_zero_both_zero < (uint_mul_uint_is_uint < juint < ouint) < cuint < temp6) > and_left;
								
								or_cases < (mul_is_zero__either_is_zero < juint < ouint < temp7) < (
									assume j_0 proves j == UINT_ZERO;
									succ_not_zero < quint < (j_0 > (j_sq) > bin_sub_left_impl)
								) < (
									assume o_0 proves o == UINT_ZERO;
									o_not_0 < o_0
								)
							)
						)
					)
				)
			)
		)
	)
);

require nonzero_not_divisible_by_zero proves forany n: n : UINT -> n != UINT_ZERO -> !(is_divisible_by n UINT_ZERO)
by (
	forany n:
	assume nuint proves n : UINT;
	assume n_not_0 proves n != UINT_ZERO;
	assume n0 proves is_divisible_by n UINT_ZERO;
	(unwrap is_divisible_by n0 > and_right) < (
		// Goal:
		// forany x: !((x : UINT) && x * UINT_ZERO == n)
		
		forany x:
		assume ttt proves (x : UINT) && x * UINT_ZERO == n;
		
		// Goal: FALSE
		
		(((ttt > and_right) > (mul_zero < (ttt > and_left)) > bin_sub_left_impl) > eq_comm) > n_not_0
	)
);

require divisible_by_zero__is_zero proves forany n: n : UINT  ->  is_divisible_by n UINT_ZERO  ->  n == UINT_ZERO
by (
	forany n:
	assume nuint proves n : UINT;
	assume n0 proves is_divisible_by n UINT_ZERO;
	
	// Goal:
	// n == UINT_ZERO
	
	not_not_impl < (
		// Goal:
		// ((n == UINT_ZERO) -> FALSE) -> FALSE
		
		assume n_not_0 proves n == UINT_ZERO -> FALSE;
		
		(unwrap is_divisible_by n0 > and_right) < (
			// Goal:
			// forany x: !((x : UINT) && x * UINT_ZERO == n)
			
			forany x:
			assume ttt proves (x : UINT) && x * UINT_ZERO == n;
			
			// Goal: FALSE
			
			n_not_0 < (
				// Goal:
				// n == UINT_ZERO
				
				((ttt > and_right) > (mul_zero < (ttt > and_left)) > bin_sub_left_impl) > eq_comm
			)
		)
	)
);

require divisible_trans proves forany a,b,c: is_divisible_by a b -> is_divisible_by b c -> is_divisible_by a c
by (
	forany a,b,c:
	assume AB proves is_divisible_by a b;
	assume BC proves is_divisible_by b c;
	require auint proves a : UINT by (unwrap is_divisible_by AB > and_left) > and_left;
	require buint proves b : UINT by (unwrap is_divisible_by AB > and_left) > and_right;
	require cuint proves c : UINT by (unwrap is_divisible_by BC > and_left) > and_right;
	wrap is_divisible_by (
		// Goal:
		// (a : UINT) && (c : UINT) && !(forany x: !((x : UINT) && x * c == a));
		
		impl_impl_and < (impl_impl_and < auint < cuint) < (
			// Goal:
			// !(forany x: !((x : UINT) && x * c == a))
			
			assume xxx proves forany x: !((x : UINT) && x * c == a);
			
			// Goal: FALSE
			
			(unwrap is_divisible_by AB > and_right) < (
				// Goal:
				// forany y: !((y : UINT) && y * b == a)
				
				forany y:
				assume yyy proves (y : UINT) && y * b == a;
				require yuint proves y : UINT  by  yyy > and_left;
				
				// Goal: FALSE
				
				(unwrap is_divisible_by BC > and_right) < (
					// Goal:
					// forany z: !((z : UINT) && z * c == b)
					
					forany z:
					assume zzz proves (z : UINT) && z * c == b;
					require zuint proves z : UINT  by  zzz > and_left;
					
					// Goal: FALSE
					
					xxx < (
						// Goal:
						// forSOME x: (x : UINT) && x * c == a
						
						// y * b == a
						// z * c == b
						
						require yz_c__a proves y * z * c == a
						by ((yyy > and_right) > (((zzz > and_right) > eq_comm) > bin_sub_right_eq) > bin_sub_left_impl) > ((mul_assoc < yuint < zuint < cuint) > eq_comm) > bin_sub_left_impl;
						
						impl_impl_and < (uint_mul_uint_is_uint < yuint < zuint) < yz_c__a
					)
				)
			)
		)
	)
);

require divisor_is_le proves forany a,b: a != UINT_ZERO -> is_divisible_by a b -> b <= a
by (
	forany a,b:
	assume a_not_0 proves a != UINT_ZERO;
	assume AB proves is_divisible_by a b;
	require buint proves b : UINT   by (unwrap is_divisible_by AB > and_left) > and_right;
	
	not_not_impl < (
		assume ttt proves !(b <= a);
		
		// Goal: FALSE
		
		(unwrap is_divisible_by AB > and_right) < (
			// Goal:
			// forany x: !((x : UINT) && x * b == a)
			
			forany x:
			assume xxx proves (x : UINT) && x * b == a;
			require xuint proves x : UINT   by xxx > and_left;
			
			// Goal: FALSE
			
			ttt < (
				// Goal: b <= a
				
				require xb_not_0 proves x * b != UINT_ZERO
				by a_not_0 > (((xxx > and_right) > eq_comm) > bin_sub_left_eq) > bin_sub_left_impl;
				
				require b_le_xb proves b <= x * b
				by mul_not_zero__right_le_mul < xuint < buint < xb_not_0;
				
				b_le_xb > (xxx > and_right) > bin_sub_right_impl
			)
		)
	)
);

// define is_divisible_by n o = (n : UINT) && (o : UINT) && !(forany x: !((x : UINT) && x * o == n));

// define uint_le a b = (forany c: ((c : UINT) && (b == (a + c))) -> FALSE) -> FALSE;

require divisor_not_zero proves forany n,o: n != UINT_ZERO  ->  is_divisible_by n o  ->  o != UINT_ZERO
by (
	forany n,o:
	assume n_not_0 proves n != UINT_ZERO;
	assume n_o proves is_divisible_by n o;
	assume o_0 proves o == UINT_ZERO;
	
	// Goal: FALSE
	
	(unwrap is_divisible_by n_o > and_right) < (
		// Goal:
		// forany x: !((x : UINT) && x * o == n)
		
		forany x:
		assume xxx proves (x : UINT) && x * o == n;
		
		// Goal: FALSE
		
		require x0_n proves x * UINT_ZERO == n
		by (xxx > and_right) > (o_0 > bin_sub_right_eq) > bin_sub_left_impl;
		
		n_not_0 < ((x0_n > (mul_zero < (xxx > and_left)) > bin_sub_left_impl) > eq_comm)
	)
);
















require one_is_not_zero proves UINT_ONE != UINT_ZERO
by (
	(succ_not_zero < zero_is_uint) > ((uint_one_eq_succ_zero > eq_comm) > bin_sub_left_eq) > bin_sub_left_impl
);

require two_is_not_one proves UINT_TWO != UINT_ONE
by (
	assume tt proves UINT_TWO == UINT_ONE;
	
	(((tt > uint_two_eq_succ_one > bin_sub_left_impl) > uint_one_eq_succ_zero > bin_sub_right_impl) > (succ_inj < one_is_uint < zero_is_uint))
	>
	one_is_not_zero
);

require two_is_not_zero proves UINT_TWO != UINT_ZERO
by (
	(succ_not_zero < one_is_uint) > ((uint_two_eq_succ_one > eq_comm) > bin_sub_left_eq) > bin_sub_left_impl
);

require zero_not_prime proves !(is_prime UINT_ZERO)
by (
	assume ttt proves is_prime UINT_ZERO;
	
	require ttt_ proves forany d:  d : UINT  ->  d != UINT_ONE  ->  d != UINT_ZERO  ->  !(is_divisible_by UINT_ZERO d)
	by (unwrap is_prime ttt > and_right);
	
	// Goal:
	// FALSE
	
	ttt_ < two_is_uint < two_is_not_one < two_is_not_zero < (zero_divisible_by_everything < two_is_uint)
);

require one_not_prime proves !(is_prime UINT_ONE)
by (
	assume ttt proves is_prime UINT_ONE;
	((unwrap is_prime ttt > and_left) > and_right) > neq_same
);

require two_le_prime proves forany a: is_prime a  ->  UINT_TWO <= a
by (
	forany a:
	assume aprime proves is_prime a;
	require a_not_0 proves a != UINT_ZERO
	by (
		assume a_0 proves a == UINT_ZERO;
		zero_not_prime < (aprime > ((a_0 > un_sub_arg) > eq_ltr))
	);
	require a_not_1 proves a != UINT_ONE
	by (
		assume a_1 proves a == UINT_ONE;
		one_not_prime < (aprime > ((a_1 > un_sub_arg) > eq_ltr))
	);
	not_zero_not_one__2_le < ((unwrap is_prime aprime > and_left) > and_left) < a_not_0 < a_not_1
);

require even_not_two_not_prime proves forany n: is_even n  ->  n != UINT_TWO  ->  !(is_prime n)
by (
	forany n:
	assume n_even proves is_even n;
	assume n_not_2 proves n != UINT_TWO;
	assume n_prime proves is_prime n;
	
	// Goal: FALSE
	
	(unwrap is_prime n_prime > and_right) < two_is_uint < two_is_not_one < (n_not_2 > neq_comm) < unwrap is_even n_even
);

require mul_is_two__both_one_or_two proves forany a,b: a : UINT  ->  b : UINT  ->  a * b == UINT_TWO  ->  (a == UINT_ONE && b == UINT_TWO) || (a == UINT_TWO && b == UINT_ONE)
by (
	forany a,b:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	
	assume ab_2 proves a * b == UINT_TWO;
	
	require ab_not_0 proves a * b != UINT_ZERO  by  two_is_not_zero > ((ab_2 > eq_comm) > bin_sub_left_eq) > bin_sub_left_impl;
	require ba_not_0 proves b * a != UINT_ZERO  by  ab_not_0 > ((mul_comm < auint < buint) > bin_sub_left_eq) > bin_sub_left_impl;
	
	require a_not_0 proves a != UINT_ZERO  by  mul_not_zero__left_not_zero < auint < buint < ab_not_0;
	require b_not_0 proves b != UINT_ZERO  by  mul_not_zero__left_not_zero < buint < auint < ba_not_0;
	
	require a_le_2 proves a <= UINT_TWO
	by  (mul_not_zero__left_le_mul < auint < buint < ab_not_0) > ab_2 > bin_sub_right_impl;
	
	require b_le_2 proves b <= UINT_TWO
	by  (mul_not_zero__left_le_mul < buint < auint < ba_not_0) > (ab_2 > (mul_comm < auint < buint) > bin_sub_left_impl) > bin_sub_right_impl;
	
	require a_is_succ proves  (forany q: (q : UINT -> (a == q++) -> FALSE)) -> FALSE
	by or__not_left__right < (uint_is_zero_or_succ < auint) < a_not_0;
	
	require b_is_succ proves  (forany w: (w : UINT -> (b == w++) -> FALSE)) -> FALSE
	by or__not_left__right < (uint_is_zero_or_succ < buint) < b_not_0;
	
	not_not_impl < (
		// Goal:
		// (((a == UINT_ONE && b == UINT_TWO) || (a == UINT_TWO && b == UINT_ONE)) -> FALSE) -> FALSE
		
		assume ttt proves ((a == UINT_ONE && b == UINT_TWO) || (a == UINT_TWO && b == UINT_ONE)) -> FALSE;
		
		// Goal: FALSE
		
		a_is_succ < (
			// Goal:
			// forany q: q : UINT -> (a == q++) -> FALSE
			
			forany q:
			assume quint proves q : UINT;
			assume a_sq proves a == q++;
			
			// Goal: FALSE
			
			b_is_succ < (
				// Goal:
				// forany w: w : UINT -> (b == w++) -> FALSE
				
				forany w:
				assume wuint proves w : UINT;
				assume b_sw proves b == w++;
				
				// Goal: FALSE
				
				ttt < (
					// Goal:
					// (a == UINT_ONE && b == UINT_TWO) || (a == UINT_TWO && b == UINT_ONE)
					
					require q_le_1 proves q <= UINT_ONE
					by succ_le_succ < quint < one_is_uint < ((a_le_2 > uint_two_eq_succ_one > bin_sub_right_impl) > a_sq > bin_sub_left_impl);
					
					require w_le_1 proves w <= UINT_ONE
					by succ_le_succ < wuint < one_is_uint < ((b_le_2 > uint_two_eq_succ_one > bin_sub_right_impl) > b_sw > bin_sub_left_impl);
					
					or_cases < (uint_le_one__zero_or_one < quint < q_le_1) < (
						assume q_0 proves q == UINT_ZERO;
						require a_s0 proves a == UINT_ZERO++  by  a_sq > (q_0 > un_sub_arg) > bin_sub_right_impl;
						require a_1 proves a == UINT_ONE  by  a_s0 > (uint_one_eq_succ_zero > eq_comm) > bin_sub_right_impl;
						
						require w_not_0 proves w != UINT_ZERO
						by (
							assume w_0 proves w == UINT_ZERO;
							
							require b_s0 proves b == UINT_ZERO++  by  b_sw > (w_0 > un_sub_arg) > bin_sub_right_impl;
							require b_1 proves b == UINT_ONE  by  b_s0 > (uint_one_eq_succ_zero > eq_comm) > bin_sub_right_impl;
														
							require ab_1 proves a * b == UINT_ONE
							by (((substitute a=a*b in eq_same) > (a_1 > bin_sub_left_eq) > bin_sub_right_impl) > (b_1 > bin_sub_right_eq) > bin_sub_right_impl) > (one_mul < one_is_uint) > bin_sub_right_impl;
							
							two_is_not_one < ((ab_2 > eq_comm) > ab_1 > bin_sub_right_impl)
						);
						
						require w_1 proves w == UINT_ONE
						by or__not_left__right < (uint_le_one__zero_or_one < wuint < w_le_1) < w_not_0;
						
						require b_2 proves b == UINT_TWO
						by ((w_1 > wrap_in_func_impl) > (b_sw > eq_comm) > bin_sub_left_impl) > (uint_two_eq_succ_one > eq_comm) > bin_sub_right_impl;
						
						or_left < (impl_impl_and < a_1 < b_2)
					) < (
						assume q_1 proves q == UINT_ONE;
						require a_s1 proves a == UINT_ONE++  by  a_sq > (q_1 > un_sub_arg) > bin_sub_right_impl;
						require a_2 proves a == UINT_TWO  by  a_s1 > (uint_two_eq_succ_one > eq_comm) > bin_sub_right_impl;
						
						require w_not_1 proves w != UINT_ONE
						by (
							assume w_1 proves w == UINT_ONE;
							
							require b_s1 proves b == UINT_ONE++  by  b_sw > (w_1 > un_sub_arg) > bin_sub_right_impl;
							
							require temp1 proves UINT_TWO * (UINT_ONE++) == UINT_TWO
							by (ab_2 > (a_2 > bin_sub_left_eq) > bin_sub_left_impl) > (b_s1 > bin_sub_right_eq) > bin_sub_left_impl;
							//require b_2 proves b == UINT_TWO  by  b_s1 > (uint_two_eq_succ_one > eq_comm) > bin_sub_right_impl;
							
							require temp2 proves UINT_TWO * UINT_ONE + UINT_TWO == UINT_TWO
							by temp1 > (mul_succ < two_is_uint < one_is_uint) > bin_sub_left_impl;
							
							require temp3 proves UINT_TWO * UINT_ONE == UINT_ZERO
							by temp2 > (add_left_eq_self < (uint_mul_uint_is_uint < two_is_uint < one_is_uint) < two_is_uint);
							
							(temp3 > (mul_one < two_is_uint) > bin_sub_left_impl) > two_is_not_zero
						);
						
						require w_0 proves w == UINT_ZERO
						by or__not_right__left < (uint_le_one__zero_or_one < wuint < w_le_1) < w_not_1;
						
						require b_1 proves b == UINT_ONE
						by ((w_0 > wrap_in_func_impl) > (b_sw > eq_comm) > bin_sub_left_impl) > (uint_one_eq_succ_zero > eq_comm) > bin_sub_right_impl;

						or_right < (impl_impl_and < a_2 < b_1)
					)
				)
			)
		)
	)
);



require two_is_prime proves is_prime UINT_TWO
by wrap is_prime (
	impl_impl_and < (impl_impl_and < two_is_uint < two_is_not_one) < (
		forany d:
		assume duint proves d : UINT;
		assume d_not_1 proves d != UINT_ONE;
		assume d_not_2 proves d != UINT_TWO;
		assume pd proves is_divisible_by UINT_TWO d;
		
		// Goal: FALSE
		
		(unwrap is_divisible_by pd > and_right) < (
			// Goal:
			// forany x: !((x : UINT) && x * d == UINT_TWO)
			forany x:
			assume ttt proves (x : UINT) && x * d == UINT_TWO;
			
			// Goal: FALSE
			
			or_cases < (mul_is_two__both_one_or_two < (ttt > and_left) < duint < (ttt > and_right)) < (
				assume temp proves x == UINT_ONE && d == UINT_TWO;
				(temp > and_right) > d_not_2
			) < (
				assume temp proves x == UINT_TWO && d == UINT_ONE;
				(temp > and_right) > d_not_1
			)
		)
	)
);















require uint_inductive_backwards proves forany F,a: a : UINT  ->  (forany b: b : UINT -> F b -> F (UINT_SATPRED b))  ->  F a  ->  (forany c: c : UINT  ->  c <= a  ->  F c)
by (
	forany F,a:
	assume auint proves a : UINT;
	assume ttt proves forany b: b : UINT -> F b -> F (UINT_SATPRED b);
	assume Fa proves F a;
	
	// Goal:
	// (forany c: c : UINT  ->  c <= a  ->  F c)
	
	forany c:
	assume cuint proves c : UINT;
	assume c_le_a proves c <= a;
	
	// Goal:
	// F c
	
	define Gunc x = F (a - x);
	
	require casezero proves Gunc UINT_ZERO
	by wrap Gunc (
		Fa > (((satsub_zero < auint) > un_sub_arg) > eq_rtl)
	);
	
	require casesucc proves forany x: x : UINT  ->  Gunc x  ->  Gunc (x++)
	by (
		forany x:
		assume xuint proves x : UINT;
		assume Gx proves Gunc x;
		require Gx_ proves F (a - x)  by unwrap Gunc Gx;
		
		require temp1 proves F (UINT_SATPRED (a - x))
		by ttt < (uint_satsub_uint_is_uint < auint < xuint) < Gx_;
		
		require temp2 proves F (a - x++)
		by temp1 > ((((satsub_succ__satpred_satsub < auint < xuint) > eq_comm) > un_sub_arg) > eq_ltr);
		
		wrap Gunc (
			// Goal:
			// F (a - x++)
			
			temp2
		)
	);
	
	require temppp proves forany x: x : UINT -> Gunc x
	by uint_inductive < casezero < casesucc;
	
	require temppp2 proves forany xx: xx : UINT -> F (a - xx)
	by (
		forany xx:
		assume xxuint proves xx : UINT;
		unwrap Gunc (temppp < xxuint)
	);
	
	// Goal:
	// F c
	
	or_cases < (a_le_b__a_eq_b__or__succ_a_le_b < cuint < auint < c_le_a) < (
		assume ca proves c == a;
		Fa > ((un_sub_arg < ca) > eq_rtl)
	) < (
		assume sc_le_a proves c++ <= a;
	
		// Goal:
		// F c
		
		// c++ <= a
		// F a
		
		not_not_impl < (
			// Goal:
			// ((F c) -> FALSE) -> FALSE
			
			assume yyy proves (F c) -> FALSE;
			
			// Goal: FALSE
			
			unwrap uint_le sc_le_a < (
				// Goal:
				// forany j: ((j : UINT) && (a == (c++ + j))) -> FALSE
				
				forany j:
				assume jjj proves (j : UINT) && (a == (c++ + j));
				require juint proves j : UINT  by  jjj > and_left;
				require a__sc_j proves a == c++ + j   by   jjj > and_right;
				
				// Goal: FALSE
				
				yyy < (
					// Goal:
					// F c
					
					// a = c++ + j
					// forany xx: xx : UINT  ->  F (a - xx)
					
					// a - xx
					// c++ + j - j++
					
					require temp3 proves F (a - j++)
					by temppp2 < (succ_uint_is_uint < juint);
					
					require temp4 proves F (c++ + j - j++)
					by temp3 > (((a__sc_j > bin_sub_left_eq) > un_sub_arg) > eq_ltr);
					
					require temp5 proves F (UINT_SATPRED (c++ + j - j))
					by temp4 > (((satsub_succ__satpred_satsub < (uint_add_uint_is_uint < (succ_uint_is_uint < cuint) < juint) < juint) > un_sub_arg) > eq_ltr);
					
					require temp6 proves F (UINT_SATPRED (c++))
					by temp5 > ((((add_satsub_same < (succ_uint_is_uint < cuint) < juint) > un_sub_arg) > un_sub_arg) > eq_ltr);
					
					temp6 > (((sat_pred_succ < cuint) > un_sub_arg) > eq_ltr)
				)
			)
		)
	)
);


require uint_strong_induction proves forany a,P: a : UINT  ->  (forany aa: aa : UINT -> (forany b: b : UINT -> b <= aa -> b != aa -> P b) -> P aa)  ->  P a
by (
	forany a,P:
	assume auint proves a : UINT;
	assume hypoth proves forany aa: aa : UINT -> (forany b: b : UINT -> b <= aa -> b != aa -> P b) -> P aa;
	
	// Goal:
	// P a
	
	define Q n = (forany m: m : UINT -> m <= n -> P m);
	
	require QQ proves forany n: n : UINT -> Q n
	by (
		require casezero proves Q UINT_ZERO
		by wrap Q (
			forany m:
			assume muint proves m : UINT;
			assume m_le_0 proves m <= UINT_ZERO;
			require m_0 proves m == UINT_ZERO
				by le_zero__is_zero < muint < m_le_0;
			
			// Goal:
			// P m
			
			hypoth < muint < (
				// Goal:
				// forany b: b : UINT  ->  b <= m  ->  b != m  ->  P b
				
				forany b:
				assume buint proves b : UINT;
				assume b_le_m proves b <= m;
				assume b_not_m proves b != m;
				((b_not_m > (m_0 > bin_sub_right_eq) > bin_sub_left_impl) < (le_zero__is_zero < buint < (b_le_m > m_0 > bin_sub_right_impl))) > false_proves_anything
			)
		);
		
		require casesucc proves forany nn: nn : UINT -> Q nn -> Q nn++
		by (
			forany nn:
			assume nnuint proves nn : UINT;
			assume hypoth2 proves Q nn;
			require hypoth2_ proves forany mm: mm : UINT -> mm <= nn -> P mm
			by unwrap Q hypoth2;
			wrap Q (
				// Goal:
				// forany m: m : UINT -> m <= nn++ -> P m
				
				forany m:
				assume muint proves m : UINT;
				assume m_le_snn proves m <= nn++;
				
				// Goal:
				// P m
				
				or_cases < (a_le_b__a_eq_b__or__succ_a_le_b < muint < (succ_uint_is_uint < nnuint) < m_le_snn) < (
					assume m_snn proves m == nn++;
					
					// Goal:
					// P m
					
					((un_sub_arg < (m_snn > eq_comm)) > eq_ltr) < (
						// Goal:
						// P nn++
						
						hypoth < (succ_uint_is_uint < nnuint) < (
							// Goal:
							// forany b: b : UINT -> b <= nn++ -> b != nn++ -> P b
							
							forany k:
							assume kuint proves k : UINT;
							assume k_le_snn proves k <= nn++;
							assume k_not_snn proves k != nn++;
							
							require sk_le_snn proves k++ <= nn++
								by a_not_b__a_le_b__succ_a_le_b < kuint < (succ_uint_is_uint < nnuint) < k_not_snn < k_le_snn;
							
							require k_le_nn	proves k <= nn
								by succ_le_succ < kuint < nnuint < sk_le_snn;
							
							// Goal:
							// P k
							
							hypoth2_ < kuint < k_le_nn
						)
					)
				) < (
					assume sm_le_snn proves m++ <= nn++;
					
					// Goal:
					// P m
					
					require s_le_nn proves m <= nn  by  succ_le_succ < muint < nnuint < sm_le_snn;
					
					hypoth2_ < muint < s_le_nn
				)
			)
		);
		
		uint_inductive < casezero < casesucc
	);
	
	unwrap Q (QQ < auint) < auint < (le_same < auint)
);



require not_prime_has_divisor proves forany a: a : UINT  ->  UINT_TWO <= a  ->  !(is_prime a)  ->  !(forany d: !(d != UINT_ONE && d != a && is_divisible_by a d))
by (
	forany a:
	assume auint proves a : UINT;
	assume 2_le_a proves UINT_TWO <= a;
	assume a_not_prime proves !(is_prime a);
	assume ttt proves forany d: !(d != UINT_ONE && d != a && is_divisible_by a d);
	
	// Goal:
	// FALSE
	
	require a_not_1 proves a != UINT_ONE
	by (
		assume a_1 proves a == UINT_ONE;
		unwrap uint_le 2_le_a < (
			// Goal:
			// forany c: (c : UINT) && (a == (UINT_TWO + c)) -> FALSE
			
			forany c:
			assume ccc proves (c : UINT) && (a == (UINT_TWO + c));
			
			require cuint proves c : UINT  by  ccc > and_left;
			
			// Goal: FALSE
			
			require temp1 proves a == (UINT_ONE + c)++
			by ((ccc > and_right) > (uint_two_eq_succ_one > bin_sub_left_eq) > bin_sub_right_impl) > (succ_add < one_is_uint < cuint) > bin_sub_right_impl;
			
			require temp2 proves UINT_ZERO == (UINT_ONE + c)
			by ((temp1 > a_1 > bin_sub_left_impl) > uint_one_eq_succ_zero > bin_sub_left_impl) > (succ_inj < zero_is_uint < (uint_add_uint_is_uint < one_is_uint < cuint));
			
			require temp3 proves UINT_ZERO == (UINT_ZERO + c)++
			by (temp2 > (uint_one_eq_succ_zero > bin_sub_left_eq) > bin_sub_right_impl) > (succ_add < zero_is_uint < cuint) > bin_sub_right_impl;
			
			succ_not_zero < (uint_add_uint_is_uint < zero_is_uint < cuint) < (temp3 > eq_comm)
		)
	);
	
	a_not_prime < wrap is_prime (
		// Goal:
		// forany d: (a : UINT) && a != UINT_ONE && (d : UINT  ->  d != UINT_ONE  ->  d != a  ->  !(is_divisible_by a d))
		
		forany d:
		impl_impl_and < (impl_impl_and < auint < a_not_1) < (
			// Goal:
			// d : UINT  ->  d != UINT_ONE  ->  d != a  ->  !(is_divisible_by a d)
			
			assume duint proves d : UINT;
			assume d_not_1 proves d != UINT_ONE;
			assume d_not_a proves d != a;
			assume a_divisible_d proves is_divisible_by a d;
			
			// Goal: FALSE
			
			(unwrap is_divisible_by a_divisible_d > and_right) < (
				// Goal:
				// forany x: !((x : UINT) && x * d == a)
				
				forany x:
				assume xxx proves (x : UINT) && x * d == a;
				
				// Goal: FALSE
				
				ttt < (
					// Goal:
					// forSOME d:  d != UINT_ONE   &&   d != a   &&   is_divisible_by a d
					
					impl_impl_and < (impl_impl_and < d_not_1 < d_not_a) < a_divisible_d
				)
			)
		)
	)
);



require 2_le__has_prime_divisor proves forany a: a : UINT  ->  UINT_TWO <= a  ->  (!(forany p: !(is_prime p && is_divisible_by a p)))
by (
	forany a:
	assume auint proves a : UINT;
	
	define Func aaa = UINT_TWO <= aaa  ->  (!(forany p: !(is_prime p && is_divisible_by aaa p)));
	
	require strong_inductor proves forany aa: aa : UINT -> (forany b: b : UINT -> b <= aa -> b != aa -> Func b) -> Func aa
	by (
		forany aa:
		assume aauint proves aa : UINT;
		assume ttt proves forany b: b : UINT  ->  b <= aa  ->  b != aa  ->  Func b;
		
		// Goal:
		// Func aa
		
		wrap Func (
			assume 2_le_aa proves UINT_TWO <= aa;
			
			require aa_not_0 proves aa != UINT_ZERO
			by succ_le_not_zero < one_is_uint < aauint < (2_le_aa > uint_two_eq_succ_one > bin_sub_left_impl);
			
			assume ppp proves forany p: !(is_prime p && is_divisible_by aa p);
			
			// Goal: FALSE
			
			or_cases < yay_or_nay < (
				assume aa_prime proves is_prime aa;
				ppp < (
					// Goal:
					// forSOME p: is_prime p && is_divisible_by aa p
					
					impl_impl_and < aa_prime < (divisible_by_self < aauint)
				)
			) < (
				assume aa_not_prime proves !(is_prime aa);
				
				require aa_has_divisor proves !(forany d: !(d != UINT_ONE && d != aa && is_divisible_by aa d))
				by not_prime_has_divisor < aauint < 2_le_aa < aa_not_prime;
				
				aa_has_divisor < (
					// Goal:
					// forany d: !(d != UINT_ONE && d != aa && is_divisible_by aa d)
					
					forany d:
					assume ddd proves d != UINT_ONE && d != aa && is_divisible_by aa d;
					
					// Goal: FALSE
					
					require aa_d proves is_divisible_by aa d   by ddd > and_right;
					require duint proves d : UINT   by (unwrap is_divisible_by aa_d > and_left) > and_right;
					require d_not_1 proves d != UINT_ONE   by (ddd > and_left) > and_left;
					require d_not_aa proves d != aa    by  (ddd > and_left) > and_right;
					require d_not_0 proves d != UINT_ZERO  by divisor_not_zero < aa_not_0 < aa_d;
					require 2_le_d proves UINT_TWO <= d  by  not_zero_not_one__2_le < duint < d_not_0 < d_not_1;
					
					require Fd proves Func d
					by ttt < duint < (divisor_is_le < aa_not_0 < aa_d) < d_not_aa;
					
					require Fd_ proves UINT_TWO <= d  ->  (!(forany qq: !(is_prime qq && is_divisible_by d qq)))
					by unwrap Func Fd;
					
					Fd_ < 2_le_d < (
						// Goal:
						// forany qq: !(is_prime qq && is_divisible_by d qq)
						
						forany qq:
						assume qqq proves is_prime qq && is_divisible_by d qq;
						
						// Goal: FALSE
						
						ppp < (
							// Goal:
							// forSOME p: is_prime p && is_divisible_by aa p
							
							// is_divisible_by aa d
							// is_divisible_by d qq
							// is_prime qq
							
							require aa_qq proves is_divisible_by aa qq   by divisible_trans < aa_d < (qqq > and_right);
							
							impl_impl_and < (qqq > and_left) < aa_qq
						)
					)
				)
			)
		)
	);
	
	require Fa proves Func a
	by uint_strong_induction < auint < strong_inductor;
	
	unwrap Func Fa
);

require 2_le_not_0 proves forany a: a : UINT  ->  UINT_TWO <= a  ->  a != UINT_ZERO
by (
	forany a:
	assume auint proves a : UINT;
	assume 2_le_a proves UINT_TWO <= a;
	assume a_0 proves a == UINT_ZERO;
	two_is_not_zero < (le_zero__is_zero < two_is_uint < (2_le_a > a_0 > bin_sub_right_impl))
);

require not_prime_has_prime_divisor proves forany a: a : UINT  ->  UINT_TWO <= a  ->  !(is_prime a)  ->  !(forany p: !(is_prime p && is_divisible_by a p))
by (
	forany a:
	assume auint proves a : UINT;
	assume 2_le_a proves UINT_TWO <= a;
	assume a_not_prime proves !(is_prime a);
	
	require a_has_divisor proves !(forany d: !(d != UINT_ONE && d != a && is_divisible_by a d))
	by not_prime_has_divisor < auint < 2_le_a < a_not_prime;
	
	assume ttt proves forany p: !(is_prime p && is_divisible_by a p);
	
	// Goal: FALSE
	
	a_has_divisor < (
		// Goal:
		// forany d: !(d != UINT_ONE && d != a && is_divisible_by a d)
		
		forany d:
		assume ddd proves d != UINT_ONE  &&  d != a  &&  is_divisible_by a d;
		
		require duint proves d : UINT  by  (unwrap is_divisible_by (ddd > and_right) > and_left) > and_right;
		require a_not_0 proves a != UINT_ZERO by 2_le_not_0 < auint < 2_le_a;
		require d_not_1 proves d != UINT_ONE   by (ddd > and_left) > and_left;
		require d_not_0 proves d != UINT_ZERO  by  divisor_not_zero < a_not_0 < (ddd > and_right);
		require 2_le_d proves UINT_TWO <= d  by  not_zero_not_one__2_le < duint < d_not_0 < d_not_1;
		
		// Goal: FALSE
		
		(2_le__has_prime_divisor < duint < 2_le_d) < (
			// Goal:
			// forany pp: !(is_prime pp && is_divisible_by d pp)
			
			forany pp:
			assume ppp proves is_prime pp && is_divisible_by d pp;
			
			// Goal: FALSE
			
			ttt < (
				// Goal:
				// forSOME p: is_prime p && is_divisible_by a p
				
				impl_impl_and < (ppp > and_left) < (divisible_trans < (ddd > and_right) < (ppp > and_right))
			)
		)
	)
);


//define is_prime p = forany d: (p : UINT) && p != UINT_ONE && (d : UINT  ->  d != UINT_ONE  ->  d != p  ->  !(is_divisible_by p d));


// define is_divisible_by n o = (n : UINT) && (o : UINT) && !(forany x: !((x : UINT) && x * o == n));

//define smallest_prime_factor n = 

//require uint_strong_induction proves forany a,P: a : UINT  ->  (forany aa: aa : UINT -> (forany b: b : UINT -> b <= aa -> b != aa -> P b) -> P aa)  ->  P a
//require not_prime_has_divisor proves forany a: a : UINT  ->  UINT_TWO <= a  ->  !(is_prime a)  ->  !(forany d: !(d != UINT_ONE && d != a && is_divisible_by a d))




require mul_range_same proves forany a: MUL_RANGE a a == a
by (
	forany a:
	defeq2 MUL_RANGE.x
);

require mul_range_other proves forany a,b: a <= b  ->  a != b  ->  MUL_RANGE a b == a * MUL_RANGE a++ b
by (
	forany a,b:
	assume a_le_b proves a <= b;
	assume a_neq_b proves a != b;
	(defeq2 MUL_RANGE.xx) < (impl_impl_and < a_le_b < a_neq_b)
);

require mul_succ_same__mul_range proves forany a,b: a : UINT  ->  b : UINT  ->  a++ == b  ->  a * b == MUL_RANGE a b
by (
	forany a,b:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	assume sa_b proves a++ == b;
	
	require temp1 proves a * b == a * b
	by eq_same;
	
	require temp2 proves a * b == a * MUL_RANGE b b
	by temp1 > ((mul_range_same > eq_comm) > bin_sub_right_eq) > bin_sub_right_impl;
	
	require temp3 proves a * b == a * MUL_RANGE a++ b
	by temp2 > (((sa_b > eq_comm) > bin_sub_left_eq) > bin_sub_right_eq) > bin_sub_right_impl;
	
	require a_le_b proves a <= b by (le_succ_self < auint) > sa_b > bin_sub_right_impl;
	require a_neq_b proves a != b by (uint_neq_succ_self < auint) > (sa_b > bin_sub_right_eq) > bin_sub_left_impl;
	
	require temp4 proves a * b == MUL_RANGE a b
	by temp3 > ((mul_range_other < a_le_b < a_neq_b) > eq_comm) > bin_sub_right_impl;
	
	temp4
);

// TODO remove (duplicate of mul_range_other)
require mul__mul_range proves forany before_first,last:   before_first : UINT  ->  last : UINT  ->  before_first <= last  ->  before_first != last  ->  (MUL_RANGE before_first last) == (before_first * MUL_RANGE before_first++ last)
by (
	forany before_first,last:
	assume before_firstuint proves before_first : UINT;
	assume lastuint proves last : UINT;
	assume bf_le_l proves before_first <= last;
	assume bf_neq_l proves before_first != last;
	
	mul_range_other < bf_le_l < bf_neq_l
);

require asdfkhasdjkhf proves forany a,b: a : UINT  ->  b : UINT ->  b++ <= a  ->  (a - b++)++  ==  a - b
by (
	forany a,b:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	assume sb_le_a proves b++ <= a;
	
	require temp1 proves (a - b++)++ == (a - b++)++   by eq_same;
	require temp2 proves (a - b++)++ == (a++ - b++)   by temp1 > ((succ_satsub < auint < (succ_uint_is_uint < buint) < sb_le_a) > eq_comm) > bin_sub_right_impl;
	
	temp2 > (succ_satsub_succ < auint < buint) > bin_sub_right_impl
);

require add_satsub_same_2 proves forany a,b: a : UINT  ->  b : UINT  ->  a <= b  ->  a + (b - a) == b
by (
	forany a,b:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	assume a_le_b proves a <= b;
	
	define Func aa = aa <= b  ->  aa + (b - aa) == b;
	
	require casezero proves Func UINT_ZERO
	by wrap Func (
		assume _ proves UINT_ZERO <= b;
		
		// Goal:
		// UINT_ZERO + (b - UINT_ZERO) == b
		
		(eq_same > ((satsub_zero < buint) > eq_comm) > bin_sub_left_impl) > ((zero_add < (uint_satsub_uint_is_uint < buint < zero_is_uint)) > eq_comm) > bin_sub_left_impl
	);
	
	require casesucc proves forany aa: aa : UINT  ->  Func aa  ->  Func aa++
	by (
		forany aa:
		assume aauint proves aa : UINT;
		assume F_aa proves Func aa;
		wrap Func (
			// Goal:
			// aa++ <= b  ->  aa++ + (b - aa++) == b;
			
			assume saa_le_b proves aa++ <= b;
			
			// aa + (b - aa) == b
			// aa + (b - aa++)++ == b
			// aa++ + (b - aa++) == b
			
			require temp1 proves aa + (b - aa) == b
			by (unwrap Func F_aa < (succ_le < aauint < buint < saa_le_b));
			
			require temp2 proves aa + (b - aa++)++ == b
			by temp1 > (((asdfkhasdjkhf < buint < aauint < saa_le_b) > eq_comm) > bin_sub_right_eq) > bin_sub_left_impl;
			
			require temp3 proves aa++ + (b - aa++) == b
			by temp2 > ((succ_add__add_succ < aauint < (uint_satsub_uint_is_uint < buint < (succ_uint_is_uint < aauint))) > eq_comm) > bin_sub_left_impl;
			
			temp3
		)
	);
	
	unwrap Func (uint_inductive < casezero < casesucc < auint) < a_le_b
);

require satsub_eq_lhs proves forany a,b: a : UINT  ->  b : UINT  ->  a != UINT_ZERO  ->  (a - b) == a  ->  b == UINT_ZERO
by (
	forany a,b:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	assume a_not_0 proves a != UINT_ZERO;
	assume ab_a proves a - b == a;
	
	or_cases < yay_or_nay < (
		assume b_le_a proves b <= a;
		
		// (a - b) == a
		// b + (a - b) == b + a
		// a == b + a
		// b == 0
		
		require temp1 proves b + (a - b) == b + a
		by ab_a > wrap_in_bin_func_rhs;
		
		require temp2 proves a == b + a
		by temp1 > (add_satsub_same_2 < buint < auint < b_le_a) > bin_sub_left_impl;
		
		require temp3 proves b == UINT_ZERO
		by add_left_eq_self < buint < auint < (temp2 > eq_comm);
		
		temp3
	) < (
		assume not_b_le_a proves !(b <= a);
		require a_le_b proves a <= b
		by (not_le__neq_and_le < buint < auint < not_b_le_a) > and_right;
		
		// (a - b) == a
		
		require temp1 proves UINT_ZERO == a
		by ab_a > (satsub_saturates < auint < buint < a_le_b) > bin_sub_left_impl;
		
		(a_not_0 < (temp1 > eq_comm)) > false_proves_anything
	)
);


require le_same_add proves forany a,b: a : UINT -> b : UINT -> a <= (a + b)
by (
	forany a,b:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	wrap uint_le (
		assume ccc proves forany c: ((c : UINT) && ((a + b) == (a + c))) -> FALSE;
		ccc < (
			impl_impl_and < buint < eq_same
		)
	)
);

require mul_range_is_uint proves forany first,last: first : UINT  ->  last : UINT  ->  first <= last  ->  (MUL_RANGE first last) : UINT
by (
	forany first,last:
	assume firstuint proves first : UINT;
	assume lastuint proves last : UINT;
	assume first_le_last proves first <= last;
	
	define Func y = y <= last  ->  (MUL_RANGE (last-y) last) : UINT;
	
	require casezero proves Func UINT_ZERO
	by wrap Func (
		assume _ proves UINT_ZERO <= last;
		
		require ttt proves (MUL_RANGE last last) : UINT
		by lastuint > ((substitute a=last in mul_range_same) > eq_comm) > bin_sub_right_impl;
		
		ttt > (((satsub_zero < lastuint) > eq_comm) > bin_sub_left_eq) > bin_sub_right_impl
		
		// Goal:
		// (MUL_RANGE (last - UINT_ZERO) last) : UINT
		// (MUL_RANGE last last) : UINT
		// last : UINT
	);
	
	
	require casesucc proves forany y: y : UINT -> Func y -> Func (y++)
	by (
		forany y:
		assume yuint proves y : UINT;
		assume hypoth proves Func y;
		
		require hypoth_ proves y <= last  ->  (MUL_RANGE (last - y) last) : UINT
		by unwrap Func hypoth;
		
		// We have:  y <= last  ->  
		// (MUL_RANGE (last - y) last) : UINT
		// (last-y) * (MUL_RANGE (last-y)++ last) : UINT
		
		
		wrap Func (
			assume bla proves y++ <= last;
			
			require last_not_0 proves last != UINT_ZERO
			by succ_le_not_zero < yuint < lastuint < bla;
			
			require hypoth__ proves (MUL_RANGE (last - y) last) : UINT
			by hypoth_ < (succ_le < yuint < lastuint < bla);
			
			// Goal:
			// (MUL_RANGE (last - y++) last) : UINT
			//    mul__mul_range
			// (last - y++) * (MUL_RANGE (last - y++)++ last) : UINT
			//    asdfkhasdjkhf  NEEDS  y++ <= last
			// (last - y++) * (MUL_RANGE (last - y) last) : UINT
			
			require temp1 proves (last - y++) * (MUL_RANGE (last - y) last) : UINT
			by uint_mul_uint_is_uint < (uint_satsub_uint_is_uint < lastuint < (succ_uint_is_uint < yuint)) < hypoth__;
			
			require temp2 proves (last - y++) * (MUL_RANGE (last - y++)++ last) : UINT
			by temp1 > ((((asdfkhasdjkhf < lastuint < yuint < bla) > eq_comm) > bin_sub_left_eq) > bin_sub_right_eq) > bin_sub_right_impl;
			
			require ggg proves (last - y++) != last
			by nonzero_satsub_notzero__neq < lastuint < (succ_uint_is_uint < yuint) < last_not_0 < (succ_not_zero < yuint);
			
			require hhh proves (last - y++) <= last
			by satsub_le_left < lastuint < (succ_uint_is_uint < yuint);
			
			require temp3 proves (MUL_RANGE (last - y++) last) : UINT
			by temp2 > ((mul__mul_range < (uint_satsub_uint_is_uint < lastuint < (succ_uint_is_uint < yuint)) < lastuint < hhh < ggg) > eq_comm) > bin_sub_right_impl;
			
			temp3
		)
	);
	
	require temppp proves (MUL_RANGE (last - (last - first)) last) : UINT
	by unwrap Func (uint_inductive < casezero < casesucc < (uint_satsub_uint_is_uint < lastuint < firstuint)) < (satsub_le_left < lastuint < firstuint);
	
	temppp > ((satsub__same_satsub < lastuint < firstuint < first_le_last) > bin_sub_left_eq) > bin_sub_right_impl
);

require le_self_add proves forany a,b:  a : UINT  ->  b : UINT  ->  a <= a + b
by (
	forany a,b:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	
	define Func aa = aa <= aa + b;
	
	require casezero proves Func UINT_ZERO
	by wrap Func (
		(zero_le < buint) > ((zero_add < buint) > eq_comm) > bin_sub_right_impl
	);
	
	require casesucc proves forany aa: aa : UINT -> Func aa -> Func aa++
	by (
		forany aa:
		assume aauint proves aa : UINT;
		assume hypoth proves Func aa;
		require hypoth_ proves aa <= aa + b
		by unwrap Func hypoth;
		wrap Func (
			// Goal:
			// aa++ <= aa++ + b
			
			require temp1 proves aa++ <= (aa + b)++
			by succ_le_succ_reverse < aauint < (uint_add_uint_is_uint < aauint < buint) < hypoth_;
			
			temp1 > ((succ_add < aauint < buint) > eq_comm) > bin_sub_right_impl
		)
	);
	
	unwrap Func (uint_inductive < casezero < casesucc < auint)
);

require mul_range__mul proves forany first,last:   first : UINT  ->  last : UINT  ->  first <= last  ->  (MUL_RANGE first last++) == ((MUL_RANGE first last) * last++)
by (
	forany f,l:
	assume fuint proves f : UINT;
	assume luint proves l : UINT;
	assume f_le_l proves f <= l;
	
	define Func y = forany first:  first : UINT -> (MUL_RANGE first (first+y)++) == ((MUL_RANGE first (first+y)) * (first+y)++);
	
	require casezero proves Func UINT_ZERO
	by wrap Func (
		forany first2:
		assume first2uint proves first2 : UINT;
		
		// Goal:
		// (MUL_RANGE first (first + 0)++) == ((MUL_RANGE first (first + 0)) * (first + 0)++)
		
		require temp0 proves first2++ == (first2 + UINT_ZERO)++
		by eq_same > (((add_zero < first2uint) > eq_comm) > un_sub_arg) > bin_sub_right_impl;
				
		require temp1a proves first2 * (first2 + UINT_ZERO)++ == MUL_RANGE first2 (first2 + UINT_ZERO)++
		by mul_succ_same__mul_range < first2uint < (succ_uint_is_uint < (uint_add_uint_is_uint < first2uint < zero_is_uint)) < temp0;
		
		require temp1b proves first2 == (MUL_RANGE first2 (first2 + UINT_ZERO))
		by (mul_range_same > eq_comm) > (((add_zero < first2uint) > eq_comm) > bin_sub_right_eq) > bin_sub_right_impl;
		
		(temp1a > (temp1b > bin_sub_left_eq) > bin_sub_left_impl) > eq_comm
	);
	
	require casesucc proves forany y: y : UINT  ->  Func y  ->  Func y++
	by (
		forany y:
		assume yuint proves y : UINT;
		assume hypoth proves Func y;
		
		require hypoth_ proves forany first:    first : UINT -> (MUL_RANGE first (first+y)++) == ((MUL_RANGE first (first+y)) * (first+y)++)
		by unwrap Func hypoth;
		
		wrap Func (
			// Goal:
			// forany first2:     (MUL_RANGE first2 (first2 + y++)++) == ((MUL_RANGE first2 (first2 + y++)) * (first2 + y++)++)
			
			forany first2:
			assume first2uint proves first2 : UINT;
			
			require temp1 proves (MUL_RANGE first2 (first2+y++)++) == (MUL_RANGE first2 (first2+y++)++)
			by eq_same;
			
			require temp2 proves (MUL_RANGE first2 (first2++ + y)++) == (MUL_RANGE first2 (first2+y++)++)
			by temp1 > ((((succ_add__add_succ < first2uint < yuint) > eq_comm) > un_sub_arg) > bin_sub_right_eq) > bin_sub_left_impl;
			
			require aaa0 proves (first2++ + y) : UINT
			by uint_add_uint_is_uint < (succ_uint_is_uint < first2uint) < yuint;
			
			require aaa1 proves (first2++ + y)++ : UINT
			by succ_uint_is_uint < aaa0;
			
			require aaa2 proves first2 != (first2++ + y)++
			by (
				assume ttt1 proves first2 == (first2++ + y)++;
				require ttt2 proves first2 == (first2 + y++)++
				by ttt1 > ((succ_add__add_succ < first2uint < yuint) > un_sub_arg) > bin_sub_right_impl;
				require ttt3 proves first2 == (first2 + y++++)
				by ttt2 > ((add_succ < first2uint < (succ_uint_is_uint < yuint)) > eq_comm) > bin_sub_right_impl;
				require ttt4 proves y++++ == UINT_ZERO
				by add_right_eq_self < first2uint < (succ_uint_is_uint < (succ_uint_is_uint < yuint)) < (ttt3 > eq_comm);
				(succ_not_zero < (succ_uint_is_uint < yuint)) < ttt4
			);
			
			require aaa44 proves first2 <= (first2++ + y)
			by (
				bin_sub_right_impl < ((succ_add < first2uint < yuint) > eq_comm) < (
					// Goal:
					// first2 <= (first2 + y)++
					le_to_le_succ < first2uint < (uint_add_uint_is_uint < first2uint < yuint) < (
						// Goal:
						// first2 <= first2 + y
						le_self_add < first2uint < yuint
					)
				)
			);
			
			require aaa33 proves first2 <= (first2++ + y)++
			by le_to_le_succ < first2uint < (uint_add_uint_is_uint < (succ_uint_is_uint < first2uint) < yuint) < (
				// Goal:
				// first2 <= (first2++ + y)
				aaa44
			);
			
			require temp3 proves first2 * (MUL_RANGE first2++ (first2++ + y)++) == (MUL_RANGE first2 (first2+y++)++)
			by temp2 > (mul__mul_range < first2uint < aaa1 < aaa33 < aaa2) > bin_sub_left_impl;
			
			require temp4 proves first2 * ((MUL_RANGE first2++ (first2++ + y)) * (first2++ + y)++) == (MUL_RANGE first2 (first2+y++)++)
			by temp3 > ((hypoth_ < (succ_uint_is_uint < first2uint)) > bin_sub_right_eq) > bin_sub_left_impl;
			
			require aaa3 proves (MUL_RANGE first2++ (first2++ + y)) : UINT
			by mul_range_is_uint < (succ_uint_is_uint < first2uint) < aaa0 < (le_same_add < (succ_uint_is_uint < first2uint) < yuint);
			
			require temp5 proves first2 * (MUL_RANGE first2++ (first2++ + y)) * (first2++ + y)++  == (MUL_RANGE first2 (first2+y++)++)
			by temp4 > ((mul_assoc < first2uint < aaa3 < aaa1) > eq_comm) > bin_sub_left_impl;
			
			require aaa4 proves first2 != (first2++ + y)
			by (
				assume ttt1 proves first2 == (first2++ + y);
				require ttt2 proves first2 == (first2 + y++)
				by ttt1 > (succ_add__add_succ < first2uint < yuint) > bin_sub_right_impl;
				require ttt3 proves y++ == UINT_ZERO
				by add_right_eq_self < first2uint < (succ_uint_is_uint < yuint) < (ttt2 > eq_comm);
				(succ_not_zero < yuint) < ttt3
			);
			
			require temp6 proves (MUL_RANGE first2 (first2++ + y)) * (first2++ + y)++  == (MUL_RANGE first2 (first2+y++)++)
			by temp5 > (((mul__mul_range < first2uint < aaa0 < aaa44 < aaa4) > eq_comm) > bin_sub_left_eq) > bin_sub_left_impl;
			
			require temp7 proves (MUL_RANGE first2 (first2 + y++)) * (first2++ + y)++  ==  (MUL_RANGE first2 (first2+y++)++)
			by temp6 > (((succ_add__add_succ < first2uint < yuint) > bin_sub_right_eq) > bin_sub_left_eq) > bin_sub_left_impl;
			
			require temp8 proves (MUL_RANGE first2 (first2 + y++)) * (first2 + y++)++  ==  (MUL_RANGE first2 (first2 + y++)++)
			by temp7 > (((succ_add__add_succ < first2uint < yuint) > un_sub_arg) > bin_sub_right_eq) > bin_sub_left_impl;
			
			// (MUL_RANGE first2 (first2 + y++)++)
			//   use succ_add__add_succ
			// (MUL_RANGE first2 (first2++ + y)++)
			//   use mul__mul_range
			// first2 * (MUL_RANGE first2++ (first2++ + y)++)
			//   use hypoth_ with first = first2++
			// first2 * ((MUL_RANGE first2++ (first2++ + y)) * (first2++ + y)++)
			//   use mul_assoc
			// first2 * (MUL_RANGE first2++ (first2++ + y)) * (first2++ + y)++
			//   use mul__mul_range
			// (MUL_RANGE first2 (first2++ + y)) * (first2++ + y)++
			//   use succ_add__add_succ twice
			// (MUL_RANGE first2 (first2 + y++)) * (first2 + y++)++
			
			temp8 > eq_comm
		)
	);
	
	require q proves Func (l - f)
	by uint_inductive < casezero < casesucc < (uint_satsub_uint_is_uint < luint < fuint);
	
	require q2 proves (MUL_RANGE f (f+(l-f))++) == ((MUL_RANGE f (f+(l-f))) * (f+(l-f))++)
	by unwrap Func q < fuint;
	
	
	
	require yoyo proves f + (l - f) == l
	by add_satsub_same_2 < fuint < luint < f_le_l;
	
	//require yoyo proves f + l - f == l
	//by (eq_same > ((add_satsub_same < luint < fuint) > eq_comm) > bin_sub_left_impl) > ((add_comm < luint < fuint) > bin_sub_left_eq) > bin_sub_left_impl;
	
	// Goal:
	// (MUL_RANGE f l++) == ((MUL_RANGE f l) * l++)
	
	((q2 > ((yoyo > un_sub_arg) > bin_sub_right_eq) > bin_sub_left_impl)
	> ((yoyo > bin_sub_right_eq) > bin_sub_left_eq) > bin_sub_right_impl)
	> ((yoyo > un_sub_arg) > bin_sub_right_eq) > bin_sub_right_impl
);

require mul_range_from_0__eq_zero proves forany last: last : UINT  ->  MUL_RANGE UINT_ZERO last == UINT_ZERO
by (
	forany last:
	assume luint proves last : UINT;
	or_cases < yay_or_nay < (
		assume last_0 proves last == UINT_ZERO;
		
		mul_range_same > ((last_0 > eq_comm) > bin_sub_right_eq) > bin_sub_left_impl
	) < (
		assume last_not_0 proves last != UINT_ZERO;
		require 1_le_last proves UINT_ONE <= last
		by not_zero__one_le < luint < last_not_0;
		require s0_le_last proves UINT_ZERO++ <= last
		by 1_le_last > uint_one_eq_succ_zero > bin_sub_left_impl;
		
		(mul__mul_range < zero_is_uint < luint < (zero_le < luint) < (last_not_0 > neq_comm)) > (zero_mul < (mul_range_is_uint < (succ_uint_is_uint < zero_is_uint) < luint < s0_le_last)) > bin_sub_right_impl
	)
);

require add_le_left proves forany a,b,c: a : UINT -> b : UINT -> c : UINT -> (a + b) <= c -> a <= c
by (
	forany a,b,c:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	assume cuint proves c : UINT;
	assume ab_le_c proves a + b <= c;
	wrap uint_le (
		assume ttt proves forany d: (AND (d : UINT) (c == (a + d))) -> FALSE;
		
		// Goal: FALSE
		
		unwrap uint_le ab_le_c < (
			// Goal:
			// forany e: (AND (e : UINT) (c == ((a + b) + e))) -> FALSE;
			
			forany e:
			assume eee proves AND (e : UINT) (c == ((a + b) + e));
			
			ttt < (
				// Goal:
				// forSOME d: (d : UINT) && (c == (a + d))
				
				impl_impl_and < (uint_add_uint_is_uint < buint < (eee > and_left)) < ((eee > and_right) > (add_assoc < auint < buint < (eee > and_left)) > bin_sub_right_impl)
			)
		)
	)
);

require succ_le__neq proves forany a,b: a : UINT -> b : UINT -> a++ <= b  ->  a != b
by (
	forany a,b:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	
	assume sa_le_b proves a++ <= b;
	assume a_b proves a == b;
	unwrap uint_le sa_le_b < (
		// Goal:
		// forany e: (AND (e : UINT) (b == (a++ + e))) -> FALSE;
		
		forany e:
		assume eee proves (e : UINT) && (b == (a++ + e));
		
		// Goal: FALSE
		
		require temp1 proves a == a++ + e
		by (eee > and_right) > (a_b > eq_comm) > bin_sub_left_impl;
		
		require temp2 proves a == a + e++
		by temp1 > (succ_add__add_succ < auint < (eee > and_left)) > bin_sub_right_impl;
		
		require temp3 proves e++ == UINT_ZERO
		by add_right_eq_self < auint < (succ_uint_is_uint < (eee > and_left)) < (temp2 > eq_comm);
		
		(succ_not_zero < (eee > and_left)) < temp3
	)
);

require mul_range_divisible_by_number_in_range proves forany q,r,s: q : UINT  ->  r : UINT  ->  s : UINT  ->  q <= s  ->  s <= r  ->  is_divisible_by (MUL_RANGE q r) s
by (
	forany q,r,s:
	assume quint proves q : UINT;
	assume ruint proves r : UINT;
	assume suint proves s : UINT;
	assume q_le_s proves q <= s;
	assume s_le_r proves s <= r;
	
	define Func dq = forany qq,rr: qq : UINT  ->  rr : UINT  ->  (qq <= qq+dq)  ->  (qq+dq <= rr)  ->  is_divisible_by (MUL_RANGE qq rr) (qq+dq);
	
	require casezero proves Func UINT_ZERO
	by wrap Func (
		// Goal:
		// forany qq,rr: qq : UINT  ->  rr : UINT  ->  (qq <= qq + 0)  ->  (qq + 0 <= rr)  ->  is_divisible_by (MUL_RANGE qq rr) (qq + 0);
		
		forany qq,rr:
		assume qquint proves qq : UINT;
		assume rruint proves rr : UINT;
		
		assume _ proves qq <= qq + UINT_ZERO;
		assume q0_le_r proves qq + UINT_ZERO <= rr;
		
		// Goal:
		// is_divisible_by (MUL_RANGE qq rr) (qq + 0)
		
		or_cases < yay_or_nay < (
			assume qq_rr proves qq == rr;
			
			require temp1 proves is_divisible_by (MUL_RANGE qq qq) qq
			by (divisible_by_self < qquint) > (mul_range_same > eq_comm) > bin_sub_left_impl;
			
			(temp1 > (bin_sub_right_eq < qq_rr) > bin_sub_left_impl) > ((add_zero < qquint) > eq_comm) > bin_sub_right_impl
		) < (
			assume qq_neq_rr proves qq != rr;
			
			// divisible__multiple_also_divisible is_divisible_by n o  ->  is_divisible_by (n*p) o
			
			require sqq_le_rr proves qq++ <= rr
			by a_not_b__a_le_b__succ_a_le_b < qquint < rruint < qq_neq_rr < (q0_le_r > (add_zero < qquint) > bin_sub_left_impl);
			
			require qq_le_rr proves qq <= rr
			by succ_le < qquint < rruint < sqq_le_rr;
			
			// is_divisible_by qq qq
			// is_divisible_by (qq * (MUL_RANGE qq++ rr)) qq
			// is_divisible_by (MUL_RANGE qq rr) qq
			// is_divisible_by (MUL_RANGE qq rr) (qq + 0)
			
			require temp1 proves is_divisible_by (qq * MUL_RANGE qq++ rr) qq
			by divisible__multiple_also_divisible < (mul_range_is_uint < (succ_uint_is_uint < qquint) < rruint < sqq_le_rr) < (divisible_by_self < qquint);
			
			require temp2 proves is_divisible_by (MUL_RANGE qq rr) qq
			by temp1 > ((mul__mul_range < qquint < rruint < qq_le_rr < qq_neq_rr) > eq_comm) > bin_sub_left_impl;
			
			temp2 > ((add_zero < qquint) > eq_comm) > bin_sub_right_impl
		)
	);
	
	require casesucc proves forany dq: dq : UINT  ->  Func dq  ->  Func (dq++)
	by (
		forany dq:
		assume dquint proves dq : UINT;
		assume hypoth proves Func dq;
		require hypoth_ proves forany qq,rr: qq : UINT  ->  rr : UINT  ->  (qq <= qq+dq)  ->  (qq+dq <= rr)  ->  is_divisible_by (MUL_RANGE qq rr) (qq+dq)
		by unwrap Func hypoth;
		wrap Func (
			forany qq,rr:
			assume qquint proves qq : UINT;
			assume rruint proves rr : UINT;
			
			// Goal:
			// (qq <= qq + dq++)  ->  (qq + dq++ <= rr)  ->  is_divisible_by (MUL_RANGE qq rr) (qq + dq++);
			
			assume q_le_q_sdq proves qq <= qq + dq++;
			assume q_sdq_le_r proves qq + dq++ <= rr;
			
			// Goal:
			// is_divisible_by (MUL_RANGE qq rr) (qq + dq++)
			
			// a != b  ->  (MUL_RANGE a b) == (a * MUL_RANGE a++ b)
			
			require temp1 proves is_divisible_by (MUL_RANGE (qq++) rr) (qq++ + dq)
			by hypoth_ < (succ_uint_is_uint < qquint) < rruint < (le_same_add < (succ_uint_is_uint < qquint) < dquint) < (q_sdq_le_r > ((succ_add__add_succ < qquint < dquint) > eq_comm) > bin_sub_left_impl);
			
			require sqq_le_rr proves qq++ <= rr
			by add_le_left < (succ_uint_is_uint < qquint) < dquint < rruint < (q_sdq_le_r > ((succ_add__add_succ < qquint < dquint) > eq_comm) > bin_sub_left_impl);
			
			require temp2 proves is_divisible_by (qq * (MUL_RANGE (qq++) rr)) (qq++ + dq)
			by (divisible__multiple_also_divisible < qquint < temp1) > (mul_comm < (mul_range_is_uint < (succ_uint_is_uint < qquint) < rruint < sqq_le_rr) < qquint) > bin_sub_left_impl;
			
			require qq_neq_rr proves qq != rr
			by succ_le__neq < qquint < rruint < sqq_le_rr;
			
			require qq_le_rr proves qq <= rr
			by succ_le < qquint < rruint < sqq_le_rr;
			
			require temp3 proves is_divisible_by (MUL_RANGE qq rr) (qq++ + dq)
			by temp2 > ((mul__mul_range < qquint < rruint < qq_le_rr < qq_neq_rr) > eq_comm) > bin_sub_left_impl;
			
			require temp4 proves is_divisible_by (MUL_RANGE qq rr) (qq + dq++)
			by temp3 > (succ_add__add_succ < qquint < dquint) > bin_sub_right_impl;
			
			temp4
		)
	);
	
	require q__le__q_plus_s_minus_q proves q <= q + (s - q)
	by q_le_s > ((add_satsub_same_2 < quint < suint < q_le_s) > eq_comm) > bin_sub_right_impl;
	
	require q_plus_s_minus_q__le__q proves q + (s - q) <= r
	by s_le_r > ((add_satsub_same_2 < quint < suint < q_le_s) > eq_comm) > bin_sub_left_impl;
	
	require almost_there proves is_divisible_by (MUL_RANGE q r) (q + (s - q))
	by unwrap Func (uint_inductive < casezero < casesucc < (uint_satsub_uint_is_uint < suint < quint)) < quint < ruint < q__le__q_plus_s_minus_q < q_plus_s_minus_q__le__q;
	
	almost_there > (add_satsub_same_2 < quint < suint < q_le_s) > bin_sub_right_impl
);

//require not_prime_has_prime_divisor proves forany a: a : UINT  ->  UINT_TWO <= a  ->  !(is_prime a)  ->  !(forany p: !(is_prime p && is_divisible_by a p))



// uint_le a b = (forany c: ((c : UINT) && (b == (a + c))) -> FALSE) -> FALSE;

require le__le_add proves forany a,b,c: a : UINT  ->  b : UINT  ->  c : UINT  ->  a <= b  ->  a <= (b + c)
by (
	forany a,b,c:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	assume cuint proves c : UINT;
	assume a_le_b proves a <= b;
	wrap uint_le (
		assume ttt proves forany e: ((e : UINT) && (b + c == (a + e))) -> FALSE;
		unwrap uint_le a_le_b < (
			// Goal:
			// forany d: ((d : UINT) && (b == (a + d))) -> FALSE
			forany d:
			assume ddd proves (d : UINT) && (b == (a + d));
			require duint proves d : UINT by ddd > and_left;
			ttt < (
				// Goal:
				// forSOME: (e : UINT) && (b + c == (a + e))
				
				require temp1 proves (a + d) + c == (a + d) + c    by eq_same;
				require temp2 proves (a + d) + c == a + (d + c)    by temp1 > (add_assoc < auint < duint < cuint) > bin_sub_right_impl;
				require temp3 proves b + c == a + (d + c)    by temp2 > (((ddd > and_right) > eq_comm) > bin_sub_left_eq) > bin_sub_left_impl;
				
				impl_impl_and < (uint_add_uint_is_uint < duint < cuint) < temp3
				
				// (a + d) + c == (a + d) + c
				// (a + d) + c == a + (d + c)
				// (a + d) + c == a + e
				// b + c == a + e
			)
		)
	)
);

require le__le_mul proves forany a,b,c: a : UINT  ->  b : UINT  ->  c : UINT  ->  a <= b  ->  c != UINT_ZERO  ->  a <= b * c
by (
	forany a,b,c:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	assume cuint proves c : UINT;
	assume a_le_b proves a <= b;
	assume c_not_0 proves c != UINT_ZERO;
	wrap uint_le (
		assume ttt proves forany e: ((e : UINT) && (b * c == (a + e))) -> FALSE;
		
		// Goal: FALSE
		
		unwrap uint_le a_le_b < (
			// Goal:
			// forany d: ((d : UINT) && (b == (a + d))) -> FALSE;
			
			forany d:
			assume ddd proves (d : UINT) && (b == (a + d));
			
			require duint proves d : UINT  by  ddd > and_left;
			require b_ad proves b == a + d  by  ddd > and_right;
			
			ttt < (
				// Goal:
				// forSOME e: (e : UINT) && (b * c == (a + e))
				
				// b = a + d
				// c != 0
				
				require a_le_bc proves a <= b * c
				by (
					require temp1 proves a <= a * c
					by right_not_zero__left_le_mul < auint < cuint < c_not_0;
					
					require temp2 proves a <= a * c + d * c
					by le__le_add < auint < (uint_mul_uint_is_uint < auint < cuint) < (uint_mul_uint_is_uint < duint < cuint) < temp1;
					
					require temp3 proves a <= (a + d) * c
					by temp2 > ((add_mul < auint < duint < cuint) > eq_comm) > bin_sub_right_impl;
					
					require temp4 proves a <= b * c
					by temp3 > ((b_ad > eq_comm) > bin_sub_left_eq) > bin_sub_right_impl;
					
					temp4
					
					// a <= a * c
					// a <= a * c + d * c
					// a <= (a + d) * c
					// a <= b * c
				);
				
				require temp1 proves b * c == a + (b * c - a)
				by (add_satsub_same_2 < auint < (uint_mul_uint_is_uint < buint < cuint) < a_le_bc) > eq_comm;
				
				impl_impl_and < (uint_satsub_uint_is_uint < (uint_mul_uint_is_uint < buint < cuint) < auint) < temp1
			)
		)
	)
);

require mul_range_0 proves forany a: a : UINT  ->  MUL_RANGE UINT_ZERO a == UINT_ZERO
by (
	forany a:
	assume auint proves a : UINT;
	
	// Goal:
	// MUL_RANGE UINT_ZERO a == UINT_ZERO
	
	or_cases < (uint_is_zero_or_succ < auint) < (
		assume a_0 proves a == UINT_ZERO;
		mul_range_same > ((a_0 > eq_comm) > bin_sub_right_eq) > bin_sub_left_impl
	) < (
		assume a_is_succ proves !(forany b: b : UINT -> a == b++ -> FALSE);
		
		// Goal:
		// MUL_RANGE UINT_ZERO a == UINT_ZERO
		
		not_not_impl < (
			// Goal:
			// !!(MUL_RANGE UINT_ZERO a == UINT_ZERO)
			
			assume ttt proves MUL_RANGE UINT_ZERO a != UINT_ZERO;
			
			// Goal: FALSE
			
			a_is_succ < (
				// Goal:
				// forany b: !(b : UINT -> a == b++)
				
				forany b:
				assume buint proves b : UINT;
				assume a_sb proves a == b++;
				
				// Goal: FALSE
				
				ttt < (
					// Goal:
					// MUL_RANGE UINT_ZERO a == UINT_ZERO
					
					require s0_le_a proves UINT_ZERO++ <= a  by (
						(succ_le_succ_reverse < zero_is_uint < buint < (zero_le < buint)) > (a_sb > eq_comm) > bin_sub_right_impl
					);
					require 0_not_a proves UINT_ZERO != a by (succ_le_not_zero < zero_is_uint < auint < s0_le_a) > neq_comm;
					
					require temp1 proves UINT_ZERO * MUL_RANGE UINT_ZERO++ a == UINT_ZERO
					by eq_same > ((zero_mul < (mul_range_is_uint < (succ_uint_is_uint < zero_is_uint) < auint < s0_le_a)) > eq_comm) > bin_sub_left_impl;
					
					require temp2 proves MUL_RANGE UINT_ZERO a == UINT_ZERO
					by temp1 > ((mul__mul_range < zero_is_uint < auint < (zero_le < auint) < 0_not_a) > eq_comm) > bin_sub_left_impl;
					
					temp2
					
					// UINT_ZERO == UINT_ZERO
					// UINT_ZERO * MUL_RANGE UINT_ZERO++ a == UINT_ZERO
					// MUL_RANGE UINT_ZERO a == UINT_ZERO
				)
			)
		)
	)
);

require mul_range_not_0 proves forany a,b: a : UINT  ->  b : UINT  ->  a != UINT_ZERO  ->  a <= b  ->  MUL_RANGE a b != UINT_ZERO
by (
	forany a,b:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	assume a_not_0 proves a != UINT_ZERO;
	assume a_le_b proves a <= b;
	
	//require temp1 proves a <= MUL_RANGE a b
	
	define Func x = a <= (a+x)  ->  MUL_RANGE a (a+x) != UINT_ZERO;
	
	require casezero proves Func UINT_ZERO
	by wrap Func (
		assume _ proves a <= (a + UINT_ZERO);
		
		require temp1 proves a == MUL_RANGE a (a + UINT_ZERO)
		by (mul_range_same > eq_comm) > (((add_zero < auint) > eq_comm) > bin_sub_right_eq) > bin_sub_right_impl;
		
		a_not_0 > (temp1 > bin_sub_left_eq) > bin_sub_left_impl
	);
	
	require casesucc proves forany x: x : UINT  ->  Func x  ->  Func x++
	by (
		forany x:
		assume xuint proves x : UINT;
		assume hypoth proves Func x;  
		require hypoth_ proves a <= (a+x)  ->  MUL_RANGE a (a+x) != UINT_ZERO
		by unwrap Func hypoth;
		wrap Func (
			assume a_le_ax proves a <= (a + x++);
			
			// Goal:
			// MUL_RANGE a (a + x++) != UINT_ZERO;
			
			or_cases < yay_or_nay < (
				assume a_asx proves a == a + x++;
				
				require temp1 proves a == MUL_RANGE a (a + x++)
				by (mul_range_same > eq_comm) > (a_asx > bin_sub_right_eq) > bin_sub_right_impl;
				
				a_not_0 > (temp1 > bin_sub_left_eq) > bin_sub_left_impl
			) < (
				assume a_asx proves a != a + x++;
				
				require a_asx2 proves a != (a + x)++    by a_asx > ((add_succ < auint < xuint) > bin_sub_right_eq) > bin_sub_left_impl;
				require a_le_ax2 proves a <= (a + x)++  by a_le_ax > (add_succ < auint < xuint) > bin_sub_right_impl;
				
				require a_le_ax proves a <= (a + x)
				by succ_le_succ < auint < (uint_add_uint_is_uint < auint < xuint) < (a_not_b__a_le_b__succ_a_le_b < auint < (succ_uint_is_uint < (uint_add_uint_is_uint < auint < xuint)) < a_asx2 < a_le_ax2);
				
				require hypoth__ proves MUL_RANGE a (a+x) != UINT_ZERO
				by hypoth_ < a_le_ax;
				
				require temp1 proves MUL_RANGE a (a + x) * (a + x)++ != UINT_ZERO
				by both_not_zero__mul_not_zero < (mul_range_is_uint < auint < (uint_add_uint_is_uint < auint < xuint) < a_le_ax) < (succ_uint_is_uint < (uint_add_uint_is_uint < auint < xuint)) < hypoth__ < (succ_not_zero < (uint_add_uint_is_uint < auint < xuint));
				
				require temp2 proves MUL_RANGE a (a + x)++ != UINT_ZERO
				by temp1 > (((mul_range__mul < auint < (uint_add_uint_is_uint < auint < xuint) < (le_same_add < auint < xuint)) > eq_comm) > bin_sub_left_eq) > bin_sub_left_impl;
				
				require temp3 proves MUL_RANGE a (a + x++) != UINT_ZERO
				by temp2 > ((((add_succ < auint < xuint) > eq_comm) > bin_sub_right_eq) > bin_sub_left_eq) > bin_sub_left_impl;
				
				temp3
				
				// MUL_RANGE a (a + x) * (a + x)++ != UINT_ZERO
				// MUL_RANGE a (a + x)++ != UINT_ZERO
				// MUL_RANGE a (a + x++) != UINT_ZERO
			)
		)
	);
	
	require b_aba proves b == a + (b - a)
	by (add_satsub_same_2 < auint < buint < a_le_b) > eq_comm;
	
	require temp1 proves a <= (a+(b-a))  ->  MUL_RANGE a (a+(b-a)) != UINT_ZERO
	by unwrap Func (uint_inductive < casezero < casesucc < (uint_satsub_uint_is_uint < buint < auint));
	
	require temp2 proves MUL_RANGE a (a+(b-a)) != UINT_ZERO
	by temp1 < (a_le_b > b_aba > bin_sub_right_impl);
	
	temp2 > (((b_aba > eq_comm) > bin_sub_right_eq) > bin_sub_left_eq) > bin_sub_left_impl
);

require lower_bound__le__mul_range proves forany a,b: a : UINT  ->  b : UINT  ->  a <= b  ->  a <= MUL_RANGE a b
by (
	forany a,b:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	assume a_le_b proves a <= b;
	or_cases < yay_or_nay < (
		assume ab proves a == b;
		((le_same < auint) > (mul_range_same > eq_comm) > bin_sub_right_impl) > (ab > bin_sub_right_eq) > bin_sub_right_impl
	) < (
		assume a_not_b proves a != b;
		
		require sa_le_b proves a++ <= b  by a_not_b__a_le_b__succ_a_le_b < auint < buint < a_not_b < a_le_b;
		
		require ttt proves MUL_RANGE (a++) b != UINT_ZERO
		by mul_range_not_0 < (succ_uint_is_uint < auint) < buint < (succ_not_zero < auint) < sa_le_b;
		
		require temp1 proves a <= a * MUL_RANGE (a++) b
		by le__le_mul < auint < auint < (mul_range_is_uint < (succ_uint_is_uint < auint) < buint < sa_le_b) < (le_same < auint) < ttt;
		
		require temp2 proves a <= MUL_RANGE a b
		by temp1 > ((mul__mul_range < auint < buint < a_le_b < a_not_b) > eq_comm) > bin_sub_right_impl;
		
		temp2
	)
);

require upper_bound__le__mul_range proves forany a,b: a : UINT  ->  b : UINT  ->  a != UINT_ZERO  ->  a <= b  ->  b <= MUL_RANGE a b
by (
	forany a,b:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	assume a_not_0 proves a != UINT_ZERO;
	assume a_le_b proves a <= b;
	
	define Func x = (b - x) != UINT_ZERO  ->  (b - x) <= b  ->  b <= MUL_RANGE (b - x) b;
	
	require casezero proves Func UINT_ZERO
	by wrap Func (
		// Goal:
		// (b - UINT_ZERO) != UINT_ZERO  ->  (b - UINT_ZERO) <= b  ->  b <= MUL_RANGE (b - UINT_ZERO) b
		assume _ proves (b - UINT_ZERO) != UINT_ZERO;
		assume __ proves (b - UINT_ZERO) <= b;
		((le_same < buint) > (mul_range_same > eq_comm) > bin_sub_right_impl) > (((satsub_zero < buint) > eq_comm) > bin_sub_left_eq) > bin_sub_right_impl
	);
	
	require casesucc proves forany x: x : UINT  ->  Func x  ->  Func x++
	by (
		forany x:
		assume xuint proves x : UINT;
		assume hypoth proves Func x;
		require hypoth_ proves  (b - x) != UINT_ZERO  ->  (b - x) <= b  ->  b <= MUL_RANGE (b - x) b
		by unwrap Func hypoth;
		wrap Func (
			assume b_sx__not_zero proves (b - x++) != UINT_ZERO;
			assume b_sx_le_b proves (b - x++) <= b;
			
			// Goal:
			// b <= MUL_RANGE (b - x++) b
			
			require sx_le_b proves x++ <= b
			by not_not_impl < (
				assume ttt proves !(x++ <= b);
				require b_le_sx proves b <= x++
				by (not_le__neq_and_le < (succ_uint_is_uint < xuint) < buint < ttt) > and_right;
				b_sx__not_zero < (satsub_saturates < buint < (succ_uint_is_uint < xuint) < b_le_sx)
			);
			
			require s_b_sx__not_zero proves (b - x++)++ != UINT_ZERO
			by succ_not_zero < (uint_satsub_uint_is_uint < buint < (succ_uint_is_uint < xuint));
			
			// asdfkhasdjkhf             x++ <= b  ->  (b - x++)++  ==  b - x
			
			require b_x__not_zero proves (b - x) != UINT_ZERO
			by s_b_sx__not_zero > ((asdfkhasdjkhf < buint < xuint < sx_le_b) > bin_sub_left_eq) > bin_sub_left_impl;
			
			require b_x_le_b proves (b - x) <= b
			by satsub_le_left < buint < xuint;
			
			require hypoth__ proves b <= MUL_RANGE (b - x) b
			by hypoth_ < b_x__not_zero < b_x_le_b;
			
			// mul_not_zero__left_le_mul         ((a * b) != 0)  ->  a <= (a * b)
			
			// mul_le_mul_left
			
			require r1 proves MUL_RANGE (b - x) b : UINT
			by (mul_range_is_uint < (uint_satsub_uint_is_uint < buint < xuint) < buint < b_x_le_b);
			
			require r2 proves (b - x++) : UINT
			by (uint_satsub_uint_is_uint < buint < (succ_uint_is_uint < xuint));
			
			require temp1 proves b  <=  (b - x++) * MUL_RANGE (b - x) b
			by (le__le_mul < buint < r1 < r2 < hypoth__ < b_sx__not_zero) > (mul_comm < r1 < r2) > bin_sub_right_impl;
			
			require temp2 proves b  <=  (b - x++) * MUL_RANGE (b - x++)++ b
			by temp1 > ((((asdfkhasdjkhf < buint < xuint < sx_le_b) > eq_comm) > bin_sub_left_eq) > bin_sub_right_eq) > bin_sub_right_impl;
			
			require temp3a proves (b - x++) != b
			by (
				assume b_sx_b proves b - x++ == b;
				
				// Goal: FALSE
				
				or_cases < yay_or_nay < (
					assume b_le_sx proves b <= x++;
					
					require ttt proves b - x++ == UINT_ZERO
					by satsub_saturates < buint < (succ_uint_is_uint < xuint) < b_le_sx;
					
					b_sx__not_zero < ttt
				) < (
					assume not_b_le_sx proves !(b <= x++);
					
					require b_neq_sx proves b != x++   by  (not_le__neq_and_le < buint < (succ_uint_is_uint < xuint) < not_b_le_sx) > and_left;
					require sx_le_b  proves x++ <= b   by  (not_le__neq_and_le < buint < (succ_uint_is_uint < xuint) < not_b_le_sx) > and_right;
					
					require tempp1 proves (b - x++) + x++ == b + x++
					by b_sx_b > wrap_in_bin_func_lhs;
					
					require tempp2 proves b == b + x++
					by tempp1 > (satsub_add_same < buint < (succ_uint_is_uint < xuint) < sx_le_b) > bin_sub_left_impl;
					
					require tempp3 proves x++ == UINT_ZERO
					by add_right_eq_self < buint < (succ_uint_is_uint < xuint) < (tempp2 > eq_comm);
					
					tempp3 > (succ_not_zero < xuint)
				)
			);
			
			require temp3b proves (b - x++) <= b
			by satsub_le_left < buint < (succ_uint_is_uint < xuint);
			
			require temp3 proves b <= MUL_RANGE (b - x++) b
			by temp2 > ((mul__mul_range < r2 < buint < temp3b < temp3a) > eq_comm) > bin_sub_right_impl;
			
			temp3
			
			// b  <=  (b - x++) * MUL_RANGE (b - x) b
			// b  <=  (b - x++) * MUL_RANGE (b - x++)++ b
			// b  <=  MUL_RANGE (b - x++) b
		)
	);
	
	require temp1 proves (b - (b - a)) != UINT_ZERO  ->  (b - (b - a)) <= b  ->  b <= MUL_RANGE (b - (b - a)) b
	by unwrap Func (uint_inductive < casezero < casesucc < (uint_satsub_uint_is_uint < buint < auint));
	
	require bba_a proves b - (b - a) == a
	by satsub__same_satsub < buint < auint < a_le_b;
	
	require temp2 proves b <= MUL_RANGE (b - (b - a)) b
	by temp1 < (a_not_0 > ((bba_a > eq_comm) > bin_sub_left_eq) > bin_sub_left_impl) < (a_le_b > (bba_a > eq_comm) > bin_sub_left_impl);
	
	temp2 > ((bba_a) > bin_sub_left_eq) > bin_sub_right_impl
);

require 2_le_not_1 proves forany a: a : UINT  ->  UINT_TWO <= a  ->  a != UINT_ONE
by (
	forany a:
	assume auint proves a : UINT;
	assume 2_le_a proves UINT_TWO <= a;
	assume a_1 proves a == UINT_ONE;
	require 2_le_1 proves UINT_TWO <= UINT_ONE   by 2_le_a > a_1 > bin_sub_right_impl;
	require s1_le_s0 proves UINT_SUCC UINT_ONE <= UINT_SUCC UINT_ZERO   by (2_le_1 > uint_two_eq_succ_one > bin_sub_left_impl) > uint_one_eq_succ_zero > bin_sub_right_impl;
	one_is_not_zero < (le_zero__is_zero < one_is_uint < (succ_le_succ < one_is_uint < zero_is_uint < s1_le_s0))
);

require succ_mul_range_not_divisible_by_number_in_range proves
	forany a,b:  a : UINT  ->  b : UINT  ->
	UINT_TWO <= a  ->  a <= b  ->  (forany c: c : UINT  ->  a <= c  ->  c <= b  ->  !(is_divisible_by (UINT_SUCC (MUL_RANGE a b)) c) )
by (
	forany a,b,c:
	assume auint proves a : UINT;
	assume buint proves b : UINT;
	assume 2_le_a proves UINT_TWO <= a;
	assume a_b proves a <= b;
	assume cuint proves c : UINT;
	assume a_c proves a <= c;
	assume c_b proves c <= b;
	
	assume ttt proves is_divisible_by (UINT_SUCC (MUL_RANGE a b)) c;
	
	// Goal: FALSE
	
	require temp1 proves is_divisible_by (MUL_RANGE a b) c
	by mul_range_divisible_by_number_in_range < auint < buint < cuint < a_c < c_b;
	
	require 2_le_c proves UINT_TWO <= c  by  le_trans < two_is_uint < auint < cuint < 2_le_a < a_c;
	require c_not_1 proves c != UINT_ONE   by  2_le_not_1 < cuint < 2_le_c;
	
	require temp2 proves !(is_divisible_by (UINT_SUCC (MUL_RANGE a b)) c)
	by if_divisible_then_succ_not_divisible < temp1 < c_not_1;
	
	temp2 < ttt
);


// For any uint x, it is not the case that all primes are <= x

require infinite_primes proves forany x: x : UINT -> !(forany p: is_prime p  ->  p <= x)
by (
	forany x:
	assume lpuint proves x : UINT;
	assume ppp proves forany p: is_prime p  ->  p <= x;
	
	// Goal: FALSE
	
	require ppp_ proves forany p: !(p <= x) -> !(is_prime p)
	by impl_reverse < ppp;
	
	require 2_le_lp proves UINT_TWO <= x
	by ppp < two_is_prime;
	
	require mr_larger_than_x proves x <= (MUL_RANGE UINT_TWO x)
	by upper_bound__le__mul_range < two_is_uint < lpuint < two_is_not_zero < 2_le_lp;
	
	require 2_le_2 proves UINT_TWO <= UINT_TWO
	by le_same < two_is_uint;
	
	require kfjadjfsd proves (forany c: c : UINT  ->  UINT_TWO <= c  ->  c <= x  ->  !(is_divisible_by (UINT_SUCC (MUL_RANGE UINT_TWO x)) c) )
	by succ_mul_range_not_divisible_by_number_in_range < two_is_uint < lpuint < 2_le_2 < 2_le_lp;
	
	require 2_le_mr1 proves UINT_TWO <= (UINT_SUCC (MUL_RANGE UINT_TWO x))
	by le_to_le_succ < two_is_uint < (mul_range_is_uint < two_is_uint < lpuint < 2_le_lp) < (lower_bound__le__mul_range < two_is_uint < lpuint < 2_le_lp);
	
	require kjjkdfgkjs proves !(forany w: !(is_prime w && is_divisible_by (UINT_SUCC (MUL_RANGE UINT_TWO x)) w))
	by 2_le__has_prime_divisor < (succ_uint_is_uint < (mul_range_is_uint < two_is_uint < lpuint < 2_le_lp)) < 2_le_mr1;
	
	kjjkdfgkjs < (
		forany w:
		assume www proves is_prime w && is_divisible_by (UINT_SUCC (MUL_RANGE UINT_TWO x)) w;
		
		// Goal: FALSE
		
		require wuint proves w : UINT  by  (unwrap is_divisible_by (www > and_right) > and_left) > and_right;
		
		require 2_le_w proves UINT_TWO <= w  by two_le_prime < (www > and_left);
		require w_le_lp proves w <= x  by ppp < (www > and_left);
		
		kfjadjfsd < wuint < 2_le_w < w_le_lp < (www > and_right)
	)
);