File: Mathlib/Order/Fin/Tuple.lean

full_name: Fin.pi_lex_lt_cons_cons
code: lemma pi_lex_lt_cons_cons {x₀ y₀ : α 0} {x y : ∀ i : Fin n, α i.succ}
    (s : ∀ {i : Fin n.succ}, α i → α i → Prop) :
    Pi.Lex (· < ·) (@s) (Fin.cons x₀ x) (Fin.cons y₀ y) ↔
      s x₀ y₀ ∨ x₀ = y₀ ∧ Pi.Lex (· < ·) (@fun i : Fin n ↦ @s i.succ) x y 
goal: Pi.Lex (fun x x_1 => x < x_1) s (Fin.cons x₀ x) (Fin.cons y₀ y) ↔
  s x₀ y₀ ∨ x₀ = y₀ ∧ Pi.Lex (fun x x_1 => x < x_1) (fun i => s) x y

full_name: Fin.insertNth_mem_Icc
code: lemma insertNth_mem_Icc {i : Fin (n + 1)} {x : α i} {p : ∀ j, α (i.succAbove j)}
    {q₁ q₂ : ∀ j, α j} :
    i.insertNth x p ∈ Icc q₁ q₂ ↔
      x ∈ Icc (q₁ i) (q₂ i) ∧ p ∈ Icc (fun j ↦ q₁ (i.succAbove j)) fun j ↦ q₂ (i.succAbove j) 
goal: i.insertNth x p ∈ Set.Icc q₁ q₂ ↔
  x ∈ Set.Icc (q₁ i) (q₂ i) ∧ p ∈ Set.Icc (fun j => q₁ (i.succAbove j)) fun j => q₂ (i.succAbove j)

full_name: Fin.preimage_insertNth_Icc_of_mem
code: lemma preimage_insertNth_Icc_of_mem {i : Fin (n + 1)} {x : α i} {q₁ q₂ : ∀ j, α j}
    (hx : x ∈ Icc (q₁ i) (q₂ i)) :
    i.insertNth x ⁻¹' Icc q₁ q₂ = Icc (fun j ↦ q₁ (i.succAbove j)) fun j ↦ q₂ (i.succAbove j) 
goal: i.insertNth x ⁻¹' Set.Icc q₁ q₂ = Set.Icc (fun j => q₁ (i.succAbove j)) fun j => q₂ (i.succAbove j)

full_name: Fin.preimage_insertNth_Icc_of_not_mem
code: lemma preimage_insertNth_Icc_of_not_mem {i : Fin (n + 1)} {x : α i} {q₁ q₂ : ∀ j, α j}
    (hx : x ∉ Icc (q₁ i) (q₂ i)) : i.insertNth x ⁻¹' Icc q₁ q₂ = ∅ 
goal: i.insertNth x ⁻¹' Set.Icc q₁ q₂ = ∅

full_name: liftFun_vecCons
code: lemma liftFun_vecCons {n : ℕ} (r : α → α → Prop) [IsTrans α r] {f : Fin (n + 1) → α} {a : α} :
    ((· < ·) ⇒ r) (vecCons a f) (vecCons a f) ↔ r a (f 0) ∧ ((· < ·) ⇒ r) f f 
goal: ((fun x x_1 => x < x_1) ⇒ r) (Matrix.vecCons a f) (Matrix.vecCons a f) ↔ r a (f 0) ∧ ((fun x x_1 => x < x_1) ⇒ r) f f

full_name: strictMono_vecCons
code: @[simp] lemma strictMono_vecCons : StrictMono (vecCons a f) ↔ a < f 0 ∧ StrictMono f 
goal: StrictMono (Matrix.vecCons a f) ↔ a < f 0 ∧ StrictMono f

full_name: monotone_vecCons
code: @[simp]
lemma monotone_vecCons : Monotone (vecCons a f) ↔ a ≤ f 0 ∧ Monotone f 
goal: Monotone (Matrix.vecCons a f) ↔ a ≤ f 0 ∧ Monotone f

full_name: monotone_vecEmpty
code: @[simp] lemma monotone_vecEmpty : Monotone ![a]
  
goal: Monotone ![a]

full_name: strictMono_vecEmpty
code: @[simp] lemma strictMono_vecEmpty : StrictMono ![a]
  
goal: StrictMono ![a]

full_name: strictAnti_vecCons
code: @[simp] lemma strictAnti_vecCons : StrictAnti (vecCons a f) ↔ f 0 < a ∧ StrictAnti f 
goal: StrictAnti (Matrix.vecCons a f) ↔ f 0 < a ∧ StrictAnti f

full_name: antitone_vecCons
code: @[simp] lemma antitone_vecCons : Antitone (vecCons a f) ↔ f 0 ≤ a ∧ Antitone f 
goal: Antitone (Matrix.vecCons a f) ↔ f 0 ≤ a ∧ Antitone f

full_name: antitone_vecEmpty
code: @[simp] lemma antitone_vecEmpty : Antitone (vecCons a vecEmpty)
  
goal: Antitone ![a]

full_name: strictAnti_vecEmpty
code: @[simp] lemma strictAnti_vecEmpty : StrictAnti (vecCons a vecEmpty)
  
goal: StrictAnti ![a]

full_name: StrictMono.vecCons
code: lemma StrictMono.vecCons (hf : StrictMono f) (ha : a < f 0) : StrictMono (vecCons a f) 
goal: StrictMono (Matrix.vecCons a f)

