egglog 2.0.0

;; reproduction of example that fails in the new backend currently
;; from adding logging to `uv run pytest python/tests/test_array_api.py::TestTupleTupleInt::test_product_example`
;; `Panic: Illegal merge attempted for function TupleInt_to_vec`

(sort TupleTupleInt)
(constructor TupleTupleInt_product (TupleTupleInt) TupleTupleInt)
(sort TupleInt)
(sort Vec_TupleInt (Vec TupleInt))
(constructor TupleTupleInt_from_vec (Vec_TupleInt) TupleTupleInt)
(sort Int)
(sort Vec_Int (Vec Int))
(constructor TupleInt_from_vec (Vec_Int) TupleInt)
(constructor Int___init__ (i64) Int)
(let $%__check_eq_x (TupleTupleInt_product (TupleTupleInt_from_vec (vec-of (TupleInt_from_vec (vec-of (Int___init__ 0) (Int___init__ 1))) (TupleInt_from_vec (vec-of (Int___init__ 4) (Int___init__ 5)))))))
(ruleset array_api_ruleset)
(constructor i-TupleInt__-Int_i (TupleInt Int) TupleInt)
(rewrite (i-TupleInt__-Int_i i _) i :subsume :ruleset array_api_ruleset)
(constructor TupleTupleInt_single (TupleInt) TupleTupleInt)
(sort UnstableFn_TupleInt_Int (UnstableFn (Int ) TupleInt))
(constructor TupleTupleInt___init__ (Int UnstableFn_TupleInt_Int) TupleTupleInt)
(rewrite (TupleTupleInt_single i) (TupleTupleInt___init__ (Int___init__ 1) (unstable-fn "i-TupleInt__-Int_i" i)) :subsume :ruleset array_api_ruleset)
(sort Value)
(sort TupleValue)
(sort Boolean)
(constructor Value_if_ (Boolean Value Value) Value)
(constructor Int___lt__ (Int Int) Boolean)
(constructor TupleValue_length (TupleValue) Int)
(constructor TupleValue___getitem__ (TupleValue Int) Value)
(constructor Int___sub__ (Int Int) Int)
(constructor other-TupleValue_self-TupleValue_i-Int__Value_if___Int___lt___i__TupleValue_length_self____TupleValue___getitem___self_i___TupleValue___getitem___other__Int___sub___i__TupleValue_length_self____ (TupleValue TupleValue Int) Value)
(rewrite (other-TupleValue_self-TupleValue_i-Int__Value_if___Int___lt___i__TupleValue_length_self____TupleValue___getitem___self_i___TupleValue___getitem___other__Int___sub___i__TupleValue_length_self____ other self i) (Value_if_ (Int___lt__ i (TupleValue_length self)) (TupleValue___getitem__ self i) (TupleValue___getitem__ other (Int___sub__ i (TupleValue_length self)))) :subsume :ruleset array_api_ruleset)
(constructor TupleValue___add__ (TupleValue TupleValue) TupleValue)
(sort UnstableFn_Value_Int (UnstableFn (Int ) Value))
(constructor TupleValue___init__ (Int UnstableFn_Value_Int) TupleValue)
(constructor Int___add__ (Int Int) Int)
(rewrite (TupleValue___add__ self other) (TupleValue___init__ (Int___add__ (TupleValue_length self) (TupleValue_length other)) (unstable-fn "other-TupleValue_self-TupleValue_i-Int__Value_if___Int___lt___i__TupleValue_length_self____TupleValue___getitem___self_i___TupleValue___getitem___other__Int___sub___i__TupleValue_length_self____" other self)) :ruleset array_api_ruleset)
(constructor Boolean___or__ (Boolean Boolean) Boolean)
(constructor Value___eq__ (Value Value) Boolean)
(constructor value-Value_acc-Boolean_j-Value__Boolean___or___acc__Value___eq___value_j__ (Value Boolean Value) Boolean)
(rewrite (value-Value_acc-Boolean_j-Value__Boolean___or___acc__Value___eq___value_j__ value acc j) (Boolean___or__ acc (Value___eq__ value j)) :subsume :ruleset array_api_ruleset)
(constructor TupleValue_contains (TupleValue Value) Boolean)
(sort UnstableFn_Boolean_Boolean_Value (UnstableFn (Boolean Value) Boolean))
(constructor TupleValue_foldl_boolean (TupleValue UnstableFn_Boolean_Boolean_Value Boolean) Boolean)
(constructor Boolean___init__ (bool) Boolean)
(rewrite (TupleValue_contains self value) (TupleValue_foldl_boolean self (unstable-fn "value-Value_acc-Boolean_j-Value__Boolean___or___acc__Value___eq___value_j__" value) (Boolean___init__ false)) :ruleset array_api_ruleset)
(constructor Value_int (Int) Value)
(constructor TupleInt___getitem__ (TupleInt Int) Int)
(constructor ti-TupleInt_i-Int__Value_int__TupleInt___getitem___ti_i__ (TupleInt Int) Value)
(rewrite (ti-TupleInt_i-Int__Value_int__TupleInt___getitem___ti_i__ ti i) (Value_int (TupleInt___getitem__ ti i)) :subsume :ruleset array_api_ruleset)
(constructor TupleValue_from_tuple_int (TupleInt) TupleValue)
(constructor TupleInt_length (TupleInt) Int)
(rewrite (TupleValue_from_tuple_int ti) (TupleValue___init__ (TupleInt_length ti) (unstable-fn "ti-TupleInt_i-Int__Value_int__TupleInt___getitem___ti_i__" ti)) :subsume :ruleset array_api_ruleset)
(constructor TupleInt_if_ (Boolean TupleInt TupleInt) TupleInt)
(constructor TupleTupleInt_length (TupleTupleInt) Int)
(constructor TupleTupleInt___getitem__ (TupleTupleInt Int) TupleInt)
(constructor other-TupleTupleInt_self-TupleTupleInt_i-Int__TupleInt_if___Int___lt___i__TupleTupleInt_length_self____TupleTupleInt___getitem___self_i___TupleTupleInt___getitem___other__Int___sub___i__TupleTupleInt_length_self____ (TupleTupleInt TupleTupleInt Int) TupleInt)
(rewrite (other-TupleTupleInt_self-TupleTupleInt_i-Int__TupleInt_if___Int___lt___i__TupleTupleInt_length_self____TupleTupleInt___getitem___self_i___TupleTupleInt___getitem___other__Int___sub___i__TupleTupleInt_length_self____ other self i) (TupleInt_if_ (Int___lt__ i (TupleTupleInt_length self)) (TupleTupleInt___getitem__ self i) (TupleTupleInt___getitem__ other (Int___sub__ i (TupleTupleInt_length self)))) :subsume :ruleset array_api_ruleset)
(constructor TupleTupleInt___add__ (TupleTupleInt TupleTupleInt) TupleTupleInt)
(rewrite (TupleTupleInt___add__ self other) (TupleTupleInt___init__ (Int___add__ (TupleTupleInt_length self) (TupleTupleInt_length other)) (unstable-fn "other-TupleTupleInt_self-TupleTupleInt_i-Int__TupleInt_if___Int___lt___i__TupleTupleInt_length_self____TupleTupleInt___getitem___self_i___TupleTupleInt___getitem___other__Int___sub___i__TupleTupleInt_length_self____" other self)) :ruleset array_api_ruleset)
(constructor n-Int_self-TupleTupleInt_i-Int__TupleTupleInt___getitem___self__Int___add___i_n__ (Int TupleTupleInt Int) TupleInt)
(rewrite (n-Int_self-TupleTupleInt_i-Int__TupleTupleInt___getitem___self__Int___add___i_n__ n self i) (TupleTupleInt___getitem__ self (Int___add__ i n)) :subsume :ruleset array_api_ruleset)
(constructor TupleTupleInt_drop (TupleTupleInt Int) TupleTupleInt)
(rewrite (TupleTupleInt_drop self n) (TupleTupleInt___init__ (Int___sub__ (TupleTupleInt_length self) n) (unstable-fn "n-Int_self-TupleTupleInt_i-Int__TupleTupleInt___getitem___self__Int___add___i_n__" n self)) :ruleset array_api_ruleset)
(sort UnstableFn_Int_TupleInt (UnstableFn (TupleInt ) Int))
(constructor f-UnstableFn_Int_TupleInt_self-TupleTupleInt_i-Int__unstable-app_f__TupleTupleInt___getitem___self_i__ (UnstableFn_Int_TupleInt TupleTupleInt Int) Int)
(rewrite (f-UnstableFn_Int_TupleInt_self-TupleTupleInt_i-Int__unstable-app_f__TupleTupleInt___getitem___self_i__ f self i) (unstable-app f (TupleTupleInt___getitem__ self i)) :subsume :ruleset array_api_ruleset)
(constructor TupleTupleInt_map_int (TupleTupleInt UnstableFn_Int_TupleInt) TupleInt)
(sort UnstableFn_Int_Int (UnstableFn (Int ) Int))
(constructor TupleInt___init__ (Int UnstableFn_Int_Int) TupleInt)
(rewrite (TupleTupleInt_map_int self f) (TupleInt___init__ (TupleTupleInt_length self) (unstable-fn "f-UnstableFn_Int_TupleInt_self-TupleTupleInt_i-Int__unstable-app_f__TupleTupleInt___getitem___self_i__" f self)) :ruleset array_api_ruleset)
(constructor x-TupleInt__TupleInt_length_x_ (TupleInt) Int)
(rewrite (x-TupleInt__TupleInt_length_x_ x) (TupleInt_length x) :subsume :ruleset array_api_ruleset)
(constructor Int___mod__ (Int Int) Int)
(constructor Int___floordiv__ (Int Int) Int)
(constructor TupleInt_product (TupleInt) Int)
(constructor i-Int_self-TupleTupleInt_j-Int__TupleInt___getitem____TupleTupleInt___getitem___self_j___Int___mod____Int___floordiv___i__TupleInt_product__TupleTupleInt_map_int__TupleTupleInt_drop_self__Int___add___j__Int___init___1_____unstable-fn__x-TupleInt__TupleInt_length_x________TupleInt_length__TupleTupleInt___getitem___self_j____ (Int TupleTupleInt Int) Int)
(rewrite (i-Int_self-TupleTupleInt_j-Int__TupleInt___getitem____TupleTupleInt___getitem___self_j___Int___mod____Int___floordiv___i__TupleInt_product__TupleTupleInt_map_int__TupleTupleInt_drop_self__Int___add___j__Int___init___1_____unstable-fn__x-TupleInt__TupleInt_length_x________TupleInt_length__TupleTupleInt___getitem___self_j____ i self j) (TupleInt___getitem__ (TupleTupleInt___getitem__ self j) (Int___mod__ (Int___floordiv__ i (TupleInt_product (TupleTupleInt_map_int (TupleTupleInt_drop self (Int___add__ j (Int___init__ 1))) (unstable-fn "x-TupleInt__TupleInt_length_x_")))) (TupleInt_length (TupleTupleInt___getitem__ self j)))) :subsume :ruleset array_api_ruleset)
(constructor self-TupleTupleInt_i-Int__TupleInt___init____TupleTupleInt_length_self___unstable-fn__i-Int_self-TupleTupleInt_j-Int__TupleInt___getitem____TupleTupleInt___getitem___self_j___Int___mod____Int___floordiv___i__TupleInt_product__TupleTupleInt_map_int__TupleTupleInt_drop_self__Int___add___j__Int___init___1_____unstable-fn__x-TupleInt__TupleInt_length_x________TupleInt_length__TupleTupleInt___getitem___self_j______i_self__ (TupleTupleInt Int) TupleInt)
(rewrite (self-TupleTupleInt_i-Int__TupleInt___init____TupleTupleInt_length_self___unstable-fn__i-Int_self-TupleTupleInt_j-Int__TupleInt___getitem____TupleTupleInt___getitem___self_j___Int___mod____Int___floordiv___i__TupleInt_product__TupleTupleInt_map_int__TupleTupleInt_drop_self__Int___add___j__Int___init___1_____unstable-fn__x-TupleInt__TupleInt_length_x________TupleInt_length__TupleTupleInt___getitem___self_j______i_self__ self i) (TupleInt___init__ (TupleTupleInt_length self) (unstable-fn "i-Int_self-TupleTupleInt_j-Int__TupleInt___getitem____TupleTupleInt___getitem___self_j___Int___mod____Int___floordiv___i__TupleInt_product__TupleTupleInt_map_int__TupleTupleInt_drop_self__Int___add___j__Int___init___1_____unstable-fn__x-TupleInt__TupleInt_length_x________TupleInt_length__TupleTupleInt___getitem___self_j____" i self)) :subsume :ruleset array_api_ruleset)
(rewrite (TupleTupleInt_product self) (TupleTupleInt___init__ (TupleInt_product (TupleTupleInt_map_int self (unstable-fn "x-TupleInt__TupleInt_length_x_"))) (unstable-fn "self-TupleTupleInt_i-Int__TupleInt___init____TupleTupleInt_length_self___unstable-fn__i-Int_self-TupleTupleInt_j-Int__TupleInt___getitem____TupleTupleInt___getitem___self_j___Int___mod____Int___floordiv___i__TupleInt_product__TupleTupleInt_map_int__TupleTupleInt_drop_self__Int___add___j__Int___init___1_____unstable-fn__x-TupleInt__TupleInt_length_x________TupleInt_length__TupleTupleInt___getitem___self_j______i_self__" self)) :subsume :ruleset array_api_ruleset)
(constructor i-Int__-Int_i (Int Int) Int)
(rewrite (i-Int__-Int_i i _) i :subsume :ruleset array_api_ruleset)
(constructor TupleInt_single (Int) TupleInt)
(rewrite (TupleInt_single i) (TupleInt___init__ (Int___init__ 1) (unstable-fn "i-Int__-Int_i" i)) :ruleset array_api_ruleset)
(constructor i-Int_i (Int) Int)
(rewrite (i-Int_i i) i :subsume :ruleset array_api_ruleset)
(constructor TupleInt_range (Int) TupleInt)
(rewrite (TupleInt_range stop) (TupleInt___init__ stop (unstable-fn "i-Int_i")) :subsume :ruleset array_api_ruleset)
(constructor Int_if_ (Boolean Int Int) Int)
(constructor other-TupleInt_self-TupleInt_i-Int__Int_if___Int___lt___i__TupleInt_length_self____TupleInt___getitem___self_i___TupleInt___getitem___other__Int___sub___i__TupleInt_length_self____ (TupleInt TupleInt Int) Int)
(rewrite (other-TupleInt_self-TupleInt_i-Int__Int_if___Int___lt___i__TupleInt_length_self____TupleInt___getitem___self_i___TupleInt___getitem___other__Int___sub___i__TupleInt_length_self____ other self i) (Int_if_ (Int___lt__ i (TupleInt_length self)) (TupleInt___getitem__ self i) (TupleInt___getitem__ other (Int___sub__ i (TupleInt_length self)))) :subsume :ruleset array_api_ruleset)
(constructor TupleInt___add__ (TupleInt TupleInt) TupleInt)
(rewrite (TupleInt___add__ self other) (TupleInt___init__ (Int___add__ (TupleInt_length self) (TupleInt_length other)) (unstable-fn "other-TupleInt_self-TupleInt_i-Int__Int_if___Int___lt___i__TupleInt_length_self____TupleInt___getitem___self_i___TupleInt___getitem___other__Int___sub___i__TupleInt_length_self____" other self)) :ruleset array_api_ruleset)
(constructor Int___eq__ (Int Int) Boolean)
(constructor i-Int_acc-Boolean_j-Int__Boolean___or___acc__Int___eq___i_j__ (Int Boolean Int) Boolean)
(rewrite (i-Int_acc-Boolean_j-Int__Boolean___or___acc__Int___eq___i_j__ i acc j) (Boolean___or__ acc (Int___eq__ i j)) :subsume :ruleset array_api_ruleset)
(constructor TupleInt_contains (TupleInt Int) Boolean)
(sort UnstableFn_Boolean_Boolean_Int (UnstableFn (Boolean Int) Boolean))
(constructor TupleInt_foldl_boolean (TupleInt UnstableFn_Boolean_Boolean_Int Boolean) Boolean)
(rewrite (TupleInt_contains self i) (TupleInt_foldl_boolean self (unstable-fn "i-Int_acc-Boolean_j-Int__Boolean___or___acc__Int___eq___i_j__" i) (Boolean___init__ false)) :subsume :ruleset array_api_ruleset)
(sort UnstableFn_Boolean_Int (UnstableFn (Int ) Boolean))
(constructor TupleInt_append (TupleInt Int) TupleInt)
(constructor f-UnstableFn_Boolean_Int_acc-TupleInt_v-Int__TupleInt_if___unstable-app_f_v___TupleInt_append_acc_v__acc_ (UnstableFn_Boolean_Int TupleInt Int) TupleInt)
(rewrite (f-UnstableFn_Boolean_Int_acc-TupleInt_v-Int__TupleInt_if___unstable-app_f_v___TupleInt_append_acc_v__acc_ f acc v) (TupleInt_if_ (unstable-app f v) (TupleInt_append acc v) acc) :subsume :ruleset array_api_ruleset)
(constructor TupleInt_filter (TupleInt UnstableFn_Boolean_Int) TupleInt)
(sort UnstableFn_TupleInt_TupleInt_Int (UnstableFn (TupleInt Int) TupleInt))
(constructor TupleInt_foldl_tuple_int (TupleInt UnstableFn_TupleInt_TupleInt_Int TupleInt) TupleInt)
(constructor TupleInt_EMPTY () TupleInt)
(rewrite (TupleInt_filter self f) (TupleInt_foldl_tuple_int self (unstable-fn "f-UnstableFn_Boolean_Int_acc-TupleInt_v-Int__TupleInt_if___unstable-app_f_v___TupleInt_append_acc_v__acc_" f) (TupleInt_EMPTY )) :subsume :ruleset array_api_ruleset)
(constructor f-UnstableFn_Int_Int_self-TupleInt_i-Int__unstable-app_f__TupleInt___getitem___self_i__ (UnstableFn_Int_Int TupleInt Int) Int)
(rewrite (f-UnstableFn_Int_Int_self-TupleInt_i-Int__unstable-app_f__TupleInt___getitem___self_i__ f self i) (unstable-app f (TupleInt___getitem__ self i)) :subsume :ruleset array_api_ruleset)
(constructor TupleInt_map (TupleInt UnstableFn_Int_Int) TupleInt)
(rewrite (TupleInt_map self f) (TupleInt___init__ (TupleInt_length self) (unstable-fn "f-UnstableFn_Int_Int_self-TupleInt_i-Int__unstable-app_f__TupleInt___getitem___self_i__" f self)) :subsume :ruleset array_api_ruleset)
(constructor n-Int_self-TupleInt_i-Int__TupleInt___getitem___self__Int___add___i_n__ (Int TupleInt Int) Int)
(rewrite (n-Int_self-TupleInt_i-Int__TupleInt___getitem___self__Int___add___i_n__ n self i) (TupleInt___getitem__ self (Int___add__ i n)) :subsume :ruleset array_api_ruleset)
(constructor TupleInt_drop (TupleInt Int) TupleInt)
(rewrite (TupleInt_drop self n) (TupleInt___init__ (Int___sub__ (TupleInt_length self) n) (unstable-fn "n-Int_self-TupleInt_i-Int__TupleInt___getitem___self__Int___add___i_n__" n self)) :ruleset array_api_ruleset)
(constructor Int___mul__ (Int Int) Int)
(constructor acc-Int_i-Int__Int___mul___acc_i_ (Int Int) Int)
(rewrite (acc-Int_i-Int__Int___mul___acc_i_ acc i) (Int___mul__ acc i) :subsume :ruleset array_api_ruleset)
(sort UnstableFn_Int_Int_Int (UnstableFn (Int Int) Int))
(constructor TupleInt_foldl (TupleInt UnstableFn_Int_Int_Int Int) Int)
(rewrite (TupleInt_product self) (TupleInt_foldl self (unstable-fn "acc-Int_i-Int__Int___mul___acc_i_") (Int___init__ 1)) :ruleset array_api_ruleset)
(constructor f-UnstableFn_TupleInt_Int_self-TupleInt_i-Int__unstable-app_f__TupleInt___getitem___self_i__ (UnstableFn_TupleInt_Int TupleInt Int) TupleInt)
(rewrite (f-UnstableFn_TupleInt_Int_self-TupleInt_i-Int__unstable-app_f__TupleInt___getitem___self_i__ f self i) (unstable-app f (TupleInt___getitem__ self i)) :subsume :ruleset array_api_ruleset)
(constructor TupleInt_map_tuple_int (TupleInt UnstableFn_TupleInt_Int) TupleTupleInt)
(rewrite (TupleInt_map_tuple_int self f) (TupleTupleInt___init__ (TupleInt_length self) (unstable-fn "f-UnstableFn_TupleInt_Int_self-TupleInt_i-Int__unstable-app_f__TupleInt___getitem___self_i__" f self)) :ruleset array_api_ruleset)
(constructor self-TupleInt_i-Int__TupleInt___getitem___self_i_ (TupleInt Int) Int)
(rewrite (self-TupleInt_i-Int__TupleInt___getitem___self_i_ self i) (TupleInt___getitem__ self i) :subsume :ruleset array_api_ruleset)
(constructor TupleInt_select (TupleInt TupleInt) TupleInt)
(rewrite (TupleInt_select self indices) (TupleInt_map indices (unstable-fn "self-TupleInt_i-Int__TupleInt___getitem___self_i_" self)) :ruleset array_api_ruleset)
(constructor Boolean___invert__ (Boolean) Boolean)
(constructor indices-TupleInt_i-Int__Boolean___invert____TupleInt_contains_indices_i__ (TupleInt Int) Boolean)
(rewrite (indices-TupleInt_i-Int__Boolean___invert____TupleInt_contains_indices_i__ indices i) (Boolean___invert__ (TupleInt_contains indices i)) :subsume :ruleset array_api_ruleset)
(constructor TupleInt_deselect (TupleInt TupleInt) TupleInt)
(rewrite (TupleInt_deselect self indices) (TupleInt_map (TupleInt_filter (TupleInt_range (TupleInt_length self)) (unstable-fn "indices-TupleInt_i-Int__Boolean___invert____TupleInt_contains_indices_i__" indices)) (unstable-fn "self-TupleInt_i-Int__TupleInt___getitem___self_i_" self)) :ruleset array_api_ruleset)
(constructor value-Value__-TupleInt_value (Value TupleInt) Value)
(rewrite (value-Value__-TupleInt_value value _) value :subsume :ruleset array_api_ruleset)
(sort NDArray)
(constructor NDArray_scalar (Value) NDArray)
(sort DType)
(sort UnstableFn_Value_TupleInt (UnstableFn (TupleInt ) Value))
(constructor NDArray___init__ (TupleInt DType UnstableFn_Value_TupleInt) NDArray)
(constructor Value_dtype (Value) DType)
(rewrite (NDArray_scalar value) (NDArray___init__ (TupleInt_EMPTY ) (Value_dtype value) (unstable-fn "value-Value__-TupleInt_value" value)) :ruleset array_api_ruleset)
(sort TupleNDArray)
(constructor NDArray_if_ (Boolean NDArray NDArray) NDArray)
(constructor TupleNDArray_length (TupleNDArray) Int)
(constructor TupleNDArray___getitem__ (TupleNDArray Int) NDArray)
(constructor other-TupleNDArray_self-TupleNDArray_i-Int__NDArray_if___Int___lt___i__TupleNDArray_length_self____TupleNDArray___getitem___self_i___TupleNDArray___getitem___other__Int___sub___i__TupleNDArray_length_self____ (TupleNDArray TupleNDArray Int) NDArray)
(rewrite (other-TupleNDArray_self-TupleNDArray_i-Int__NDArray_if___Int___lt___i__TupleNDArray_length_self____TupleNDArray___getitem___self_i___TupleNDArray___getitem___other__Int___sub___i__TupleNDArray_length_self____ other self i) (NDArray_if_ (Int___lt__ i (TupleNDArray_length self)) (TupleNDArray___getitem__ self i) (TupleNDArray___getitem__ other (Int___sub__ i (TupleNDArray_length self)))) :subsume :ruleset array_api_ruleset)
(constructor TupleNDArray___add__ (TupleNDArray TupleNDArray) TupleNDArray)
(sort UnstableFn_NDArray_Int (UnstableFn (Int ) NDArray))
(constructor TupleNDArray___init__ (Int UnstableFn_NDArray_Int) TupleNDArray)
(rewrite (TupleNDArray___add__ self other) (TupleNDArray___init__ (Int___add__ (TupleNDArray_length self) (TupleNDArray_length other)) (unstable-fn "other-TupleNDArray_self-TupleNDArray_i-Int__NDArray_if___Int___lt___i__TupleNDArray_length_self____TupleNDArray___getitem___self_i___TupleNDArray___getitem___other__Int___sub___i__TupleNDArray_length_self____" other self)) :ruleset array_api_ruleset)
(sort LoopNestAPI)
(constructor LoopNestAPI_indices (LoopNestAPI) TupleTupleInt)
(constructor LoopNestAPI_get_dims (LoopNestAPI) TupleInt)
(rewrite (LoopNestAPI_indices self) (TupleTupleInt_product (TupleInt_map_tuple_int (LoopNestAPI_get_dims self) (unstable-fn "TupleInt_range"))) :ruleset array_api_ruleset)
(sort OptionalLoopNestAPI)
(constructor LoopNestAPI_from_tuple (TupleInt) OptionalLoopNestAPI)
(constructor OptionalLoopNestAPI_NONE () OptionalLoopNestAPI)
(rewrite (LoopNestAPI_from_tuple (TupleInt_EMPTY )) (OptionalLoopNestAPI_NONE ) :subsume :ruleset array_api_ruleset)
(constructor OptionalLoopNestAPI___init__ (LoopNestAPI) OptionalLoopNestAPI)
(constructor LoopNestAPI___init__ (Int OptionalLoopNestAPI) LoopNestAPI)
(rewrite (LoopNestAPI_from_tuple (TupleInt_append ti dim)) (OptionalLoopNestAPI___init__ (LoopNestAPI___init__ dim (LoopNestAPI_from_tuple ti))) :subsume :ruleset array_api_ruleset)
(rewrite (LoopNestAPI_get_dims (LoopNestAPI___init__ dim (OptionalLoopNestAPI_NONE ))) (TupleInt_single dim) :subsume :ruleset array_api_ruleset)
(rewrite (LoopNestAPI_get_dims (LoopNestAPI___init__ dim (OptionalLoopNestAPI___init__ lna))) (TupleInt_append (LoopNestAPI_get_dims lna) dim) :subsume :ruleset array_api_ruleset)
(constructor OptionalLoopNestAPI_unwrap (OptionalLoopNestAPI) LoopNestAPI)
(rewrite (OptionalLoopNestAPI_unwrap (OptionalLoopNestAPI___init__ lna)) lna :ruleset array_api_ruleset)
(constructor axis-TupleInt_i-Int__Boolean___invert____TupleInt_contains_axis_i__ (TupleInt Int) Boolean)
(rewrite (axis-TupleInt_i-Int__Boolean___invert____TupleInt_contains_axis_i__ axis i) (Boolean___invert__ (TupleInt_contains axis i)) :subsume :ruleset array_api_ruleset)
(constructor dims-TupleInt_i-Int__TupleInt___getitem___dims_i_ (TupleInt Int) Int)
(rewrite (dims-TupleInt_i-Int__TupleInt___getitem___dims_i_ dims i) (TupleInt___getitem__ dims i) :subsume :ruleset array_api_ruleset)
(constructor axis-TupleInt_i-Int__TupleInt_contains_axis_i_ (TupleInt Int) Boolean)
(rewrite (axis-TupleInt_i-Int__TupleInt_contains_axis_i_ axis i) (TupleInt_contains axis i) :subsume :ruleset array_api_ruleset)
(sort ShapeAPI)
(constructor ShapeAPI_deselect (ShapeAPI TupleInt) ShapeAPI)
(constructor ShapeAPI___init__ (TupleInt) ShapeAPI)
(rewrite (ShapeAPI_deselect (ShapeAPI___init__ dims) axis) (ShapeAPI___init__ (TupleInt_map (TupleInt_filter (TupleInt_range (TupleInt_length dims)) (unstable-fn "axis-TupleInt_i-Int__Boolean___invert____TupleInt_contains_axis_i__" axis)) (unstable-fn "dims-TupleInt_i-Int__TupleInt___getitem___dims_i_" dims))) :subsume :ruleset array_api_ruleset)
(constructor ShapeAPI_select (ShapeAPI TupleInt) ShapeAPI)
(rewrite (ShapeAPI_select (ShapeAPI___init__ dims) axis) (ShapeAPI___init__ (TupleInt_map (TupleInt_filter (TupleInt_range (TupleInt_length dims)) (unstable-fn "axis-TupleInt_i-Int__TupleInt_contains_axis_i_" axis)) (unstable-fn "dims-TupleInt_i-Int__TupleInt___getitem___dims_i_" dims))) :subsume :ruleset array_api_ruleset)
(constructor ShapeAPI_to_tuple (ShapeAPI) TupleInt)
(rewrite (ShapeAPI_to_tuple (ShapeAPI___init__ dims)) dims :subsume :ruleset array_api_ruleset)
(constructor NDArray_size (NDArray) Int)
(constructor NDArray_shape (NDArray) TupleInt)
(rewrite (NDArray_size x) (TupleInt_foldl (NDArray_shape x) (unstable-fn "Int___mul__") (Int___init__ 1)) :ruleset array_api_ruleset)
(constructor unique_values (NDArray) NDArray)
(constructor NDArray_vector (TupleValue) NDArray)
(constructor possible_values (Value) TupleValue)
(constructor NDArray_index (NDArray TupleInt) Value)
(constructor ALL_INDICES () TupleInt)
(rewrite (unique_values a) (NDArray_vector (possible_values (NDArray_index a (ALL_INDICES )))) :ruleset array_api_ruleset)
(constructor Value_isfinite (Value) Boolean)
(rewrite (Value_isfinite (Value_int i)) (Boolean___init__ true) :ruleset array_api_ruleset)
(constructor Value_bool (Boolean) Value)
(rewrite (Value_isfinite (Value_bool b)) (Boolean___init__ true) :ruleset array_api_ruleset)
(sort Float)
(constructor Value_float (Float) Value)
(constructor Float___init__ (f64) Float :cost 3)
(rewrite (Value_isfinite (Value_float (Float___init__ f))) (Boolean___init__ true) :when ((!= f NaN)) :ruleset array_api_ruleset)
(constructor isfinite (NDArray) NDArray)
(sort OptionalIntOrTuple)
(constructor sum (NDArray OptionalIntOrTuple) NDArray)
(constructor OptionalIntOrTuple_none () OptionalIntOrTuple)
(rewrite (isfinite (sum arr (OptionalIntOrTuple_none ))) (NDArray_scalar (Value_bool (Value_isfinite (NDArray_index arr (ALL_INDICES ))))) :ruleset array_api_ruleset)
(constructor assume_value_one_of (NDArray TupleValue) NDArray)
(rewrite (NDArray_shape (assume_value_one_of x vs)) (NDArray_shape x) :ruleset array_api_ruleset)
(constructor NDArray_dtype (NDArray) DType)
(rewrite (NDArray_dtype (assume_value_one_of x vs)) (NDArray_dtype x) :ruleset array_api_ruleset)
(rule ((= v (NDArray_index (assume_value_one_of x vs) idx)))
      ((union v (NDArray_index x idx))
       (union (possible_values v) vs))
        :ruleset array_api_ruleset )
