File: .lake/packages/lean4/src/lean/Lean/Elab/Tactic/Omega/MinNatAbs.lean

full_name: List.nonzeroMinimum
code: /--
The minimum non-zero entry in a list of natural numbers, or zero if all entries are zero.

We completely characterize the function via
`nonzeroMinimum_eq_zero_iff` and `nonzeroMinimum_eq_nonzero_iff` below.
-/
def nonzeroMinimum (xs : List Nat) : Nat 
goal: Nat

full_name: List.minimum?_eq_some_iff'
code: theorem minimum?_eq_some_iff' {xs : List Nat} :
    xs.minimum? = some a ↔ (a ∈ xs ∧ ∀ b ∈ xs, a ≤ b) 
goal: xs.minimum? = some a ↔ a ∈ xs ∧ ∀ (b : Nat), b ∈ xs → a ≤ b

full_name: List.nonzeroMinimum_eq_zero_iff
code: @[simp] theorem nonzeroMinimum_eq_zero_iff {xs : List Nat} :
    xs.nonzeroMinimum = 0 ↔ ∀ x ∈ xs, x = 0 
goal: xs.nonzeroMinimum = 0 ↔ ∀ (x : Nat), x ∈ xs → x = 0

full_name: List.nonzeroMinimum_mem
code: theorem nonzeroMinimum_mem {xs : List Nat} (w : xs.nonzeroMinimum ≠ 0) :
    xs.nonzeroMinimum ∈ xs 
goal: xs.nonzeroMinimum ∈ xs

full_name: List.nonzeroMinimum_pos
code: theorem nonzeroMinimum_pos {xs : List Nat} (m : a ∈ xs) (h : a ≠ 0) : 0 < xs.nonzeroMinimum 
goal: 0 < xs.nonzeroMinimum

full_name: List.nonzeroMinimum_le
code: theorem nonzeroMinimum_le {xs : List Nat} (m : a ∈ xs) (h : a ≠ 0) : xs.nonzeroMinimum ≤ a 
goal: xs.nonzeroMinimum ≤ a

full_name: List.nonzeroMinimum_eq_nonzero_iff
code: theorem nonzeroMinimum_eq_nonzero_iff {xs : List Nat} {y : Nat} (h : y ≠ 0) :
    xs.nonzeroMinimum = y ↔ y ∈ xs ∧ (∀ x ∈ xs, y ≤ x ∨ x = 0) 
goal: xs.nonzeroMinimum = y ↔ y ∈ xs ∧ ∀ (x : Nat), x ∈ xs → y ≤ x ∨ x = 0

full_name: List.nonzeroMinimum_eq_of_nonzero
code: theorem nonzeroMinimum_eq_of_nonzero {xs : List Nat} (h : xs.nonzeroMinimum ≠ 0) :
    ∃ x ∈ xs, xs.nonzeroMinimum = x 
goal: ∃ x, x ∈ xs ∧ xs.nonzeroMinimum = x

full_name: List.nonzeroMinimum_le_iff
code: theorem nonzeroMinimum_le_iff {xs : List Nat} {y : Nat} :
    xs.nonzeroMinimum ≤ y ↔ xs.nonzeroMinimum = 0 ∨ ∃ x ∈ xs, x ≤ y ∧ x ≠ 0 
goal: xs.nonzeroMinimum ≤ y ↔ xs.nonzeroMinimum = 0 ∨ ∃ x, x ∈ xs ∧ x ≤ y ∧ x ≠ 0

full_name: List.nonzeroMininum_map_le_nonzeroMinimum
code: theorem nonzeroMininum_map_le_nonzeroMinimum (f : α → β) (p : α → Nat) (q : β → Nat) (xs : List α)
    (h : ∀ a, a ∈ xs → (p a = 0 ↔ q (f a) = 0))
    (w : ∀ a, a ∈ xs → p a ≠ 0 → q (f a) ≤ p a) :
    ((xs.map f).map q).nonzeroMinimum ≤ (xs.map p).nonzeroMinimum 
goal: (List.map q (List.map f xs)).nonzeroMinimum ≤ (List.map p xs).nonzeroMinimum

full_name: List.minNatAbs
code: /--
The minimum absolute value of a nonzero entry, or zero if all entries are zero.

We completely characterize the function via
`minNatAbs_eq_zero_iff` and `minNatAbs_eq_nonzero_iff` below.
-/
def minNatAbs (xs : List Int) : Nat 
goal: Nat

full_name: List.minNatAbs_eq_zero_iff
code: @[simp] theorem minNatAbs_eq_zero_iff {xs : List Int} : xs.minNatAbs = 0 ↔ ∀ y ∈ xs, y = 0 
goal: xs.minNatAbs = 0 ↔ ∀ (y : Int), y ∈ xs → y = 0

full_name: List.minNatAbs_eq_nonzero_iff
code: theorem minNatAbs_eq_nonzero_iff (xs : List Int) (w : z ≠ 0) :
    xs.minNatAbs = z ↔ (∃ y ∈ xs, y.natAbs = z) ∧ (∀ y ∈ xs, z ≤ y.natAbs ∨ y = 0) 
goal: xs.minNatAbs = z ↔ (∃ y, y ∈ xs ∧ y.natAbs = z) ∧ ∀ (y : Int), y ∈ xs → z ≤ y.natAbs ∨ y = 0

full_name: List.minNatAbs_nil
code: @[simp] theorem minNatAbs_nil : ([] : List Int).minNatAbs = 0 
goal: [].minNatAbs = 0

full_name: List.maxNatAbs
code: /-- The maximum absolute value in a list of integers. -/
def maxNatAbs (xs : List Int) : Nat 
goal: Nat