full_name: StrictAnti.vecCons
code: lemma StrictAnti.vecCons (hf : StrictAnti f) (ha : f 0 < a) : StrictAnti (vecCons a f) 
goal: StrictAnti (Matrix.vecCons a f)

full_name: Monotone.vecCons
code: lemma Monotone.vecCons (hf : Monotone f) (ha : a ≤ f 0) : Monotone (vecCons a f) 
goal: Monotone (Matrix.vecCons a f)

full_name: Antitone.vecCons
code: lemma Antitone.vecCons (hf : Antitone f) (ha : f 0 ≤ a) : Antitone (vecCons a f) 
goal: Antitone (Matrix.vecCons a f)

full_name: OrderIso.piFinTwoIso
code: /-- `Π i : Fin 2, α i` is order equivalent to `α 0 × α 1`. See also `OrderIso.finTwoArrowEquiv`
for a non-dependent version. -/
def OrderIso.piFinTwoIso (α : Fin 2 → Type*) [∀ i, Preorder (α i)] : (∀ i, α i) ≃o α 0 × α 1 
goal: ((i : Fin 2) → α i) ≃o α 0 × α 1

full_name: OrderIso.finTwoArrowIso
code: /-- The space of functions `Fin 2 → α` is order equivalent to `α × α`. See also
`OrderIso.piFinTwoIso`. -/
def OrderIso.finTwoArrowIso (α : Type*) [Preorder α] : (Fin 2 → α) ≃o α × α 
goal: (Fin 2 → α) ≃o α × α

full_name: OrderIso.piFinSuccAboveIso
code: /-- Order isomorphism between `Π j : Fin (n + 1), α j` and
`α i × Π j : Fin n, α (Fin.succAbove i j)`. -/
def OrderIso.piFinSuccAboveIso (α : Fin (n + 1) → Type*) [∀ i, LE (α i)]
    (i : Fin (n + 1)) : (∀ j, α j) ≃o α i × ∀ j, α (i.succAbove j) 
goal: ((j : Fin (n + 1)) → α j) ≃o α i × ((j : Fin n) → α (i.succAbove j))

full_name: finSuccAboveOrderIso
code: /-- `Fin.succAbove` as an order isomorphism between `Fin n` and `{x : Fin (n + 1) // x ≠ p}`. -/
def finSuccAboveOrderIso (p : Fin (n + 1)) : Fin n ≃o { x : Fin (n + 1) // x ≠ p } 
goal: Fin n ≃o { x // x ≠ p }

full_name: finSuccAboveOrderIso_apply
code: lemma finSuccAboveOrderIso_apply (p : Fin (n + 1)) (i : Fin n) :
    finSuccAboveOrderIso p i = ⟨p.succAbove i, p.succAbove_ne i⟩ 
goal: (finSuccAboveOrderIso p) i = ⟨p.succAbove i, ⋯⟩

full_name: finSuccAboveOrderIso_symm_apply_last
code: lemma finSuccAboveOrderIso_symm_apply_last (x : { x : Fin (n + 1) // x ≠ Fin.last n }) :
    (finSuccAboveOrderIso (Fin.last n)).symm x = Fin.castLT x.1 (Fin.val_lt_last x.2) 
goal: (finSuccAboveOrderIso (Fin.last n)).symm x = (↑x).castLT ⋯

full_name: finSuccAboveOrderIso_symm_apply_ne_last
code: lemma finSuccAboveOrderIso_symm_apply_ne_last {p : Fin (n + 1)} (h : p ≠ Fin.last n)
    (x : { x : Fin (n + 1) // x ≠ p }) :
    (finSuccAboveEquiv p).symm x = (p.castLT (Fin.val_lt_last h)).predAbove x 
goal: (finSuccAboveEquiv p).symm x = (p.castLT ⋯).predAbove ↑x

full_name: Fin.castLEOrderIso_symm_apply
code: /-- Promote a `Fin n` into a larger `Fin m`, as a subtype where the underlying
values are retained. This is the `OrderIso` version of `Fin.castLE`. -/
@[simps apply symm_apply]
def Fin.castLEOrderIso {n m : ℕ} (h : n ≤ m) : Fin n ≃o { i : Fin m // (i : ℕ) < n } 
goal: (RelIso.symm (Fin.castLEOrderIso h)) i = ⟨↑↑i, ⋯⟩

full_name: Fin.castLEOrderIso
code: /-- Promote a `Fin n` into a larger `Fin m`, as a subtype where the underlying
values are retained. This is the `OrderIso` version of `Fin.castLE`. -/
@[simps apply symm_apply]
def Fin.castLEOrderIso {n m : ℕ} (h : n ≤ m) : Fin n ≃o { i : Fin m // (i : ℕ) < n } 
goal: Fin n ≃o { i // ↑i < n }

full_name: Fin.castLEOrderIso_apply
code: /-- Promote a `Fin n` into a larger `Fin m`, as a subtype where the underlying
values are retained. This is the `OrderIso` version of `Fin.castLE`. -/
@[simps apply symm_apply]
def Fin.castLEOrderIso {n m : ℕ} (h : n ≤ m) : Fin n ≃o { i : Fin m // (i : ℕ) < n } 
goal: (Fin.castLEOrderIso h) i = ⟨Fin.castLE h i, ⋯⟩