ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- PFunctor.Approx.agree_trival
@[simp]
theorem agree_trival {x : CofixA F 0} {y : CofixA F 1} : Agree x y 
Arguments: {F : PFunctor.{u}} {x : PFunctor.Approx.CofixA F 0} {y : PFunctor.Approx.CofixA F 1}
Goal: PFunctor.Approx.Agree x y
-- PFunctor.Approx.agree_children
theorem agree_children {n : ℕ} (x : CofixA F (succ n)) (y : CofixA F (succ n + 1)) {i j}
    (h₀ : HEq i j) (h₁ : Agree x y) : Agree (children' x i) (children' y j) 
Arguments: {F : PFunctor.{u}} {n : ℕ} (x : PFunctor.Approx.CofixA F n.succ) (y : PFunctor.Approx.CofixA F (n.succ + 1)) {i : F.B (PFunctor.Approx.head' x)} {j : F.B (PFunctor.Approx.head' y)} (h₀ : HEq i j) (h₁ : PFunctor.Approx.Agree x y)
Goal: PFunctor.Approx.Agree (PFunctor.Approx.children' x i) (PFunctor.Approx.children' y j)
-- PFunctor.Approx.truncate_eq_of_agree
theorem truncate_eq_of_agree {n : ℕ} (x : CofixA F n) (y : CofixA F (succ n)) (h : Agree x y) :
    truncate y = x 
Arguments: {F : PFunctor.{u}} {n : ℕ} (x : PFunctor.Approx.CofixA F n) (y : PFunctor.Approx.CofixA F n.succ) (h : PFunctor.Approx.Agree x y)
Goal: PFunctor.Approx.truncate y = x
-- PFunctor.Approx.P_corec
theorem P_corec (i : X) (n : ℕ) : Agree (sCorec f i n) (sCorec f i (succ n)) 
Arguments: {F : PFunctor.{u}} {X : Type w} (f : X → ↑F X) (i : X) (n : ℕ)
Goal: PFunctor.Approx.Agree (PFunctor.Approx.sCorec f i n) (PFunctor.Approx.sCorec f i n.succ)
-- PFunctor.Approx.head_succ'
theorem head_succ' (n m : ℕ) (x : ∀ n, CofixA F n) (Hconsistent : AllAgree x) :
    head' (x (succ n)) = head' (x (succ m)) 
Arguments: {F : PFunctor.{u}} (n m : ℕ) (x : (n : ℕ) → PFunctor.Approx.CofixA F n) (Hconsistent : PFunctor.Approx.AllAgree x)
Goal: PFunctor.Approx.head' (x n.succ) = PFunctor.Approx.head' (x m.succ)
-- PFunctor.MIntl.consistent
structure MIntl where
    approx : ∀ n, CofixA F n
    consistent : AllAgree approx
Arguments: {F : PFunctor.{u}} (self : F.MIntl)
Goal: PFunctor.Approx.AllAgree self.approx
-- PFunctor.M.default_consistent
theorem M.default_consistent [Inhabited F.A] : ∀ n, Agree (default : CofixA F n) default
  
Arguments: (F : PFunctor.{u}) [Inhabited F.A] (n : ℕ)
Goal: PFunctor.Approx.Agree default default
-- PFunctor.M.ext'
theorem ext' (x y : M F) (H : ∀ i : ℕ, x.approx i = y.approx i) : x = y 
Arguments: (F : PFunctor.{u}) (x y : F.M) (H : ∀ (i : ℕ), x.approx i = y.approx i)
Goal: x = y
-- PFunctor.M.head_succ
theorem head_succ (n m : ℕ) (x : M F) : head' (x.approx (succ n)) = head' (x.approx (succ m)) 
Arguments: {F : PFunctor.{u}} (n m : ℕ) (x : F.M)
Goal: PFunctor.Approx.head' (x.approx n.succ) = PFunctor.Approx.head' (x.approx m.succ)
-- PFunctor.M.head_eq_head'
theorem head_eq_head' : ∀ (x : M F) (n : ℕ), head x = head' (x.approx <| n + 1)
  
Arguments: {F : PFunctor.{u}} (x : F.M) (n : ℕ)
Goal: x.head = PFunctor.Approx.head' (x.approx (n + 1))
-- PFunctor.M.head'_eq_head
theorem head'_eq_head : ∀ (x : M F) (n : ℕ), head' (x.approx <| n + 1) = head x
  
Arguments: {F : PFunctor.{u}} (x : F.M) (n : ℕ)
Goal: PFunctor.Approx.head' (x.approx (n + 1)) = x.head
-- PFunctor.M.truncate_approx
theorem truncate_approx (x : M F) (n : ℕ) : truncate (x.approx <| n + 1) = x.approx n 
Arguments: {F : PFunctor.{u}} (x : F.M) (n : ℕ)
Goal: PFunctor.Approx.truncate (x.approx (n + 1)) = x.approx n
-- PFunctor.M.Approx.P_mk
protected theorem P_mk (x : F (M F)) : AllAgree (Approx.sMk x)
  