(constructor assume_isfinite (NDArray) NDArray)
(rewrite (NDArray_shape (assume_isfinite x)) (NDArray_shape x) :ruleset array_api_ruleset)
(rewrite (NDArray_dtype (assume_isfinite x)) (NDArray_dtype x) :ruleset array_api_ruleset)
(rewrite (NDArray_index (assume_isfinite x) ti) (NDArray_index x ti) :ruleset array_api_ruleset)
(rewrite (Value_isfinite (NDArray_index (assume_isfinite x) ti)) (Boolean___init__ true) :ruleset array_api_ruleset)
(constructor assume_shape (NDArray TupleInt) NDArray)
(rewrite (NDArray_shape (assume_shape x shape)) shape :ruleset array_api_ruleset)
(rewrite (NDArray_dtype (assume_shape x shape)) (NDArray_dtype x) :ruleset array_api_ruleset)
(rewrite (NDArray_index (assume_shape x shape) idx) (NDArray_index x idx) :ruleset array_api_ruleset)
(constructor assume_dtype (NDArray DType) NDArray)
(rewrite (NDArray_dtype (assume_dtype x dtype)) dtype :ruleset array_api_ruleset)
(rewrite (NDArray_shape (assume_dtype x dtype)) (NDArray_shape x) :ruleset array_api_ruleset)
(rewrite (NDArray_index (assume_dtype x dtype) idx) (NDArray_index x idx) :ruleset array_api_ruleset)
(sort IndexKey)
(constructor NDArray___getitem__ (NDArray IndexKey) NDArray)
(constructor IndexKey_int (Int) IndexKey)
(rewrite (NDArray___getitem__ x (IndexKey_int i)) (NDArray_scalar (NDArray_index x (TupleInt_single i))) :ruleset array_api_ruleset)
(sort OptionalBool)
(constructor reshape (NDArray TupleInt OptionalBool) NDArray)
(rule ((= __a (reshape x shape copy)))
      ((NDArray_shape x)
       (TupleInt_length (NDArray_shape x)))
        :ruleset array_api_ruleset )
