File: .lake/packages/lean4/src/lean/Init/Omega/Int.lean

full_name: Lean.Omega.Int.ofNat_pow
code: theorem ofNat_pow (a b : Nat) : ((a ^ b : Nat) : Int) = (a : Int) ^ b 
goal: ↑(a ^ b) = ↑a ^ b

full_name: Lean.Omega.Int.pos_pow_of_pos
code: theorem pos_pow_of_pos (a : Int) (b : Nat) (h : 0 < a) : 0 < a ^ b 
goal: 0 < a ^ b

full_name: Lean.Omega.Int.ofNat_pos
code: theorem ofNat_pos {a : Nat} : 0 < (a : Int) ↔ 0 < a 
goal: 0 < ↑a ↔ 0 < a

full_name: Lean.Omega.Int.ofNat_pos_of_pos
code: theorem ofNat_pos_of_pos {a : Nat} (h : 0 < a) : 0 < (a : Int) 
goal: 0 < ↑a

full_name: Lean.Omega.Int.natCast_ofNat
code: theorem natCast_ofNat {x : Nat} :
    @Nat.cast Int instNatCastInt (no_index (OfNat.ofNat x)) = OfNat.ofNat x 
goal: ↑(OfNat.ofNat x) = OfNat.ofNat x

full_name: Lean.Omega.Int.ofNat_lt_of_lt
code: theorem ofNat_lt_of_lt {x y : Nat} (h : x < y) : (x : Int) < (y : Int) 
goal: ↑x < ↑y

full_name: Lean.Omega.Int.ofNat_le_of_le
code: theorem ofNat_le_of_le {x y : Nat} (h : x ≤ y) : (x : Int) ≤ (y : Int) 
goal: ↑x ≤ ↑y

full_name: Lean.Omega.Int.ofNat_shiftLeft_eq
code: theorem ofNat_shiftLeft_eq {x y : Nat} : (x <<< y : Int) = (x : Int) * (2 ^ y : Nat) 
goal: ↑(x <<< y) = ↑x * ↑(2 ^ y)

full_name: Lean.Omega.Int.ofNat_shiftRight_eq_div_pow
code: theorem ofNat_shiftRight_eq_div_pow {x y : Nat} : (x >>> y : Int) = (x : Int) / (2 ^ y : Nat) 
goal: ↑(x >>> y) = ↑x / ↑(2 ^ y)

full_name: Lean.Omega.Int.emod_ofNat_nonneg
code: theorem emod_ofNat_nonneg {x : Nat} {y : Int} : 0 ≤ (x : Int) % y 
goal: 0 ≤ ↑x % y

full_name: Lean.Omega.Int.lt_of_not_ge
code: theorem lt_of_not_ge {x y : Int} (h : ¬ (x ≤ y)) : y < x 
goal: y < x

full_name: Lean.Omega.Int.lt_of_not_le
code: theorem lt_of_not_le {x y : Int} (h : ¬ (x ≤ y)) : y < x 
goal: y < x

full_name: Lean.Omega.Int.not_le_of_lt
code: theorem not_le_of_lt {x y : Int} (h : y < x) : ¬ (x ≤ y) 
goal: ¬x ≤ y

full_name: Lean.Omega.Int.lt_le_asymm
code: theorem lt_le_asymm {x y : Int} (h₁ : y < x) (h₂ : x ≤ y) : False 
goal: False

full_name: Lean.Omega.Int.le_lt_asymm
code: theorem le_lt_asymm {x y : Int} (h₁ : y ≤ x) (h₂ : x < y) : False 
goal: False

full_name: Lean.Omega.Int.le_of_not_gt
code: theorem le_of_not_gt {x y : Int} (h : ¬ (y > x)) : y ≤ x 
goal: y ≤ x

full_name: Lean.Omega.Int.not_lt_of_ge
code: theorem not_lt_of_ge {x y : Int} (h : y ≥ x) : ¬ (y < x) 
goal: ¬y < x

full_name: Lean.Omega.Int.le_of_not_lt
code: theorem le_of_not_lt {x y : Int} (h : ¬ (x < y)) : y ≤ x 
goal: y ≤ x

full_name: Lean.Omega.Int.not_lt_of_le
code: theorem not_lt_of_le {x y : Int} (h : y ≤ x) : ¬ (x < y) 
goal: ¬x < y

full_name: Lean.Omega.Int.add_congr
code: theorem add_congr {a b c d : Int} (h₁ : a = b) (h₂ : c = d) : a + c = b + d 
goal: a + c = b + d

full_name: Lean.Omega.Int.mul_congr
code: theorem mul_congr {a b c d : Int} (h₁ : a = b) (h₂ : c = d) : a * c = b * d 
goal: a * c = b * d

full_name: Lean.Omega.Int.mul_congr_left
code: theorem mul_congr_left {a b : Int} (h₁ : a = b)  (c : Int) : a * c = b * c 
goal: a * c = b * c