Arguments: {F : PFunctor.{u}} (x : ↑F F.M)
Goal: PFunctor.Approx.AllAgree (PFunctor.M.Approx.sMk x)
-- PFunctor.M.dest_mk
@[simp]
theorem dest_mk (x : F (M F)) : dest (M.mk x) = x 
Arguments: {F : PFunctor.{u}} (x : ↑F F.M)
Goal: (PFunctor.M.mk x).dest = x
-- PFunctor.M.mk_dest
@[simp]
theorem mk_dest (x : M F) : M.mk (dest x) = x 
Arguments: {F : PFunctor.{u}} (x : F.M)
Goal: PFunctor.M.mk x.dest = x
-- PFunctor.M.mk_inj
theorem mk_inj {x y : F (M F)} (h : M.mk x = M.mk y) : x = y 
Arguments: {F : PFunctor.{u}} {x y : ↑F F.M} (h : PFunctor.M.mk x = PFunctor.M.mk y)
Goal: x = y
-- PFunctor.M.approx_mk
theorem approx_mk (a : F.A) (f : F.B a → M F) (i : ℕ) :
    (M.mk ⟨a, f⟩).approx (succ i) = CofixA.intro a fun j => (f j).approx i 
Arguments: {F : PFunctor.{u}} (a : F.A) (f : F.B a → F.M) (i : ℕ)
Goal: (PFunctor.M.mk ⟨a, f⟩).approx i.succ = PFunctor.Approx.CofixA.intro a fun j => (f j).approx i
-- PFunctor.M.agree'_refl
@[simp]
theorem agree'_refl {n : ℕ} (x : M F) : Agree' n x x 
Arguments: {F : PFunctor.{u}} {n : ℕ} (x : F.M)
Goal: PFunctor.M.Agree' n x x
-- PFunctor.M.agree_iff_agree'
theorem agree_iff_agree' {n : ℕ} (x y : M F) :
    Agree (x.approx n) (y.approx <| n + 1) ↔ Agree' n x y 
Arguments: {F : PFunctor.{u}} {n : ℕ} (x y : F.M)
Goal: PFunctor.Approx.Agree (x.approx n) (y.approx (n + 1)) ↔ PFunctor.M.Agree' n x y
-- PFunctor.M.cases_mk
@[simp]
theorem cases_mk {r : M F → Sort*} (x : F (M F)) (f : ∀ x : F (M F), r (M.mk x)) :
    PFunctor.M.cases f (M.mk x) = f x 
Arguments: {F : PFunctor.{u}} {r : F.M → Sort u_2} (x : ↑F F.M) (f : (x : ↑F F.M) → r (PFunctor.M.mk x))
Goal: PFunctor.M.cases f (PFunctor.M.mk x) = f x
-- PFunctor.M.casesOn_mk
@[simp]
theorem casesOn_mk {r : M F → Sort*} (x : F (M F)) (f : ∀ x : F (M F), r (M.mk x)) :
    PFunctor.M.casesOn (M.mk x) f = f x 
Arguments: {F : PFunctor.{u}} {r : F.M → Sort u_2} (x : ↑F F.M) (f : (x : ↑F F.M) → r (PFunctor.M.mk x))
Goal: (PFunctor.M.mk x).casesOn f = f x
-- PFunctor.M.casesOn_mk'
@[simp]
theorem casesOn_mk' {r : M F → Sort*} {a} (x : F.B a → M F)
    (f : ∀ (a) (f : F.B a → M F), r (M.mk ⟨a, f⟩)) :
    PFunctor.M.casesOn' (M.mk ⟨a, x⟩) f = f a x 