(rule ((reshape x shape copy))
      ((TupleInt_length shape)
       (TupleInt___getitem__ shape (Int___init__ 0)))
        :ruleset array_api_ruleset )
(rewrite (reshape x shape copy) x :when ((= (TupleInt_length (NDArray_shape x)) (Int___init__ 1)) (= (TupleInt_length shape) (Int___init__ 1)) (= (TupleInt___getitem__ shape (Int___init__ 0)) (Int___init__ -1))) :ruleset array_api_ruleset)
(rewrite (NDArray_shape (NDArray_vector vs)) (TupleInt_single (TupleValue_length vs)) :ruleset array_api_ruleset)
(rewrite (NDArray_dtype (NDArray_vector vs)) (Value_dtype (TupleValue___getitem__ vs (Int___init__ 0))) :ruleset array_api_ruleset)
(rewrite (NDArray_index (NDArray_vector vs) ti) (TupleValue___getitem__ vs (TupleInt___getitem__ ti (Int___init__ 0))) :ruleset array_api_ruleset)
(rewrite (NDArray_shape (NDArray_scalar v)) (TupleInt_EMPTY ) :ruleset array_api_ruleset)
(rewrite (NDArray_dtype (NDArray_scalar v)) (Value_dtype v) :ruleset array_api_ruleset)
(rewrite (NDArray_index (NDArray_scalar v) (TupleInt_EMPTY )) v :ruleset array_api_ruleset)
(constructor any (NDArray) NDArray)
(constructor Value_to_truthy_value (Value) Value)
(rewrite (any x) (NDArray_scalar (Value_bool (TupleValue_contains (possible_values (Value_to_truthy_value (NDArray_index x (ALL_INDICES )))) (Value_bool (Boolean___init__ true))))) :ruleset array_api_ruleset)
(constructor NDArray___lt__ (NDArray NDArray) NDArray)
(constructor Value___lt__ (Value Value) Value)
(constructor broadcast_index (TupleInt TupleInt TupleInt) TupleInt)
(constructor broadcast_shapes (TupleInt TupleInt) TupleInt)
(rewrite (NDArray_index (NDArray___lt__ x y) idx) (Value___lt__ (NDArray_index x (broadcast_index (NDArray_shape x) (broadcast_shapes (NDArray_shape x) (NDArray_shape y)) idx)) (NDArray_index y (broadcast_index (NDArray_shape y) (broadcast_shapes (NDArray_shape x) (NDArray_shape y)) idx))) :ruleset array_api_ruleset)
(constructor NDArray___truediv__ (NDArray NDArray) NDArray)
(constructor Value___truediv__ (Value Value) Value)
(rewrite (NDArray_index (NDArray___truediv__ x y) idx) (Value___truediv__ (NDArray_index x (broadcast_index (NDArray_shape x) (broadcast_shapes (NDArray_shape x) (NDArray_shape y)) idx)) (NDArray_index y (broadcast_index (NDArray_shape y) (broadcast_shapes (NDArray_shape x) (NDArray_shape y)) idx))) :ruleset array_api_ruleset)
(rewrite (NDArray_index (NDArray_scalar v) idx) v :ruleset array_api_ruleset)
(constructor astype (NDArray DType) NDArray)
(constructor Value_astype (Value DType) Value)
(rewrite (NDArray_index (astype x dtype) idx) (Value_astype (NDArray_index x idx) dtype) :ruleset array_api_ruleset)
(relation greater_zero (Value))
(constructor unique_counts (NDArray) TupleNDArray)
(rule ((= v (NDArray_index (TupleNDArray___getitem__ (unique_counts x) (Int___init__ 1)) idx)))
      ((greater_zero v))
        :ruleset array_api_ruleset )