full_name: Lean.Omega.Int.sub_congr
code: theorem sub_congr {a b c d : Int} (h₁ : a = b) (h₂ : c = d) : a - c = b - d 
goal: a - c = b - d

full_name: Lean.Omega.Int.neg_congr
code: theorem neg_congr {a b : Int} (h₁ : a = b) : -a = -b 
goal: -a = -b

full_name: Lean.Omega.Int.lt_of_gt
code: theorem lt_of_gt {x y : Int} (h : x > y) : y < x 
goal: y < x

full_name: Lean.Omega.Int.le_of_ge
code: theorem le_of_ge {x y : Int} (h : x ≥ y) : y ≤ x 
goal: y ≤ x

full_name: Lean.Omega.Int.ofNat_sub_eq_zero
code: theorem ofNat_sub_eq_zero {b a : Nat} (h : ¬ b ≤ a) : ((a - b : Nat) : Int) = 0 
goal: ↑(a - b) = 0

full_name: Lean.Omega.Int.ofNat_sub_dichotomy
code: theorem ofNat_sub_dichotomy {a b : Nat} :
    b ≤ a ∧ ((a - b : Nat) : Int) = a - b ∨ a < b ∧ ((a - b : Nat) : Int) = 0 
goal: b ≤ a ∧ ↑(a - b) = ↑a - ↑b ∨ a < b ∧ ↑(a - b) = 0

full_name: Lean.Omega.Int.ofNat_congr
code: theorem ofNat_congr {a b : Nat} (h : a = b) : (a : Int) = (b : Int) 
goal: ↑a = ↑b

full_name: Lean.Omega.Int.ofNat_sub_sub
code: theorem ofNat_sub_sub {a b c : Nat} : ((a - b - c : Nat) : Int) = ((a - (b + c) : Nat) : Int) 
goal: ↑(a - b - c) = ↑(a - (b + c))

full_name: Lean.Omega.Int.ofNat_min
code: theorem ofNat_min (a b : Nat) : ((min a b : Nat) : Int) = min (a : Int) (b : Int) 
goal: ↑(min a b) = min ↑a ↑b

full_name: Lean.Omega.Int.ofNat_max
code: theorem ofNat_max (a b : Nat) : ((max a b : Nat) : Int) = max (a : Int) (b : Int) 
goal: ↑(max a b) = max ↑a ↑b

full_name: Lean.Omega.Int.ofNat_natAbs
code: theorem ofNat_natAbs (a : Int) : (a.natAbs : Int) = if 0 ≤ a then a else -a 
goal: ↑a.natAbs = if 0 ≤ a then a else -a

full_name: Lean.Omega.Int.natAbs_dichotomy
code: theorem natAbs_dichotomy {a : Int} : 0 ≤ a ∧ a.natAbs = a ∨ a < 0 ∧ a.natAbs = -a 
goal: 0 ≤ a ∧ ↑a.natAbs = a ∨ a < 0 ∧ ↑a.natAbs = -a

full_name: Lean.Omega.Int.neg_le_natAbs
code: theorem neg_le_natAbs {a : Int} : -a ≤ a.natAbs 
goal: -a ≤ ↑a.natAbs

full_name: Lean.Omega.Int.add_le_iff_le_sub
code: theorem add_le_iff_le_sub (a b c : Int) : a + b ≤ c ↔ a ≤ c - b 
goal: a + b ≤ c ↔ a ≤ c - b

full_name: Lean.Omega.Int.le_add_iff_sub_le
code: theorem le_add_iff_sub_le (a b c : Int) : a ≤ b + c ↔ a - c ≤ b 
goal: a ≤ b + c ↔ a - c ≤ b

full_name: Lean.Omega.Int.add_le_zero_iff_le_neg
code: theorem add_le_zero_iff_le_neg (a b : Int) : a + b ≤ 0 ↔ a ≤ - b 
goal: a + b ≤ 0 ↔ a ≤ -b

full_name: Lean.Omega.Int.add_le_zero_iff_le_neg'
code: theorem add_le_zero_iff_le_neg' (a b : Int) : a + b ≤ 0 ↔ b ≤ -a 
goal: a + b ≤ 0 ↔ b ≤ -a

full_name: Lean.Omega.Int.add_nonnneg_iff_neg_le
code: theorem add_nonnneg_iff_neg_le (a b : Int) : 0 ≤ a + b ↔ -b ≤ a 
goal: 0 ≤ a + b ↔ -b ≤ a

full_name: Lean.Omega.Int.add_nonnneg_iff_neg_le'
code: theorem add_nonnneg_iff_neg_le' (a b : Int) : 0 ≤ a + b ↔ -a ≤ b 
goal: 0 ≤ a + b ↔ -a ≤ b