Arguments: {F : PFunctor.{u}} {r : F.M → Sort u_2} {a : F.A} (x : F.B a → F.M) (f : (a : F.A) → (f : F.B a → F.M) → r (PFunctor.M.mk ⟨a, f⟩))
Goal: (PFunctor.M.mk ⟨a, x⟩).casesOn' f = f a x
-- PFunctor.M.isPath_cons
theorem isPath_cons {xs : Path F} {a a'} {f : F.B a → M F} {i : F.B a'} :
    IsPath (⟨a', i⟩ :: xs) (M.mk ⟨a, f⟩) → a = a' 
Arguments: {F : PFunctor.{u}} {xs : PFunctor.Approx.Path F} {a a' : F.A} {f : F.B a → F.M} {i : F.B a'}
Goal: PFunctor.M.IsPath (⟨a', i⟩ :: xs) (PFunctor.M.mk ⟨a, f⟩) → a = a'
-- PFunctor.M.isPath_cons'
theorem isPath_cons' {xs : Path F} {a} {f : F.B a → M F} {i : F.B a} :
    IsPath (⟨a, i⟩ :: xs) (M.mk ⟨a, f⟩) → IsPath xs (f i) 
Arguments: {F : PFunctor.{u}} {xs : PFunctor.Approx.Path F} {a : F.A} {f : F.B a → F.M} {i : F.B a}
Goal: PFunctor.M.IsPath (⟨a, i⟩ :: xs) (PFunctor.M.mk ⟨a, f⟩) → PFunctor.M.IsPath xs (f i)
-- PFunctor.M.iselect_eq_default
theorem iselect_eq_default [DecidableEq F.A] [Inhabited (M F)] (ps : Path F) (x : M F)
    (h : ¬IsPath ps x) : iselect ps x = head default 
Arguments: {F : PFunctor.{u}} [DecidableEq F.A] [Inhabited F.M] (ps : PFunctor.Approx.Path F) (x : F.M) (h : ¬PFunctor.M.IsPath ps x)
Goal: PFunctor.M.iselect ps x = default.head
-- PFunctor.M.head_mk
@[simp]
theorem head_mk (x : F (M F)) : head (M.mk x) = x.1 
Arguments: {F : PFunctor.{u}} (x : ↑F F.M)
Goal: (PFunctor.M.mk x).head = x.fst
-- PFunctor.M.children_mk
theorem children_mk {a} (x : F.B a → M F) (i : F.B (head (M.mk ⟨a, x⟩))) :
    children (M.mk ⟨a, x⟩) i = x (cast (by rw [head_mk]) i) 
Arguments: {F : PFunctor.{u}} {a : F.A} (x : F.B a → F.M) (i : F.B (PFunctor.M.mk ⟨a, x⟩).head)
Goal: (PFunctor.M.mk ⟨a, x⟩).children i = x (cast ⋯ i)
-- PFunctor.M.ichildren_mk
@[simp]
theorem ichildren_mk [DecidableEq F.A] [Inhabited (M F)] (x : F (M F)) (i : F.Idx) :
    ichildren i (M.mk x) = x.iget i 
Arguments: {F : PFunctor.{u}} [DecidableEq F.A] [Inhabited F.M] (x : ↑F F.M) (i : F.Idx)
Goal: PFunctor.M.ichildren i (PFunctor.M.mk x) = x.iget i
-- PFunctor.M.isubtree_cons
@[simp]
theorem isubtree_cons [DecidableEq F.A] [Inhabited (M F)] (ps : Path F) {a} (f : F.B a → M F)
    {i : F.B a} : isubtree (⟨_, i⟩ :: ps) (M.mk ⟨a, f⟩) = isubtree ps (f i) 
Arguments: {F : PFunctor.{u}} [DecidableEq F.A] [Inhabited F.M] (ps : PFunctor.Approx.Path F) {a : F.A} (f : F.B a → F.M) {i : F.B a}
Goal: PFunctor.M.isubtree (⟨a, i⟩ :: ps) (PFunctor.M.mk ⟨a, f⟩) = PFunctor.M.isubtree ps (f i)
-- PFunctor.M.iselect_nil
@[simp]
theorem iselect_nil [DecidableEq F.A] [Inhabited (M F)] {a} (f : F.B a → M F) :
    iselect nil (M.mk ⟨a, f⟩) = a 
Arguments: {F : PFunctor.{u}} [DecidableEq F.A] [Inhabited F.M] {a : F.A} (f : F.B a → F.M)
Goal: PFunctor.M.iselect [] (PFunctor.M.mk ⟨a, f⟩) = a
-- PFunctor.M.iselect_cons
@[simp]
theorem iselect_cons [DecidableEq F.A] [Inhabited (M F)] (ps : Path F) {a} (f : F.B a → M F) {i} :
    iselect (⟨a, i⟩ :: ps) (M.mk ⟨a, f⟩) = iselect ps (f i) 
Arguments: {F : PFunctor.{u}} [DecidableEq F.A] [Inhabited F.M] (ps : PFunctor.Approx.Path F) {a : F.A} (f : F.B a → F.M) {i : F.B a}
Goal: PFunctor.M.iselect (⟨a, i⟩ :: ps) (PFunctor.M.mk ⟨a, f⟩) = PFunctor.M.iselect ps (f i)
-- PFunctor.M.corec_def
theorem corec_def {X} (f : X → F X) (x₀ : X) : M.corec f x₀ = M.mk (F.map (M.corec f) (f x₀)) 
Arguments: {F : PFunctor.{u}} {X : Type u_2} (f : X → ↑F X) (x₀ : X)
Goal: PFunctor.M.corec f x₀ = PFunctor.M.mk (F.map (PFunctor.M.corec f) (f x₀))
-- PFunctor.M.ext_aux
theorem ext_aux [Inhabited (M F)] [DecidableEq F.A] {n : ℕ} (x y z : M F) (hx : Agree' n z x)
    (hy : Agree' n z y) (hrec : ∀ ps : Path F, n = ps.length → iselect ps x = iselect ps y) :
    x.approx (n + 1) = y.approx (n + 1) 
Arguments: {F : PFunctor.{u}} [Inhabited F.M] [DecidableEq F.A] {n : ℕ} (x y z : F.M) (hx : PFunctor.M.Agree' n z x) (hy : PFunctor.M.Agree' n z y) (hrec : ∀ (ps : PFunctor.Approx.Path F), n = List.length ps → PFunctor.M.iselect ps x = PFunctor.M.iselect ps y)
Goal: x.approx (n + 1) = y.approx (n + 1)
-- PFunctor.M.ext
theorem ext [Inhabited (M F)] (x y : M F) (H : ∀ ps : Path F, iselect ps x = iselect ps y) :
    x = y 
Arguments: {F : PFunctor.{u}} [Inhabited F.M] (x y : F.M) (H : ∀ (ps : PFunctor.Approx.Path F), PFunctor.M.iselect ps x = PFunctor.M.iselect ps y)
Goal: x = y
-- PFunctor.M.IsBisimulation.tail
structure IsBisimulation : Prop where
    head : ∀ {a a'} {f f'}, M.mk ⟨a, f⟩ ~ M.mk ⟨a', f'⟩ → a = a'
    tail : ∀ {a} {f f' : F.B a → M F}, M.mk ⟨a, f⟩ ~ M.mk ⟨a, f'⟩ → ∀ i : F.B a, f i ~ f' i
Arguments: {F : PFunctor.{u}} {R : F.M → F.M → Prop} (self : PFunctor.M.IsBisimulation R) {a : F.A} {f f' : F.B a → F.M}
Goal: R (PFunctor.M.mk ⟨a, f⟩) (PFunctor.M.mk ⟨a, f'⟩) → ∀ (i : F.B a), R (f i) (f' i)
-- PFunctor.M.IsBisimulation.head
structure IsBisimulation : Prop where
    head : ∀ {a a'} {f f'}, M.mk ⟨a, f⟩ ~ M.mk ⟨a', f'⟩ → a = a'
    tail : ∀ {a} {f f' : F.B a → M F}, M.mk ⟨a, f⟩ ~ M.mk ⟨a, f'⟩ → ∀ i : F.B a, f i ~ f' i
Arguments: {F : PFunctor.{u}} {R : F.M → F.M → Prop} (self : PFunctor.M.IsBisimulation R) {a a' : F.A} {f : F.B a → F.M} {f' : F.B a' → F.M}
Goal: R (PFunctor.M.mk ⟨a, f⟩) (PFunctor.M.mk ⟨a', f'⟩) → a = a'
-- PFunctor.M.nth_of_bisim
theorem nth_of_bisim [Inhabited (M F)] (bisim : IsBisimulation R) (s₁ s₂) (ps : Path F) :
    (R s₁ s₂) →
      IsPath ps s₁ ∨ IsPath ps s₂ →
        iselect ps s₁ = iselect ps s₂ ∧
          ∃ (a : _) (f f' : F.B a → M F),
            isubtree ps s₁ = M.mk ⟨a, f⟩ ∧
              isubtree ps s₂ = M.mk ⟨a, f'⟩ ∧ ∀ i : F.B a, f i ~ f' i 
Arguments: {F : PFunctor.{u}} (R : F.M → F.M → Prop) [Inhabited F.M] (bisim : PFunctor.M.IsBisimulation R) (s₁ s₂ : F.M) (ps : PFunctor.Approx.Path F)
Goal: R s₁ s₂ →
  PFunctor.M.IsPath ps s₁ ∨ PFunctor.M.IsPath ps s₂ →
    PFunctor.M.iselect ps s₁ = PFunctor.M.iselect ps s₂ ∧
      ∃ a f f',
        PFunctor.M.isubtree ps s₁ = PFunctor.M.mk ⟨a, f⟩ ∧
          PFunctor.M.isubtree ps s₂ = PFunctor.M.mk ⟨a, f'⟩ ∧ ∀ (i : F.B a), R (f i) (f' i)
-- PFunctor.M.eq_of_bisim
theorem eq_of_bisim [Nonempty (M F)] (bisim : IsBisimulation R) : ∀ s₁ s₂, R s₁ s₂ → s₁ = s₂ 
Arguments: {F : PFunctor.{u}} (R : F.M → F.M → Prop) [Nonempty F.M] (bisim : PFunctor.M.IsBisimulation R) (s₁ s₂ : F.M)
Goal: R s₁ s₂ → s₁ = s₂
-- PFunctor.M.dest_corec
theorem dest_corec (g : α → P α) (x : α) : M.dest (M.corec g x) = P.map (M.corec g) (g x) 
Arguments: {P : PFunctor.{u}} {α : Type u_2} (g : α → ↑P α) (x : α)
Goal: (PFunctor.M.corec g x).dest = P.map (PFunctor.M.corec g) (g x)
-- PFunctor.M.bisim
theorem bisim (R : M P → M P → Prop)
    (h : ∀ x y, R x y → ∃ a f f', M.dest x = ⟨a, f⟩ ∧ M.dest y = ⟨a, f'⟩ ∧ ∀ i, R (f i) (f' i)) :
    ∀ x y, R x y → x = y 
Arguments: {P : PFunctor.{u}} (R : P.M → P.M → Prop) (h : ∀ (x y : P.M), R x y → ∃ a f f', x.dest = ⟨a, f⟩ ∧ y.dest = ⟨a, f'⟩ ∧ ∀ (i : P.B a), R (f i) (f' i)) (x y : P.M)
Goal: R x y → x = y
-- PFunctor.M.bisim'
theorem bisim' {α : Type*} (Q : α → Prop) (u v : α → M P)
    (h : ∀ x, Q x → ∃ a f f',
          M.dest (u x) = ⟨a, f⟩
          ∧ M.dest (v x) = ⟨a, f'⟩
          ∧ ∀ i, ∃ x', Q x' ∧ f i = u x' ∧ f' i = v x'
      ) :
    ∀ x, Q x → u x = v x 
Arguments: {P : PFunctor.{u}} {α : Type u_3} (Q : α → Prop) (u v : α → P.M) (h :
  ∀ (x : α),
    Q x → ∃ a f f', (u x).dest = ⟨a, f⟩ ∧ (v x).dest = ⟨a, f'⟩ ∧ ∀ (i : P.B a), ∃ x', Q x' ∧ f i = u x' ∧ f' i = v x') (x : α)
Goal: Q x → u x = v x
-- PFunctor.M.bisim_equiv
theorem bisim_equiv (R : M P → M P → Prop)
    (h : ∀ x y, R x y → ∃ a f f', M.dest x = ⟨a, f⟩ ∧ M.dest y = ⟨a, f'⟩ ∧ ∀ i, R (f i) (f' i)) :
    ∀ x y, R x y → x = y 
Arguments: {P : PFunctor.{u}} (R : P.M → P.M → Prop) (h : ∀ (x y : P.M), R x y → ∃ a f f', x.dest = ⟨a, f⟩ ∧ y.dest = ⟨a, f'⟩ ∧ ∀ (i : P.B a), R (f i) (f' i)) (x y : P.M)
Goal: R x y → x = y
-- PFunctor.M.corec_unique
theorem corec_unique (g : α → P α) (f : α → M P) (hyp : ∀ x, M.dest (f x) = P.map f (g x)) :
    f = M.corec g 
Arguments: {P : PFunctor.{u}} {α : Type u_2} (g : α → ↑P α) (f : α → P.M) (hyp : ∀ (x : α), (f x).dest = P.map f (g x))
Goal: f = PFunctor.M.corec g
-- Int.not_prime_of_int_mul
theorem not_prime_of_int_mul {a b : ℤ} {c : ℕ} (ha : a.natAbs ≠ 1) (hb : b.natAbs ≠ 1)
    (hc : a * b = (c : ℤ)) : ¬Nat.Prime c 
Arguments: {a b : ℤ} {c : ℕ} (ha : a.natAbs ≠ 1) (hb : b.natAbs ≠ 1) (hc : a * b = ↑c)
Goal: ¬Nat.Prime c
-- Int.succ_dvd_or_succ_dvd_of_succ_sum_dvd_mul
theorem succ_dvd_or_succ_dvd_of_succ_sum_dvd_mul {p : ℕ} (p_prime : Nat.Prime p) {m n : ℤ}
    {k l : ℕ} (hpm : ↑(p ^ k) ∣ m) (hpn : ↑(p ^ l) ∣ n) (hpmn : ↑(p ^ (k + l + 1)) ∣ m * n) :
    ↑(p ^ (k + 1)) ∣ m ∨ ↑(p ^ (l + 1)) ∣ n 
Arguments: {p : ℕ} (p_prime : Nat.Prime p) {m n : ℤ} {k l : ℕ} (hpm : ↑(p ^ k) ∣ m) (hpn : ↑(p ^ l) ∣ n) (hpmn : ↑(p ^ (k + l + 1)) ∣ m * n)
Goal: ↑(p ^ (k + 1)) ∣ m ∨ ↑(p ^ (l + 1)) ∣ n
-- Int.Prime.dvd_natAbs_of_coe_dvd_sq
theorem Prime.dvd_natAbs_of_coe_dvd_sq {p : ℕ} (hp : p.Prime) (k : ℤ) (h : (p : ℤ) ∣ k ^ 2) :
    p ∣ k.natAbs 
Arguments: {p : ℕ} (hp : Nat.Prime p) (k : ℤ) (h : ↑p ∣ k ^ 2)
Goal: p ∣ k.natAbs
-- Int.csSup_eq_greatest_of_bdd
theorem csSup_eq_greatest_of_bdd {s : Set ℤ} [DecidablePred (· ∈ s)] (b : ℤ) (Hb : ∀ z ∈ s, z ≤ b)
    (Hinh : ∃ z : ℤ, z ∈ s) : sSup s = greatestOfBdd b Hb Hinh 
Arguments: {s : Set ℤ} [DecidablePred fun x => x ∈ s] (b : ℤ) (Hb : ∀ z ∈ s, z ≤ b) (Hinh : ∃ z, z ∈ s)
Goal: sSup s = ↑(b.greatestOfBdd Hb Hinh)
-- Int.csSup_empty
@[simp]
theorem csSup_empty : sSup (∅ : Set ℤ) = 0 
Goal: sSup ∅ = 0
-- Int.csSup_of_not_bdd_above
theorem csSup_of_not_bdd_above {s : Set ℤ} (h : ¬BddAbove s) : sSup s = 0 
Arguments: {s : Set ℤ} (h : ¬BddAbove s)
Goal: sSup s = 0
-- Int.csInf_eq_least_of_bdd
theorem csInf_eq_least_of_bdd {s : Set ℤ} [DecidablePred (· ∈ s)] (b : ℤ) (Hb : ∀ z ∈ s, b ≤ z)
    (Hinh : ∃ z : ℤ, z ∈ s) : sInf s = leastOfBdd b Hb Hinh 
Arguments: {s : Set ℤ} [DecidablePred fun x => x ∈ s] (b : ℤ) (Hb : ∀ z ∈ s, b ≤ z) (Hinh : ∃ z, z ∈ s)
Goal: sInf s = ↑(b.leastOfBdd Hb Hinh)
-- Int.csInf_empty
@[simp]
theorem csInf_empty : sInf (∅ : Set ℤ) = 0 
Goal: sInf ∅ = 0
-- Int.csInf_of_not_bdd_below
theorem csInf_of_not_bdd_below {s : Set ℤ} (h : ¬BddBelow s) : sInf s = 0 
Arguments: {s : Set ℤ} (h : ¬BddBelow s)
Goal: sInf s = 0
-- Int.csSup_mem
theorem csSup_mem {s : Set ℤ} (h1 : s.Nonempty) (h2 : BddAbove s) : sSup s ∈ s 
Arguments: {s : Set ℤ} (h1 : s.Nonempty) (h2 : BddAbove s)
Goal: sSup s ∈ s
-- Int.csInf_mem
theorem csInf_mem {s : Set ℤ} (h1 : s.Nonempty) (h2 : BddBelow s) : sInf s ∈ s 
Arguments: {s : Set ℤ} (h1 : s.Nonempty) (h2 : BddBelow s)
Goal: sInf s ∈ s
-- Int.cast_ite
@[simp, norm_cast]
theorem cast_ite [AddGroupWithOne α] (P : Prop) [Decidable P] (m n : ℤ) :
    ((ite P m n : ℤ) : α) = ite P (m : α) (n : α) 
Arguments: {α : Type u_3} [AddGroupWithOne α] (P : Prop) [Decidable P] (m n : ℤ)
Goal: ↑(if P then m else n) = if P then ↑m else ↑n
-- Int.coe_castAddHom
@[simp] lemma coe_castAddHom : ⇑(castAddHom α) = fun x : ℤ => (x : α) 
Arguments: {α : Type u_3} [AddGroupWithOne α]
Goal: ⇑(Int.castAddHom α) = fun x => ↑x
-- Even.intCast
lemma _root_.Even.intCast {n : ℤ} (h : Even n) : Even (n : α) 
Arguments: {α : Type u_3} [AddGroupWithOne α] {n : ℤ} (h : Even n)
Goal: Even ↑n
-- Int.cast_eq_zero
@[simp] lemma cast_eq_zero : (n : α) = 0 ↔ n = 0 
Arguments: {α : Type u_3} [AddGroupWithOne α] [CharZero α] {n : ℤ}
Goal: ↑n = 0 ↔ n = 0
-- Int.cast_inj
@[simp, norm_cast]
lemma cast_inj : (m : α) = n ↔ m = n 
Arguments: {α : Type u_3} [AddGroupWithOne α] [CharZero α] {m n : ℤ}
Goal: ↑m = ↑n ↔ m = n
-- Int.cast_injective
lemma cast_injective : Injective (Int.cast : ℤ → α) 
Arguments: {α : Type u_3} [AddGroupWithOne α] [CharZero α]
Goal: Function.Injective Int.cast
-- Int.cast_ne_zero
lemma cast_ne_zero : (n : α) ≠ 0 ↔ n ≠ 0 
Arguments: {α : Type u_3} [AddGroupWithOne α] [CharZero α] {n : ℤ}
Goal: ↑n ≠ 0 ↔ n ≠ 0
-- Int.cast_eq_one
@[simp] lemma cast_eq_one : (n : α) = 1 ↔ n = 1 
Arguments: {α : Type u_3} [AddGroupWithOne α] [CharZero α] {n : ℤ}
Goal: ↑n = 1 ↔ n = 1
-- Int.cast_ne_one
lemma cast_ne_one : (n : α) ≠ 1 ↔ n ≠ 1 
Arguments: {α : Type u_3} [AddGroupWithOne α] [CharZero α] {n : ℤ}
Goal: ↑n ≠ 1 ↔ n ≠ 1
-- Int.coe_castRingHom
@[simp] lemma coe_castRingHom : ⇑(castRingHom α) = fun x : ℤ ↦ (x : α) 
Arguments: {α : Type u_3} [NonAssocRing α]
Goal: ⇑(Int.castRingHom α) = fun x => ↑x
-- Int.cast_commute
lemma cast_commute : ∀ (n : ℤ) (a : α), Commute ↑n a
  
Arguments: {α : Type u_3} [NonAssocRing α] (n : ℤ) (a : α)
Goal: Commute (↑n) a
-- Int.cast_comm
lemma cast_comm (n : ℤ) (x : α) : n * x = x * n 
Arguments: {α : Type u_3} [NonAssocRing α] (n : ℤ) (x : α)
Goal: ↑n * x = x * ↑n
-- Int.commute_cast
lemma commute_cast (a : α) (n : ℤ) : Commute a n 
Arguments: {α : Type u_3} [NonAssocRing α] (a : α) (n : ℤ)
Goal: Commute a ↑n
-- zsmul_eq_mul
@[simp] lemma _root_.zsmul_eq_mul (a : α) : ∀ n : ℤ, n • a = n * a
  
Arguments: {α : Type u_3} [NonAssocRing α] (a : α) (n : ℤ)
Goal: n • a = ↑n * a
-- zsmul_eq_mul'
lemma _root_.zsmul_eq_mul' (a : α) (n : ℤ) : n • a = a * n 
Arguments: {α : Type u_3} [NonAssocRing α] (a : α) (n : ℤ)
Goal: n • a = a * ↑n
-- Odd.intCast
lemma _root_.Odd.intCast (hn : Odd n) : Odd (n : α) 
Arguments: {α : Type u_3} [Ring α] {n : ℤ} (hn : Odd n)
Goal: Odd ↑n
-- Int.cast_dvd_cast
theorem cast_dvd_cast [CommRing α] (m n : ℤ) (h : m ∣ n) : (m : α) ∣ (n : α) 
Arguments: {α : Type u_3} [CommRing α] (m n : ℤ) (h : m ∣ n)
Goal: ↑m ∣ ↑n
-- SemiconjBy.intCast_mul_right
@[simp] lemma intCast_mul_right (h : SemiconjBy a x y) (n : ℤ) : SemiconjBy a (n * x) (n * y) 
Arguments: {α : Type u_3} [Ring α] {a x y : α} (h : SemiconjBy a x y) (n : ℤ)
Goal: SemiconjBy a (↑n * x) (↑n * y)
-- SemiconjBy.intCast_mul_left
@[simp] lemma intCast_mul_left (h : SemiconjBy a x y) (n : ℤ) : SemiconjBy (n * a) x y 
Arguments: {α : Type u_3} [Ring α] {a x y : α} (h : SemiconjBy a x y) (n : ℤ)
Goal: SemiconjBy (↑n * a) x y
-- SemiconjBy.intCast_mul_intCast_mul
@[simp] lemma intCast_mul_intCast_mul (h : SemiconjBy a x y) (m n : ℤ) :
    SemiconjBy (m * a) (n * x) (n * y) 
Arguments: {α : Type u_3} [Ring α] {a x y : α} (h : SemiconjBy a x y) (m n : ℤ)
Goal: SemiconjBy (↑m * a) (↑n * x) (↑n * y)
-- Commute.intCast_left
@[simp] lemma intCast_left : Commute (n : α) a 
Arguments: {α : Type u_3} [NonAssocRing α] {a : α} {n : ℤ}
Goal: Commute (↑n) a
-- Commute.intCast_right
@[simp] lemma intCast_right : Commute a n 
Arguments: {α : Type u_3} [NonAssocRing α] {a : α} {n : ℤ}
Goal: Commute a ↑n
-- Commute.intCast_mul_right
@[simp] lemma intCast_mul_right (h : Commute a b) (m : ℤ) : Commute a (m * b) 
Arguments: {α : Type u_3} [Ring α] {a b : α} (h : Commute a b) (m : ℤ)
Goal: Commute a (↑m * b)
-- Commute.intCast_mul_left
@[simp] lemma intCast_mul_left (h : Commute a b) (m : ℤ) : Commute (m  * a) b 
Arguments: {α : Type u_3} [Ring α] {a b : α} (h : Commute a b) (m : ℤ)
Goal: Commute (↑m * a) b
-- Commute.intCast_mul_intCast_mul
lemma intCast_mul_intCast_mul (h : Commute a b) (m n : ℤ) : Commute (m * a) (n * b) 
Arguments: {α : Type u_3} [Ring α] {a b : α} (h : Commute a b) (m n : ℤ)
Goal: Commute (↑m * a) (↑n * b)
-- Commute.self_intCast_mul
lemma self_intCast_mul : Commute a (n * a : α) 
Arguments: {α : Type u_3} [Ring α] (a : α) (n : ℤ)
Goal: Commute a (↑n * a)
-- Commute.intCast_mul_self
lemma intCast_mul_self : Commute ((n : α) * a) a 
Arguments: {α : Type u_3} [Ring α] (a : α) (n : ℤ)
Goal: Commute (↑n * a) a
-- Commute.self_intCast_mul_intCast_mul
lemma self_intCast_mul_intCast_mul : Commute (m * a : α) (n * a : α) 
Arguments: {α : Type u_3} [Ring α] (a : α) (m n : ℤ)
Goal: Commute (↑m * a) (↑n * a)
-- AddMonoidHom.ext_int
@[ext high]
theorem ext_int [AddMonoid A] {f g : ℤ →+ A} (h1 : f 1 = g 1) : f = g 
Arguments: {A : Type u_5} [AddMonoid A] {f g : ℤ →+ A} (h1 : f 1 = g 1)
Goal: f = g
-- AddMonoidHom.eq_intCastAddHom
theorem eq_intCastAddHom (f : ℤ →+ A) (h1 : f 1 = 1) : f = Int.castAddHom A 
Arguments: {A : Type u_5} [AddGroupWithOne A] (f : ℤ →+ A) (h1 : f 1 = 1)
Goal: f = Int.castAddHom A
-- eq_intCast'
theorem eq_intCast' [AddGroupWithOne α] [FunLike F ℤ α] [AddMonoidHomClass F ℤ α]
    (f : F) (h₁ : f 1 = 1) :
    ∀ n : ℤ, f n = n 
Arguments: {F : Type u_1} {α : Type u_3} [AddGroupWithOne α] [FunLike F ℤ α] [AddMonoidHomClass F ℤ α] (f : F) (h₁ : f 1 = 1) (n : ℤ)
Goal: f n = ↑n
-- zsmul_one
@[simp] lemma zsmul_one [AddGroupWithOne α] (n : ℤ) : n • (1 : α) = n 
Arguments: {α : Type u_3} [AddGroupWithOne α] (n : ℤ)
Goal: n • 1 = ↑n
-- Int.castAddHom_int
@[simp]
theorem Int.castAddHom_int : Int.castAddHom ℤ = AddMonoidHom.id ℤ 
Goal: Int.castAddHom ℤ = AddMonoidHom.id ℤ
-- MonoidHom.ext_mint
@[ext]
theorem ext_mint {f g : Multiplicative ℤ →* M} (h1 : f (ofAdd 1) = g (ofAdd 1)) : f = g 
Arguments: {M : Type u_5} [Monoid M] {f g : Multiplicative ℤ →* M} (h1 : f (Multiplicative.ofAdd 1) = g (Multiplicative.ofAdd 1))
Goal: f = g
-- MonoidHom.ext_int
@[ext]
theorem ext_int {f g : ℤ →* M} (h_neg_one : f (-1) = g (-1))
    (h_nat : f.comp Int.ofNatHom.toMonoidHom = g.comp Int.ofNatHom.toMonoidHom) : f = g 
Arguments: {M : Type u_5} [Monoid M] {f g : ℤ →* M} (h_neg_one : f (-1) = g (-1)) (h_nat : f.comp ↑Int.ofNatHom = g.comp ↑Int.ofNatHom)
Goal: f = g
-- MonoidWithZeroHom.ext_int
@[ext]
theorem ext_int {f g : ℤ →*₀ M} (h_neg_one : f (-1) = g (-1))
    (h_nat : f.comp Int.ofNatHom.toMonoidWithZeroHom = g.comp Int.ofNatHom.toMonoidWithZeroHom) :
    f = g 
Arguments: {M : Type u_5} [MonoidWithZero M] {f g : ℤ →*₀ M} (h_neg_one : f (-1) = g (-1)) (h_nat : f.comp Int.ofNatHom.toMonoidWithZeroHom = g.comp Int.ofNatHom.toMonoidWithZeroHom)
Goal: f = g
-- ext_int'
theorem ext_int' [MonoidWithZero α] [FunLike F ℤ α] [MonoidWithZeroHomClass F ℤ α] {f g : F}
    (h_neg_one : f (-1) = g (-1)) (h_pos : ∀ n : ℕ, 0 < n → f n = g n) : f = g 
Arguments: {F : Type u_1} {α : Type u_3} [MonoidWithZero α] [FunLike F ℤ α] [MonoidWithZeroHomClass F ℤ α] {f g : F} (h_neg_one : f (-1) = g (-1)) (h_pos : ∀ (n : ℕ), 0 < n → f ↑n = g ↑n)
Goal: f = g
-- zmultiplesHom_apply
lemma zmultiplesHom_apply (x : β) (n : ℤ) : zmultiplesHom β x n = n • x 
Arguments: (β : Type u_4) [AddGroup β] (x : β) (n : ℤ)
Goal: ((zmultiplesHom β) x) n = n • x
-- zmultiplesHom_symm_apply
lemma zmultiplesHom_symm_apply (f : ℤ →+ β) : (zmultiplesHom β).symm f = f 1 
Arguments: (β : Type u_4) [AddGroup β] (f : ℤ →+ β)
Goal: (zmultiplesHom β).symm f = f 1
-- zpowersHom_apply
@[to_additive existing (attr := simp)]
lemma zpowersHom_apply (x : α) (n : Multiplicative ℤ) : zpowersHom α x n = x ^ toAdd n 
Arguments: (α : Type u_3) [Group α] (x : α) (n : Multiplicative ℤ)
Goal: ((zpowersHom α) x) n = x ^ Multiplicative.toAdd n
-- zpowersHom_symm_apply
@[to_additive existing (attr := simp)]
lemma zpowersHom_symm_apply (f : Multiplicative ℤ →* α) :
    (zpowersHom α).symm f = f (ofAdd 1) 
Arguments: (α : Type u_3) [Group α] (f : Multiplicative ℤ →* α)
Goal: (zpowersHom α).symm f = f (Multiplicative.ofAdd 1)