(rule ((greater_zero v)
       (= v1 (Value_astype v dtype)))
      ((greater_zero v1))
        :ruleset array_api_ruleset )
(rule ((= v (Value_float (Float___init__ f)))
       (> f 0.0))
      ((greater_zero v))
        :ruleset array_api_ruleset )
(rule ((= v (Value_int (Int___init__ i)))
       (> i 0))
      ((greater_zero v))
        :ruleset array_api_ruleset )
(rule ((greater_zero v)
       (greater_zero v1)
       (= v2 (Value___truediv__ v v1)))
      ((greater_zero v2))
        :ruleset array_api_ruleset )
(rule ((greater_zero v)
       (= v1 (Value___lt__ v (Value_int (Int___init__ 0)))))
      ((union v1 (Value_bool (Boolean___init__ false))))
        :ruleset array_api_ruleset )
(constructor TupleValue_append (TupleValue Value) TupleValue)
(constructor TupleValue_EMPTY () TupleValue)
(rewrite (possible_values (Value_bool b)) (TupleValue_append (TupleValue_EMPTY ) (Value_bool b)) :ruleset array_api_ruleset)
(rule ((= v1 (Value_astype v dtype))
       (greater_zero v))
      ((greater_zero v1))
        :ruleset array_api_ruleset )