full_name: Lean.Omega.Int.ofNat_fst_mk
code: theorem ofNat_fst_mk {β} {x : Nat} {y : β} : (Prod.mk x y).fst = (x : Int) 
goal: ↑(x, y).fst = ↑x

full_name: Lean.Omega.Int.ofNat_snd_mk
code: theorem ofNat_snd_mk {α} {x : α} {y : Nat} : (Prod.mk x y).snd = (y : Int) 
goal: ↑(x, y).snd = ↑y

full_name: Lean.Omega.Nat.lt_of_gt
code: theorem lt_of_gt {x y : Nat} (h : x > y) : y < x 
goal: y < x

full_name: Lean.Omega.Nat.le_of_ge
code: theorem le_of_ge {x y : Nat} (h : x ≥ y) : y ≤ x 
goal: y ≤ x

full_name: Lean.Omega.Fin.ne_iff_lt_or_gt
code: theorem ne_iff_lt_or_gt {i j : Fin n} : i ≠ j ↔ i < j ∨ i > j 
goal: i ≠ j ↔ i < j ∨ i > j

full_name: Lean.Omega.Fin.lt_or_gt_of_ne
code: protected theorem lt_or_gt_of_ne {i j : Fin n} (h : i ≠ j) : i < j ∨ i > j 
goal: i < j ∨ i > j

full_name: Lean.Omega.Fin.not_le
code: theorem not_le {i j : Fin n} : ¬ i ≤ j ↔ j < i 
goal: ¬i ≤ j ↔ j < i

full_name: Lean.Omega.Fin.not_lt
code: theorem not_lt {i j : Fin n} : ¬ i < j ↔ j ≤ i 
goal: ¬i < j ↔ j ≤ i

full_name: Lean.Omega.Fin.lt_of_not_le
code: protected theorem lt_of_not_le {i j : Fin n} (h : ¬ i ≤ j) : j < i 
goal: j < i

full_name: Lean.Omega.Fin.le_of_not_lt
code: protected theorem le_of_not_lt {i j : Fin n} (h : ¬ i < j) : j ≤ i 
goal: j ≤ i

full_name: Lean.Omega.Fin.ofNat_val_add
code: theorem ofNat_val_add {x y : Fin n} :
    (((x + y : Fin n)) : Int) = ((x : Int) + (y : Int)) % n 
goal: ↑↑(x + y) = (↑↑x + ↑↑y) % ↑n

full_name: Lean.Omega.Fin.ofNat_val_sub
code: theorem ofNat_val_sub {x y : Fin n} :
    (((x - y : Fin n)) : Int) = (((n - y : Nat) + (x : Int) : Int)) % n 
goal: ↑↑(x - y) = (↑(n - ↑y) + ↑↑x) % ↑n

full_name: Lean.Omega.Fin.ofNat_val_mul
code: theorem ofNat_val_mul {x y : Fin n} :
    (((x * y : Fin n)) : Int) = ((x : Int) * (y : Int)) % n 
goal: ↑↑(x * y) = ↑↑x * ↑↑y % ↑n

full_name: Lean.Omega.Fin.ofNat_val_natCast
code: theorem ofNat_val_natCast {n x y : Nat} (h : y = x % (n + 1)):
    @Nat.cast Int instNatCastInt (@Fin.val (n + 1) (OfNat.ofNat x)) = OfNat.ofNat y 
goal: ↑↑(OfNat.ofNat x) = OfNat.ofNat y

full_name: Lean.Omega.Prod.of_lex
code: theorem of_lex (w : Prod.Lex r s p q) : r p.fst q.fst ∨ p.fst = q.fst ∧ s p.snd q.snd 
goal: ∀ {α : Type u_1} {r : α → α → Prop} {β : Type u_2} {s : β → β → Prop} {p q : α × β},
  Prod.Lex r s p q → r p.fst q.fst ∨ p.fst = q.fst ∧ s p.snd q.snd

full_name: Lean.Omega.Prod.of_not_lex
code: theorem of_not_lex {α} {r : α → α → Prop} [DecidableEq α] {β} {s : β → β → Prop}
    {p q : α × β} (w : ¬ Prod.Lex r s p q) :
    ¬ r p.fst q.fst ∧ (p.fst ≠ q.fst ∨ ¬ s p.snd q.snd) 
goal: ¬r p.fst q.fst ∧ (p.fst ≠ q.fst ∨ ¬s p.snd q.snd)

full_name: Lean.Omega.Prod.fst_mk
code: theorem fst_mk : (Prod.mk x y).fst = x 
goal: ∀ {α : Type u_1} {x : α} {β : Type u_2} {y : β}, (x, y).fst = x

full_name: Lean.Omega.Prod.snd_mk
code: theorem snd_mk : (Prod.mk x y).snd = y 
goal: ∀ {α : Type u_1} {x : α} {α_1 : Type u_2} {y : α_1}, (x, y).snd = y