(constructor svd (NDArray Boolean) TupleNDArray)
(rewrite (svd x full_matrices) (TupleNDArray___init__ (Int___init__ 3) (unstable-fn "TupleNDArray___getitem__" (svd x full_matrices))) :ruleset array_api_ruleset)
(constructor unique_inverse (NDArray) TupleNDArray)
(rewrite (unique_inverse x) (TupleNDArray___init__ (Int___init__ 2) (unstable-fn "TupleNDArray___getitem__" (unique_inverse x))) :ruleset array_api_ruleset)
(rewrite (TupleNDArray___getitem__ (unique_inverse x) (Int___init__ 0)) (unique_values x) :ruleset array_api_ruleset)
(constructor ndarray-abs (NDArray) NDArray)
(constructor Float_abs (Float) Float)
(rewrite (ndarray-abs (NDArray_scalar (Value_float f))) (NDArray_scalar (Value_float (Float_abs f))) :ruleset array_api_ruleset)
(rewrite (unique_counts x) (TupleNDArray___init__ (Int___init__ 2) (unstable-fn "TupleNDArray___getitem__" (unique_counts x))) :ruleset array_api_ruleset)
(rewrite (sum (TupleNDArray___getitem__ (unique_counts x) (Int___init__ 1)) (OptionalIntOrTuple_none )) (NDArray_scalar (Value_int (NDArray_size x))) :ruleset array_api_ruleset)
(rewrite (sum (astype (TupleNDArray___getitem__ (unique_counts x) (Int___init__ 1)) dtype) (OptionalIntOrTuple_none )) (astype (NDArray_scalar (Value_int (NDArray_size x))) dtype) :ruleset array_api_ruleset)
(rewrite (NDArray_dtype (astype x dtype)) dtype :ruleset array_api_ruleset)
(constructor DType_float64 () DType)
(rewrite (astype (NDArray_scalar (Value_int (Int___init__ i))) (DType_float64 )) (NDArray_scalar (Value_float (Float___init__ (to-f64 i)))) :ruleset array_api_ruleset)
(sort OptionalInt)
(constructor concat (TupleNDArray OptionalInt) NDArray)
(constructor TupleNDArray_append (TupleNDArray NDArray) TupleNDArray)
(constructor TupleNDArray_EMPTY () TupleNDArray)
(constructor OptionalInt_none () OptionalInt)
(rewrite (concat (TupleNDArray_append (TupleNDArray_EMPTY ) x) (OptionalInt_none )) x :ruleset array_api_ruleset)
(rewrite (unique_values (unique_values x)) (unique_values x) :ruleset array_api_ruleset)
(rewrite (sum (NDArray___truediv__ x (NDArray_scalar v)) (OptionalIntOrTuple_none )) (NDArray___truediv__ (sum x (OptionalIntOrTuple_none )) (NDArray_scalar v)) :ruleset array_api_ruleset)
(constructor NDArray_ndim (NDArray) Int)
(sort OptionalDType)
(sort OptionalDevice)
(constructor asarray (NDArray OptionalDType OptionalBool OptionalDevice) NDArray)
(constructor OptionalDevice_none () OptionalDevice)
(rewrite (NDArray_ndim (asarray a d ob (OptionalDevice_none ))) (NDArray_ndim a) :ruleset array_api_ruleset)
(constructor OptionalDType_none () OptionalDType)
(constructor OptionalBool_none () OptionalBool)
(rewrite (asarray a (OptionalDType_none ) (OptionalBool_none ) (OptionalDevice_none )) a :ruleset array_api_ruleset)
(constructor check_index (Int Int) Int)
(constructor Boolean___and__ (Boolean Boolean) Boolean)
(constructor Int___ge__ (Int Int) Boolean)
(constructor Int_NEVER () Int)
(rewrite (check_index length idx) (Int_if_ (Boolean___and__ (Int___ge__ idx (Int___init__ 0)) (Int___lt__ idx length)) idx (Int_NEVER )) :ruleset array_api_ruleset)
(sort Vec_NDArray (Vec NDArray))
(function TupleNDArray_to_vec (TupleNDArray) Vec_NDArray :no-merge)
(constructor TupleNDArray_from_vec (Vec_NDArray) TupleNDArray)
(rule ((= tv (TupleNDArray_from_vec vs)))
      ((set (TupleNDArray_to_vec tv) vs))
        :ruleset array_api_ruleset )
(rewrite (TupleNDArray_length (TupleNDArray___init__ length idx_fn)) length :ruleset array_api_ruleset)
(rewrite (TupleNDArray___getitem__ (TupleNDArray___init__ length idx_fn) idx) (unstable-app idx_fn (check_index idx length)) :ruleset array_api_ruleset)
(rewrite (TupleNDArray_length (TupleNDArray_EMPTY )) (Int___init__ 0) :ruleset array_api_ruleset)
(constructor NDArray_NEVER () NDArray)
(rewrite (TupleNDArray___getitem__ (TupleNDArray_EMPTY ) idx) (NDArray_NEVER ) :ruleset array_api_ruleset)
(rewrite (TupleNDArray_length (TupleNDArray_append tv v)) (Int___add__ (TupleNDArray_length tv) (Int___init__ 1)) :ruleset array_api_ruleset)
(rewrite (TupleNDArray___getitem__ (TupleNDArray_append tv v) idx) (NDArray_if_ (Int___eq__ idx (TupleNDArray_length tv)) v (TupleNDArray___getitem__ tv idx)) :ruleset array_api_ruleset)
(rewrite (TupleNDArray___init__ (Int___init__ 0) idx_fn) (TupleNDArray_EMPTY ) :subsume :ruleset array_api_ruleset)
(rewrite (TupleNDArray___init__ (Int___init__ k) idx_fn) (TupleNDArray_append (TupleNDArray___init__ (Int___init__ (- k 1)) idx_fn) (unstable-app idx_fn (Int___init__ (- k 1)))) :subsume :when ((> k 0)) :ruleset array_api_ruleset)
(rewrite (TupleNDArray_EMPTY ) (TupleNDArray_from_vec (vec-of )) :ruleset array_api_ruleset)
(rewrite (TupleNDArray_append (TupleNDArray_from_vec vs) v) (TupleNDArray_from_vec (vec-append vs (vec-of v))) :ruleset array_api_ruleset)
(rule ((= (TupleNDArray_append tv v) (TupleNDArray_append tv1 v1)))
      ((union tv tv1)
       (union v v1))
        :ruleset array_api_ruleset )
(rewrite (NDArray_shape (NDArray___init__ shape dtype idx_fn)) shape :ruleset array_api_ruleset)
(rewrite (NDArray_dtype (NDArray___init__ shape dtype idx_fn)) dtype :ruleset array_api_ruleset)
(rewrite (NDArray_index (NDArray___init__ shape dtype idx_fn) idx) (unstable-app idx_fn idx) :subsume :ruleset array_api_ruleset)
(rewrite (NDArray_ndim x) (TupleInt_length (NDArray_shape x)) :ruleset array_api_ruleset)
(constructor NDArray_to_value (NDArray) Value)
(rewrite (NDArray_to_value x) (NDArray_index x (TupleInt_EMPTY )) :ruleset array_api_ruleset)
(constructor NDArray_to_values (NDArray) TupleValue)
(rewrite (NDArray_to_values (NDArray_vector tv)) tv :ruleset array_api_ruleset)
(rewrite (NDArray___truediv__ (NDArray_scalar (Value_float f)) (NDArray_scalar (Value_float f))) (NDArray_scalar (Value_float (Float___init__ 1.0))) :ruleset array_api_ruleset)
(constructor NDArray___sub__ (NDArray NDArray) NDArray)
(rewrite (NDArray___sub__ (NDArray_scalar (Value_float f)) (NDArray_scalar (Value_float f))) (NDArray_scalar (Value_float (Float___init__ 0.0))) :ruleset array_api_ruleset)
(constructor NDArray___gt__ (NDArray NDArray) NDArray)
(rewrite (NDArray___gt__ (NDArray_scalar (Value_float (Float___init__ fi1))) (NDArray_scalar (Value_float (Float___init__ fi2)))) (NDArray_scalar (Value_bool (Boolean___init__ true))) :when ((> fi1 fi2)) :ruleset array_api_ruleset)
(rewrite (NDArray___gt__ (NDArray_scalar (Value_float (Float___init__ fi1))) (NDArray_scalar (Value_float (Float___init__ fi2)))) (NDArray_scalar (Value_bool (Boolean___init__ false))) :when ((<= fi1 fi2)) :ruleset array_api_ruleset)
(constructor NDArray_T (NDArray) NDArray)
(rewrite (NDArray_T (NDArray_T x)) x :ruleset array_api_ruleset)
(rewrite (NDArray_if_ (Boolean___init__ true) x x1) x :ruleset array_api_ruleset)
(rewrite (NDArray_if_ (Boolean___init__ false) x x1) x1 :ruleset array_api_ruleset)
(rewrite (TupleValue_length (TupleValue___init__ length idx_fn)) length :ruleset array_api_ruleset)
(rewrite (TupleValue___getitem__ (TupleValue___init__ length idx_fn) idx) (unstable-app idx_fn (check_index idx length)) :ruleset array_api_ruleset)
(rewrite (TupleValue_length (TupleValue_EMPTY )) (Int___init__ 0) :ruleset array_api_ruleset)
(constructor Value_NEVER () Value)
(rewrite (TupleValue___getitem__ (TupleValue_EMPTY ) idx) (Value_NEVER ) :ruleset array_api_ruleset)
(rewrite (TupleValue_length (TupleValue_append tv v)) (Int___add__ (TupleValue_length tv) (Int___init__ 1)) :ruleset array_api_ruleset)
(rewrite (TupleValue___getitem__ (TupleValue_append tv v) idx) (Value_if_ (Int___eq__ idx (TupleValue_length tv)) v (TupleValue___getitem__ tv idx)) :ruleset array_api_ruleset)
(rewrite (TupleValue___init__ (Int___init__ 0) idx_fn) (TupleValue_EMPTY ) :subsume :ruleset array_api_ruleset)
(rewrite (TupleValue___init__ (Int___init__ k) idx_fn) (TupleValue_append (TupleValue___init__ (Int___init__ (- k 1)) idx_fn) (unstable-app idx_fn (Int___init__ (- k 1)))) :subsume :when ((> k 0)) :ruleset array_api_ruleset)
(sort Vec_Value (Vec Value))
(constructor TupleValue_from_vec (Vec_Value) TupleValue)
(rewrite (TupleValue_EMPTY ) (TupleValue_from_vec (vec-of )) :ruleset array_api_ruleset)
(rewrite (TupleValue_append (TupleValue_from_vec vs) v) (TupleValue_from_vec (vec-append vs (vec-of v))) :ruleset array_api_ruleset)
(rewrite (TupleValue_foldl_boolean (TupleValue_EMPTY ) bool_f b) b :subsume :ruleset array_api_ruleset)
(rewrite (TupleValue_foldl_boolean (TupleValue_append tv v) bool_f b) (unstable-app bool_f (TupleValue_foldl_boolean tv bool_f b) v) :subsume :ruleset array_api_ruleset)
(rule ((= (TupleValue_append tv v) (TupleValue_append tv1 v1)))
      ((union tv tv1)
       (union v v1))
        :ruleset array_api_ruleset )
(constructor DType_int64 () DType)
(rewrite (Value_dtype (Value_int i)) (DType_int64 ) :ruleset array_api_ruleset)
(rewrite (Value_dtype (Value_float f)) (DType_float64 ) :ruleset array_api_ruleset)
(constructor DType_bool () DType)
(rewrite (Value_dtype (Value_bool b)) (DType_bool ) :ruleset array_api_ruleset)
(constructor Value_to_bool (Value) Boolean)
(rewrite (Value_to_bool (Value_bool b)) b :ruleset array_api_ruleset)
(constructor Value_to_int (Value) Int)
(rewrite (Value_to_int (Value_int i)) i :ruleset array_api_ruleset)
(rewrite (Value_to_truthy_value (Value_bool b)) (Value_bool b) :ruleset array_api_ruleset)
(constructor Value_conj (Value) Value)
(rewrite (Value_conj (Value_float f)) (Value_float f) :ruleset array_api_ruleset)
(constructor Value_real (Value) Value)
(rewrite (Value_real (Value_float f)) (Value_float f) :ruleset array_api_ruleset)
(rewrite (Value_real (Value_int i)) (Value_int i) :ruleset array_api_ruleset)
(rewrite (Value_conj (Value_int i)) (Value_int i) :ruleset array_api_ruleset)
(constructor Value_sqrt (Value) Value)
(constructor Float___pow__ (Float Float) Float)
(rewrite (Value_sqrt (Value_float f)) (Value_float (Float___pow__ f (Float___init__ 0.5))) :ruleset array_api_ruleset)
(constructor Value___add__ (Value Value) Value)
(constructor Float_rational (BigRat) Float :cost 2)
(rewrite (Value___add__ (Value_float (Float_rational (bigrat (bigint 0) (bigint 1)))) v) v :ruleset array_api_ruleset)
(rewrite (Value_if_ (Boolean___init__ true) v v1) v :ruleset array_api_ruleset)
(rewrite (Value_if_ (Boolean___init__ false) v v1) v1 :ruleset array_api_ruleset)
(rewrite (Value___eq__ (Value_int i) (Value_int i1)) (Int___eq__ i i1) :ruleset array_api_ruleset)
(constructor Float___eq__ (Float Float) Boolean)
(rewrite (Value___eq__ (Value_float f) (Value_float f1)) (Float___eq__ f f1) :ruleset array_api_ruleset)
(constructor Boolean___eq__ (Boolean Boolean) Boolean)
(rewrite (Value___eq__ (Value_bool b) (Value_bool b1)) (Boolean___eq__ b b1) :ruleset array_api_ruleset)
(sort IsDtypeKind)
(constructor isdtype (DType IsDtypeKind) Boolean)
(constructor DType_float32 () DType)
(constructor IsDtypeKind_string (String) IsDtypeKind)
(rewrite (isdtype (DType_float32 ) (IsDtypeKind_string "integral")) (Boolean___init__ false) :ruleset array_api_ruleset)
(rewrite (isdtype (DType_float64 ) (IsDtypeKind_string "integral")) (Boolean___init__ false) :ruleset array_api_ruleset)
(constructor DType_object () DType)
(rewrite (isdtype (DType_object ) (IsDtypeKind_string "integral")) (Boolean___init__ false) :ruleset array_api_ruleset)
(rewrite (isdtype (DType_int64 ) (IsDtypeKind_string "integral")) (Boolean___init__ true) :ruleset array_api_ruleset)
(constructor DType_int32 () DType)
(rewrite (isdtype (DType_int32 ) (IsDtypeKind_string "integral")) (Boolean___init__ true) :ruleset array_api_ruleset)
(rewrite (isdtype (DType_float32 ) (IsDtypeKind_string "real floating")) (Boolean___init__ true) :ruleset array_api_ruleset)
(rewrite (isdtype (DType_float64 ) (IsDtypeKind_string "real floating")) (Boolean___init__ true) :ruleset array_api_ruleset)
(rewrite (isdtype (DType_object ) (IsDtypeKind_string "real floating")) (Boolean___init__ false) :ruleset array_api_ruleset)
(rewrite (isdtype (DType_int64 ) (IsDtypeKind_string "real floating")) (Boolean___init__ false) :ruleset array_api_ruleset)
(rewrite (isdtype (DType_int32 ) (IsDtypeKind_string "real floating")) (Boolean___init__ false) :ruleset array_api_ruleset)
(rewrite (isdtype (DType_float32 ) (IsDtypeKind_string "complex floating")) (Boolean___init__ false) :ruleset array_api_ruleset)
(rewrite (isdtype (DType_float64 ) (IsDtypeKind_string "complex floating")) (Boolean___init__ false) :ruleset array_api_ruleset)
(rewrite (isdtype (DType_object ) (IsDtypeKind_string "complex floating")) (Boolean___init__ false) :ruleset array_api_ruleset)
(rewrite (isdtype (DType_int64 ) (IsDtypeKind_string "complex floating")) (Boolean___init__ false) :ruleset array_api_ruleset)
(rewrite (isdtype (DType_int32 ) (IsDtypeKind_string "complex floating")) (Boolean___init__ false) :ruleset array_api_ruleset)
(constructor IsDtypeKind_NULL () IsDtypeKind)
(rewrite (isdtype d (IsDtypeKind_NULL )) (Boolean___init__ false) :ruleset array_api_ruleset)
(constructor IsDtypeKind_dtype (DType) IsDtypeKind)
(rewrite (isdtype d (IsDtypeKind_dtype d)) (Boolean___init__ true) :ruleset array_api_ruleset)
(constructor IsDtypeKind___or__ (IsDtypeKind IsDtypeKind) IsDtypeKind :cost 10)
(rewrite (isdtype d (IsDtypeKind___or__ k1 k2)) (Boolean___or__ (isdtype d k1) (isdtype d k2)) :ruleset array_api_ruleset)
(rewrite (IsDtypeKind___or__ k1 (IsDtypeKind_NULL )) k1 :ruleset array_api_ruleset)
(constructor DType___eq__ (DType DType) Boolean)
(rewrite (DType___eq__ (DType_float64 ) (DType_float64 )) (Boolean___init__ true) :ruleset array_api_ruleset)
(rewrite (DType___eq__ (DType_float64 ) (DType_float32 )) (Boolean___init__ false) :ruleset array_api_ruleset)
(rewrite (DType___eq__ (DType_float64 ) (DType_int32 )) (Boolean___init__ false) :ruleset array_api_ruleset)
(rewrite (DType___eq__ (DType_float64 ) (DType_int64 )) (Boolean___init__ false) :ruleset array_api_ruleset)
(rewrite (DType___eq__ (DType_float64 ) (DType_object )) (Boolean___init__ false) :ruleset array_api_ruleset)
(rewrite (DType___eq__ (DType_float32 ) (DType_float64 )) (Boolean___init__ false) :ruleset array_api_ruleset)
(rewrite (DType___eq__ (DType_float32 ) (DType_float32 )) (Boolean___init__ true) :ruleset array_api_ruleset)
(rewrite (DType___eq__ (DType_float32 ) (DType_int32 )) (Boolean___init__ false) :ruleset array_api_ruleset)
(rewrite (DType___eq__ (DType_float32 ) (DType_int64 )) (Boolean___init__ false) :ruleset array_api_ruleset)
(rewrite (DType___eq__ (DType_float32 ) (DType_object )) (Boolean___init__ false) :ruleset array_api_ruleset)
(rewrite (DType___eq__ (DType_int32 ) (DType_float64 )) (Boolean___init__ false) :ruleset array_api_ruleset)
(rewrite (DType___eq__ (DType_int32 ) (DType_float32 )) (Boolean___init__ false) :ruleset array_api_ruleset)
(rewrite (DType___eq__ (DType_int32 ) (DType_int32 )) (Boolean___init__ true) :ruleset array_api_ruleset)
(rewrite (DType___eq__ (DType_int32 ) (DType_int64 )) (Boolean___init__ false) :ruleset array_api_ruleset)
(rewrite (DType___eq__ (DType_int32 ) (DType_object )) (Boolean___init__ false) :ruleset array_api_ruleset)
(rewrite (DType___eq__ (DType_int64 ) (DType_float64 )) (Boolean___init__ false) :ruleset array_api_ruleset)
(rewrite (DType___eq__ (DType_int64 ) (DType_float32 )) (Boolean___init__ false) :ruleset array_api_ruleset)
(rewrite (DType___eq__ (DType_int64 ) (DType_int32 )) (Boolean___init__ false) :ruleset array_api_ruleset)
(rewrite (DType___eq__ (DType_int64 ) (DType_int64 )) (Boolean___init__ true) :ruleset array_api_ruleset)
(rewrite (DType___eq__ (DType_int64 ) (DType_object )) (Boolean___init__ false) :ruleset array_api_ruleset)
(rewrite (DType___eq__ (DType_object ) (DType_float64 )) (Boolean___init__ false) :ruleset array_api_ruleset)
(rewrite (DType___eq__ (DType_object ) (DType_float32 )) (Boolean___init__ false) :ruleset array_api_ruleset)
(rewrite (DType___eq__ (DType_object ) (DType_int32 )) (Boolean___init__ false) :ruleset array_api_ruleset)
(rewrite (DType___eq__ (DType_object ) (DType_int64 )) (Boolean___init__ false) :ruleset array_api_ruleset)
(rewrite (DType___eq__ (DType_object ) (DType_object )) (Boolean___init__ true) :ruleset array_api_ruleset)
(function TupleTupleInt_to_vec (TupleTupleInt) Vec_TupleInt :no-merge)
(rule ((= tti (TupleTupleInt_from_vec vs)))
      ((set (TupleTupleInt_to_vec tti) vs))
        :ruleset array_api_ruleset )
(rewrite (TupleTupleInt_length (TupleTupleInt___init__ length idx_fn)) length :ruleset array_api_ruleset)
(rewrite (TupleTupleInt___getitem__ (TupleTupleInt___init__ length idx_fn) idx) (unstable-app idx_fn (check_index idx length)) :ruleset array_api_ruleset)
(constructor TupleTupleInt_EMPTY () TupleTupleInt)
(rewrite (TupleTupleInt_length (TupleTupleInt_EMPTY )) (Int___init__ 0) :ruleset array_api_ruleset)
(constructor TupleInt_NEVER () TupleInt)
(rewrite (TupleTupleInt___getitem__ (TupleTupleInt_EMPTY ) idx) (TupleInt_NEVER ) :ruleset array_api_ruleset)
(constructor TupleTupleInt_append (TupleTupleInt TupleInt) TupleTupleInt)
(rewrite (TupleTupleInt_length (TupleTupleInt_append tti ti)) (Int___add__ (TupleTupleInt_length tti) (Int___init__ 1)) :ruleset array_api_ruleset)
(rewrite (TupleTupleInt___getitem__ (TupleTupleInt_append tti ti) idx) (TupleInt_if_ (Int___eq__ idx (TupleTupleInt_length tti)) ti (TupleTupleInt___getitem__ tti idx)) :ruleset array_api_ruleset)
(rewrite (TupleTupleInt___init__ (Int___init__ 0) idx_fn) (TupleTupleInt_EMPTY ) :subsume :ruleset array_api_ruleset)
(rewrite (TupleTupleInt___init__ (Int___init__ k) idx_fn) (TupleTupleInt_append (TupleTupleInt___init__ (Int___init__ (- k 1)) idx_fn) (unstable-app idx_fn (Int___init__ (- k 1)))) :subsume :when ((> k 0)) :ruleset array_api_ruleset)
(rewrite (TupleTupleInt_EMPTY ) (TupleTupleInt_from_vec (vec-of )) :ruleset array_api_ruleset)
(rewrite (TupleTupleInt_append (TupleTupleInt_from_vec vs) ti) (TupleTupleInt_from_vec (vec-append vs (vec-of ti))) :ruleset array_api_ruleset)
(sort UnstableFn_Value_Value_TupleInt (UnstableFn (Value TupleInt) Value))
(constructor TupleTupleInt_foldl_value (TupleTupleInt UnstableFn_Value_Value_TupleInt Value) Value)
(rewrite (TupleTupleInt_foldl_value (TupleTupleInt_EMPTY ) f i) i :subsume :ruleset array_api_ruleset)
(rewrite (TupleTupleInt_foldl_value (TupleTupleInt_append tti ti) f i) (unstable-app f (TupleTupleInt_foldl_value tti f i) ti) :subsume :ruleset array_api_ruleset)
(rule ((= (TupleTupleInt_append tti ti) (TupleTupleInt_append tti1 ti1)))
      ((union tti tti1)
       (union ti ti1))
        :ruleset array_api_ruleset )
(function TupleInt_to_vec (TupleInt) Vec_Int :no-merge)
(rule ((= ti (TupleInt_from_vec vs)))
      ((set (TupleInt_to_vec ti) vs))
        :ruleset array_api_ruleset )
(rewrite (TupleInt_length (TupleInt___init__ i idx_fn)) i :ruleset array_api_ruleset)
(rewrite (TupleInt___getitem__ (TupleInt___init__ i idx_fn) i2) (unstable-app idx_fn (check_index i i2)) :ruleset array_api_ruleset)
(rewrite (TupleInt_length (TupleInt_EMPTY )) (Int___init__ 0) :ruleset array_api_ruleset)
(rewrite (TupleInt___getitem__ (TupleInt_EMPTY ) i) (Int_NEVER ) :ruleset array_api_ruleset)
(rewrite (TupleInt_length (TupleInt_append ti i)) (Int___add__ (TupleInt_length ti) (Int___init__ 1)) :ruleset array_api_ruleset)
(rewrite (TupleInt___getitem__ (TupleInt_append ti i) i2) (Int_if_ (Int___eq__ i2 (TupleInt_length ti)) i (TupleInt___getitem__ ti i2)) :ruleset array_api_ruleset)
(rewrite (TupleInt___init__ (Int___init__ 0) idx_fn) (TupleInt_EMPTY ) :subsume :ruleset array_api_ruleset)
(rewrite (TupleInt___init__ (Int___init__ k) idx_fn) (TupleInt_append (TupleInt___init__ (Int___init__ (- k 1)) idx_fn) (unstable-app idx_fn (Int___init__ (- k 1)))) :subsume :when ((> k 0)) :ruleset array_api_ruleset)
(rewrite (TupleInt_EMPTY ) (TupleInt_from_vec (vec-of )) :ruleset array_api_ruleset)
(rewrite (TupleInt_append (TupleInt_from_vec vs) i) (TupleInt_from_vec (vec-append vs (vec-of i))) :ruleset array_api_ruleset)
(rewrite (TupleInt_foldl (TupleInt_EMPTY ) f i) i :subsume :ruleset array_api_ruleset)
(rewrite (TupleInt_foldl (TupleInt_append ti i2) f i) (unstable-app f (TupleInt_foldl ti f i) i2) :subsume :ruleset array_api_ruleset)
(rewrite (TupleInt_foldl_boolean (TupleInt_EMPTY ) bool_f b) b :subsume :ruleset array_api_ruleset)
(rewrite (TupleInt_foldl_boolean (TupleInt_append ti i2) bool_f b) (unstable-app bool_f (TupleInt_foldl_boolean ti bool_f b) i2) :subsume :ruleset array_api_ruleset)
(rewrite (TupleInt_foldl_tuple_int (TupleInt_EMPTY ) tuple_int_f ti) ti :subsume :ruleset array_api_ruleset)
(rewrite (TupleInt_foldl_tuple_int (TupleInt_append ti i2) tuple_int_f ti2) (unstable-app tuple_int_f (TupleInt_foldl_tuple_int ti tuple_int_f ti2) i2) :subsume :ruleset array_api_ruleset)
(rewrite (TupleInt_if_ (Boolean___init__ true) ti ti2) ti :subsume :ruleset array_api_ruleset)
(rewrite (TupleInt_if_ (Boolean___init__ false) ti ti2) ti2 :subsume :ruleset array_api_ruleset)
(rule ((= (TupleInt_append ti i) (TupleInt_append ti2 i2)))
      ((union ti ti2)
       (union i i2))
        :ruleset array_api_ruleset )
(function Float_to_f64 (Float) f64 :no-merge)
(rule ((= fl (Float___init__ f)))
      ((set (Float_to_f64 fl) f))
        :ruleset array_api_ruleset )
(rewrite (Float_abs (Float___init__ f)) (Float___init__ f) :when ((>= f 0.0)) :ruleset array_api_ruleset)
(rewrite (Float_abs (Float___init__ f)) (Float___init__ (neg f)) :when ((< f 0.0)) :ruleset array_api_ruleset)
(rewrite (Float___init__ f) (Float_rational (bigrat (bigint (to-i64 f)) (bigint 1))) :when ((= (to-f64 (to-i64 f)) f)) :ruleset array_api_ruleset)
(constructor Float_from_int (Int) Float)
(rewrite (Float_from_int (Int___init__ i)) (Float_rational (bigrat (bigint i) (bigint 1))) :ruleset array_api_ruleset)
(constructor Float___add__ (Float Float) Float)
(rewrite (Float___add__ (Float___init__ f) (Float___init__ f2)) (Float___init__ (+ f f2)) :ruleset array_api_ruleset)
(constructor Float___sub__ (Float Float) Float)
(rewrite (Float___sub__ (Float___init__ f) (Float___init__ f2)) (Float___init__ (- f f2)) :ruleset array_api_ruleset)
(constructor Float___mul__ (Float Float) Float)
(rewrite (Float___mul__ (Float___init__ f) (Float___init__ f2)) (Float___init__ (* f f2)) :ruleset array_api_ruleset)
(constructor Float___truediv__ (Float Float) Float)
(rewrite (Float___truediv__ (Float_rational r) (Float_rational r1)) (Float_rational (/ r r1)) :ruleset array_api_ruleset)
(rewrite (Float___add__ (Float_rational r) (Float_rational r1)) (Float_rational (+ r r1)) :ruleset array_api_ruleset)
(rewrite (Float___sub__ (Float_rational r) (Float_rational r1)) (Float_rational (- r r1)) :ruleset array_api_ruleset)
(rewrite (Float___mul__ (Float_rational r) (Float_rational r1)) (Float_rational (* r r1)) :ruleset array_api_ruleset)
(rewrite (Float___pow__ (Float___init__ f) (Float___init__ f2)) (Float___init__ (^ f f2)) :ruleset array_api_ruleset)
(rewrite (Float___eq__ (Float___init__ f) (Float___init__ f)) (Boolean___init__ true) :ruleset array_api_ruleset)
(rewrite (Float___eq__ (Float___init__ f) (Float___init__ f2)) (Boolean___init__ false) :when ((!= f f2)) :ruleset array_api_ruleset)
(rewrite (Float___eq__ (Float_rational r) (Float_rational r)) (Boolean___init__ true) :ruleset array_api_ruleset)
(rewrite (Float___eq__ (Float_rational r) (Float_rational r1)) (Boolean___init__ false) :when ((!= r r1)) :ruleset array_api_ruleset)
(rewrite (Int___eq__ (Int___init__ i) (Int___init__ i)) (Boolean___init__ true) :ruleset array_api_ruleset)
(rule ((= r (Int___eq__ (Int___init__ i) (Int___init__ j)))
       (!= i j))
      ((union r (Boolean___init__ false)))
        :ruleset array_api_ruleset )
(rewrite (Int___ge__ (Int___init__ i) (Int___init__ i)) (Boolean___init__ true) :ruleset array_api_ruleset)
(rule ((= r (Int___ge__ (Int___init__ i) (Int___init__ j)))
       (> i j))
      ((union r (Boolean___init__ true)))
        :ruleset array_api_ruleset )
(rule ((= r (Int___ge__ (Int___init__ i) (Int___init__ j)))
       (< i j))
      ((union r (Boolean___init__ false)))
        :ruleset array_api_ruleset )
(rewrite (Int___lt__ (Int___init__ i) (Int___init__ i)) (Boolean___init__ false) :ruleset array_api_ruleset)
(rule ((= r (Int___lt__ (Int___init__ i) (Int___init__ j)))
       (< i j))
      ((union r (Boolean___init__ true)))
        :ruleset array_api_ruleset )
(rule ((= r (Int___lt__ (Int___init__ i) (Int___init__ j)))
       (> i j))
      ((union r (Boolean___init__ false)))
        :ruleset array_api_ruleset )
(constructor Int___gt__ (Int Int) Boolean)
(rewrite (Int___gt__ (Int___init__ i) (Int___init__ i)) (Boolean___init__ false) :ruleset array_api_ruleset)
(rule ((= r (Int___gt__ (Int___init__ i) (Int___init__ j)))
       (> i j))
      ((union r (Boolean___init__ true)))
        :ruleset array_api_ruleset )
(rule ((= r (Int___gt__ (Int___init__ i) (Int___init__ j)))
       (< i j))
      ((union r (Boolean___init__ false)))
        :ruleset array_api_ruleset )
(function Int_to_i64 (Int) i64 :no-merge)
(rule ((= o (Int___init__ j)))
      ((set (Int_to_i64 o) j))
        :ruleset array_api_ruleset )
(rule ((= (Int___init__ i) (Int___init__ j))
       (!= i j))
      ((panic "Real ints cannot be equal to different ints"))
        :ruleset array_api_ruleset )
(rewrite (Int___add__ (Int___init__ i) (Int___init__ j)) (Int___init__ (+ i j)) :ruleset array_api_ruleset)
(rewrite (Int___sub__ (Int___init__ i) (Int___init__ j)) (Int___init__ (- i j)) :ruleset array_api_ruleset)
(rewrite (Int___mul__ (Int___init__ i) (Int___init__ j)) (Int___init__ (* i j)) :ruleset array_api_ruleset)
(rewrite (Int___floordiv__ (Int___init__ i) (Int___init__ j)) (Int___init__ (/ i j)) :ruleset array_api_ruleset)
(rewrite (Int___mod__ (Int___init__ i) (Int___init__ j)) (Int___init__ (% i j)) :ruleset array_api_ruleset)
(constructor Int___and__ (Int Int) Int)
(rewrite (Int___and__ (Int___init__ i) (Int___init__ j)) (Int___init__ (& i j)) :ruleset array_api_ruleset)
(constructor Int___or__ (Int Int) Int)
(rewrite (Int___or__ (Int___init__ i) (Int___init__ j)) (Int___init__ (| i j)) :ruleset array_api_ruleset)
(constructor Int___xor__ (Int Int) Int)
(rewrite (Int___xor__ (Int___init__ i) (Int___init__ j)) (Int___init__ (^ i j)) :ruleset array_api_ruleset)
(constructor Int___lshift__ (Int Int) Int)
(rewrite (Int___lshift__ (Int___init__ i) (Int___init__ j)) (Int___init__ (<< i j)) :ruleset array_api_ruleset)
(constructor Int___rshift__ (Int Int) Int)
(rewrite (Int___rshift__ (Int___init__ i) (Int___init__ j)) (Int___init__ (>> i j)) :ruleset array_api_ruleset)
(constructor Int___invert__ (Int) Int)
(rewrite (Int___invert__ (Int___init__ i)) (Int___init__ (not-i64 i)) :ruleset array_api_ruleset)
(rewrite (Int_if_ (Boolean___init__ true) o b) o :subsume :ruleset array_api_ruleset)
(rewrite (Int_if_ (Boolean___init__ false) o b) b :subsume :ruleset array_api_ruleset)
(rule ((= (Int_NEVER ) (Int___init__ i)))
      ((panic "Int.NEVER cannot be equal to any real int"))
        :ruleset array_api_ruleset )
(function Boolean_to_bool (Boolean) bool :no-merge)
(rule ((= x (Boolean___init__ b)))
      ((set (Boolean_to_bool x) b))
        :ruleset array_api_ruleset )
(rewrite (Boolean___or__ (Boolean___init__ true) x) (Boolean___init__ true) :ruleset array_api_ruleset)
(rewrite (Boolean___or__ (Boolean___init__ false) x) x :ruleset array_api_ruleset)
(rewrite (Boolean___and__ (Boolean___init__ true) x) x :ruleset array_api_ruleset)
(rewrite (Boolean___and__ (Boolean___init__ false) x) (Boolean___init__ false) :ruleset array_api_ruleset)
(rewrite (Boolean___invert__ (Boolean___init__ true)) (Boolean___init__ false) :ruleset array_api_ruleset)
(rewrite (Boolean___invert__ (Boolean___init__ false)) (Boolean___init__ true) :ruleset array_api_ruleset)
(rule ((= (Boolean___init__ false) (Boolean___init__ true)))
      ((panic "False cannot equal True"))
        :ruleset array_api_ruleset )
(rewrite (Boolean___eq__ x x) (Boolean___init__ true) :ruleset array_api_ruleset)
(rewrite (Boolean___eq__ (Boolean___init__ false) (Boolean___init__ true)) (Boolean___init__ false) :ruleset array_api_ruleset)
(rewrite (Boolean___eq__ (Boolean___init__ true) (Boolean___init__ false)) (Boolean___init__ false) :ruleset array_api_ruleset)
(ruleset array_api_vec_to_cons_ruleset)
(rewrite (TupleInt_from_vec vs) (TupleInt_EMPTY ) :when ((= (vec-length vs) 0)) :ruleset array_api_vec_to_cons_ruleset)
(rewrite (TupleInt_from_vec vs) (TupleInt_append (TupleInt_from_vec (vec-remove vs (- (vec-length vs) 1))) (vec-get vs (- (vec-length vs) 1))) :when ((!= (vec-length vs) 0)) :ruleset array_api_vec_to_cons_ruleset)
(rewrite (TupleValue_from_vec vv) (TupleValue_EMPTY ) :when ((= (vec-length vv) 0)) :ruleset array_api_vec_to_cons_ruleset)
(rewrite (TupleValue_from_vec vv) (TupleValue_append (TupleValue_from_vec (vec-remove vv (- (vec-length vv) 1))) (vec-get vv (- (vec-length vv) 1))) :when ((!= (vec-length vv) 0)) :ruleset array_api_vec_to_cons_ruleset)
(rewrite (TupleTupleInt_from_vec vt) (TupleTupleInt_EMPTY ) :when ((= (vec-length vt) 0)) :ruleset array_api_vec_to_cons_ruleset)
(rewrite (TupleTupleInt_from_vec vt) (TupleTupleInt_append (TupleTupleInt_from_vec (vec-remove vt (- (vec-length vt) 1))) (vec-get vt (- (vec-length vt) 1))) :when ((!= (vec-length vt) 0)) :ruleset array_api_vec_to_cons_ruleset)
(rewrite (TupleNDArray_from_vec vn) (TupleNDArray_EMPTY ) :when ((= (vec-length vn) 0)) :ruleset array_api_vec_to_cons_ruleset)
(rewrite (TupleNDArray_from_vec vn) (TupleNDArray_append (TupleNDArray_from_vec (vec-remove vn (- (vec-length vn) 1))) (vec-get vn (- (vec-length vn) 1))) :when ((!= (vec-length vn) 0)) :ruleset array_api_vec_to_cons_ruleset)
(unstable-combined-ruleset combined_ruleset_4718011712 array_api_ruleset array_api_vec_to_cons_ruleset)
(run-schedule (saturate (run combined_ruleset_4718011712)))