Theorem: Tuple.lt_card_le_iff_apply_le_of_monotone
File: Mathlib/Data/Fin/Tuple/Sort.lean

tactic: suffices h1 : ∀ k : Fin m, (k < Fintype.card {i // f i ≤ a}) → f k ≤ a by
  refine ⟨h1 j, fun h ↦ ?_⟩
  by_contra! hc
  let p : Fin m → Prop := fun x ↦ f x ≤ a
  let q : Fin m → Prop := fun x ↦ x < Fintype.card {i // f i ≤ a}
  let q' : {i // f i ≤ a} → Prop := fun x ↦ q x
  have hw : 0 < Fintype.card {j : {x : Fin m // f x ≤ a} // ¬ q' j} :=
    Fintype.card_pos_iff.2 ⟨⟨⟨j, h⟩, not_lt.2 hc⟩⟩
  apply hw.ne'
  have he := Fintype.card_congr <| Equiv.sumCompl <| q'
  have h4 := (Fintype.card_congr (@Equiv.subtypeSubtypeEquivSubtype _ p q (h1 _)))
  have h_le : Fintype.card { i // f i ≤ a } ≤ m := by
    conv_rhs => rw [← Fintype.card_fin m]
    exact Fintype.card_subtype_le _
  rwa [Fintype.card_sum, h4, Fintype.card_fin_lt_of_le h_le, add_right_eq_self] at he
state_before: n : ℕ
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : DecidableRel LE.le
m : ℕ
f : Fin m → α
a : α
h_sorted : Monotone f
j : Fin m
⊢ ↑j < Fintype.card { i // f i ≤ a } ↔ f j ≤ a
state_after: n : ℕ
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : DecidableRel LE.le
m : ℕ
f : Fin m → α
a : α
h_sorted : Monotone f
j : Fin m
⊢ ∀ (k : Fin m), ↑k < Fintype.card { i // f i ≤ a } → f k ≤ a

tactic: intro _ h
state_before: n : ℕ
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : DecidableRel LE.le
m : ℕ
f : Fin m → α
a : α
h_sorted : Monotone f
j : Fin m
⊢ ∀ (k : Fin m), ↑k < Fintype.card { i // f i ≤ a } → f k ≤ a
state_after: n : ℕ
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : DecidableRel LE.le
m : ℕ
f : Fin m → α
a : α
h_sorted : Monotone f
j k✝ : Fin m
h : ↑k✝ < Fintype.card { i // f i ≤ a }
⊢ f k✝ ≤ a

tactic: contrapose! h
state_before: n : ℕ
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : DecidableRel LE.le
m : ℕ
f : Fin m → α
a : α
h_sorted : Monotone f
j k✝ : Fin m
h : ↑k✝ < Fintype.card { i // f i ≤ a }
⊢ f k✝ ≤ a
state_after: n : ℕ
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : DecidableRel LE.le
m : ℕ
f : Fin m → α
a : α
h_sorted : Monotone f
j k✝ : Fin m
h : ¬f k✝ ≤ a
⊢ Fintype.card { i // f i ≤ a } ≤ ↑k✝

tactic: rw [← Fin.card_Iio, Fintype.card_subtype]
state_before: n : ℕ
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : DecidableRel LE.le
m : ℕ
f : Fin m → α
a : α
h_sorted : Monotone f
j k✝ : Fin m
h : ¬f k✝ ≤ a
⊢ Fintype.card { i // f i ≤ a } ≤ ↑k✝
state_after: n : ℕ
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : DecidableRel LE.le
m : ℕ
f : Fin m → α
a : α
h_sorted : Monotone f
j k✝ : Fin m
h : ¬f k✝ ≤ a
⊢ (Finset.filter (fun i => f i ≤ a) Finset.univ).card ≤ (Finset.Iio k✝).card

tactic: refine Finset.card_mono (fun i => Function.mtr ?_)
state_before: n : ℕ
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : DecidableRel LE.le
m : ℕ
f : Fin m → α
a : α
h_sorted : Monotone f
j k✝ : Fin m
h : ¬f k✝ ≤ a
⊢ (Finset.filter (fun i => f i ≤ a) Finset.univ).card ≤ (Finset.Iio k✝).card
state_after: n : ℕ
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : DecidableRel LE.le
m : ℕ
f : Fin m → α
a : α
h_sorted : Monotone f
j k✝ : Fin m
h : ¬f k✝ ≤ a
i : Fin m
⊢ i ∉ Finset.Iio k✝ → i ∉ Finset.filter (fun i => f i ≤ a) Finset.univ

tactic: simp_rw [Finset.mem_filter, Finset.mem_univ, true_and, Finset.mem_Iio]
state_before: n : ℕ
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : DecidableRel LE.le
m : ℕ
f : Fin m → α
a : α
h_sorted : Monotone f
j k✝ : Fin m
h : ¬f k✝ ≤ a
i : Fin m
⊢ i ∉ Finset.Iio k✝ → i ∉ Finset.filter (fun i => f i ≤ a) Finset.univ
state_after: n : ℕ
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : DecidableRel LE.le
m : ℕ
f : Fin m → α
a : α
h_sorted : Monotone f
j k✝ : Fin m
h : ¬f k✝ ≤ a
i : Fin m
⊢ ¬i < k✝ → ¬f i ≤ a

tactic: intro hij hia
state_before: n : ℕ
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : DecidableRel LE.le
m : ℕ
f : Fin m → α
a : α
h_sorted : Monotone f
j k✝ : Fin m
h : ¬f k✝ ≤ a
i : Fin m
⊢ ¬i < k✝ → ¬f i ≤ a
state_after: n : ℕ
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : DecidableRel LE.le
m : ℕ
f : Fin m → α
a : α
h_sorted : Monotone f
j k✝ : Fin m
h : ¬f k✝ ≤ a
i : Fin m
hij : ¬i < k✝
hia : f i ≤ a
⊢ False

tactic: apply h
state_before: n : ℕ
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : DecidableRel LE.le
m : ℕ
f : Fin m → α
a : α
h_sorted : Monotone f
j k✝ : Fin m
h : ¬f k✝ ≤ a
i : Fin m
hij : ¬i < k✝
hia : f i ≤ a
⊢ False
state_after: n : ℕ
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : DecidableRel LE.le
m : ℕ
f : Fin m → α
a : α
h_sorted : Monotone f
j k✝ : Fin m
h : ¬f k✝ ≤ a
i : Fin m
hij : ¬i < k✝
hia : f i ≤ a
⊢ f k✝ ≤ a

tactic: exact (h_sorted (le_of_not_lt hij)).trans hia
state_before: n : ℕ
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : DecidableRel LE.le
m : ℕ
f : Fin m → α
a : α
h_sorted : Monotone f
j k✝ : Fin m
h : ¬f k✝ ≤ a
i : Fin m
hij : ¬i < k✝
hia : f i ≤ a
⊢ f k✝ ≤ a
state_after: no goals

tactic: refine ⟨h1 j, fun h ↦ ?_⟩
state_before: n : ℕ
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : DecidableRel LE.le
m : ℕ
f : Fin m → α
a : α
h_sorted : Monotone f
j : Fin m
h1 : ∀ (k : Fin m), ↑k < Fintype.card { i // f i ≤ a } → f k ≤ a
⊢ ↑j < Fintype.card { i // f i ≤ a } ↔ f j ≤ a
state_after: n : ℕ
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : DecidableRel LE.le
m : ℕ
f : Fin m → α
a : α
h_sorted : Monotone f
j : Fin m
h1 : ∀ (k : Fin m), ↑k < Fintype.card { i // f i ≤ a } → f k ≤ a
h : f j ≤ a
⊢ ↑j < Fintype.card { i // f i ≤ a }

tactic: by_contra! hc
state_before: n : ℕ
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : DecidableRel LE.le
m : ℕ
f : Fin m → α
a : α
h_sorted : Monotone f
j : Fin m
h1 : ∀ (k : Fin m), ↑k < Fintype.card { i // f i ≤ a } → f k ≤ a
h : f j ≤ a
⊢ ↑j < Fintype.card { i // f i ≤ a }
state_after: n : ℕ
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : DecidableRel LE.le
m : ℕ
f : Fin m → α
a : α
h_sorted : Monotone f
j : Fin m
h1 : ∀ (k : Fin m), ↑k < Fintype.card { i // f i ≤ a } → f k ≤ a
h : f j ≤ a
hc : Fintype.card { i // f i ≤ a } ≤ ↑j
⊢ False

tactic: let p : Fin m → Prop := fun x ↦ f x ≤ a
state_before: n : ℕ
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : DecidableRel LE.le
m : ℕ
f : Fin m → α
a : α
h_sorted : Monotone f
j : Fin m
h1 : ∀ (k : Fin m), ↑k < Fintype.card { i // f i ≤ a } → f k ≤ a
h : f j ≤ a
hc : Fintype.card { i // f i ≤ a } ≤ ↑j
⊢ False
state_after: n : ℕ
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : DecidableRel LE.le
m : ℕ
f : Fin m → α
a : α
h_sorted : Monotone f
j : Fin m
h1 : ∀ (k : Fin m), ↑k < Fintype.card { i // f i ≤ a } → f k ≤ a
h : f j ≤ a
hc : Fintype.card { i // f i ≤ a } ≤ ↑j
p : Fin m → Prop := fun x => f x ≤ a
⊢ False

tactic: let q : Fin m → Prop := fun x ↦ x < Fintype.card {i // f i ≤ a}
state_before: n : ℕ
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : DecidableRel LE.le
m : ℕ
f : Fin m → α
a : α
h_sorted : Monotone f
j : Fin m
h1 : ∀ (k : Fin m), ↑k < Fintype.card { i // f i ≤ a } → f k ≤ a
h : f j ≤ a
hc : Fintype.card { i // f i ≤ a } ≤ ↑j
p : Fin m → Prop := fun x => f x ≤ a
⊢ False
state_after: n : ℕ
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : DecidableRel LE.le
m : ℕ
f : Fin m → α
a : α
h_sorted : Monotone f
j : Fin m
h1 : ∀ (k : Fin m), ↑k < Fintype.card { i // f i ≤ a } → f k ≤ a
h : f j ≤ a
hc : Fintype.card { i // f i ≤ a } ≤ ↑j
p : Fin m → Prop := fun x => f x ≤ a
q : Fin m → Prop := fun x => ↑x < Fintype.card { i // f i ≤ a }
⊢ False

tactic: let q' : {i // f i ≤ a} → Prop := fun x ↦ q x
state_before: n : ℕ
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : DecidableRel LE.le
m : ℕ
f : Fin m → α
a : α
h_sorted : Monotone f
j : Fin m
h1 : ∀ (k : Fin m), ↑k < Fintype.card { i // f i ≤ a } → f k ≤ a
h : f j ≤ a
hc : Fintype.card { i // f i ≤ a } ≤ ↑j
p : Fin m → Prop := fun x => f x ≤ a
q : Fin m → Prop := fun x => ↑x < Fintype.card { i // f i ≤ a }
⊢ False
state_after: n : ℕ
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : DecidableRel LE.le
m : ℕ
f : Fin m → α
a : α
h_sorted : Monotone f
j : Fin m
h1 : ∀ (k : Fin m), ↑k < Fintype.card { i // f i ≤ a } → f k ≤ a
h : f j ≤ a
hc : Fintype.card { i // f i ≤ a } ≤ ↑j
p : Fin m → Prop := fun x => f x ≤ a
q : Fin m → Prop := fun x => ↑x < Fintype.card { i // f i ≤ a }
q' : { i // f i ≤ a } → Prop := fun x => q ↑x
⊢ False

tactic: have hw : 0 < Fintype.card {j : {x : Fin m // f x ≤ a} // ¬ q' j} :=
  Fintype.card_pos_iff.2 ⟨⟨⟨j, h⟩, not_lt.2 hc⟩⟩
state_before: n : ℕ
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : DecidableRel LE.le
m : ℕ
f : Fin m → α
a : α
h_sorted : Monotone f
j : Fin m
h1 : ∀ (k : Fin m), ↑k < Fintype.card { i // f i ≤ a } → f k ≤ a
h : f j ≤ a
hc : Fintype.card { i // f i ≤ a } ≤ ↑j
p : Fin m → Prop := fun x => f x ≤ a
q : Fin m → Prop := fun x => ↑x < Fintype.card { i // f i ≤ a }
q' : { i // f i ≤ a } → Prop := fun x => q ↑x
⊢ False
state_after: n : ℕ
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : DecidableRel LE.le
m : ℕ
f : Fin m → α
a : α
h_sorted : Monotone f
j : Fin m
h1 : ∀ (k : Fin m), ↑k < Fintype.card { i // f i ≤ a } → f k ≤ a
h : f j ≤ a
hc : Fintype.card { i // f i ≤ a } ≤ ↑j
p : Fin m → Prop := fun x => f x ≤ a
q : Fin m → Prop := fun x => ↑x < Fintype.card { i // f i ≤ a }
q' : { i // f i ≤ a } → Prop := fun x => q ↑x
hw : 0 < Fintype.card { j // ¬q' j }
⊢ False

tactic: apply hw.ne'
state_before: n : ℕ
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : DecidableRel LE.le
m : ℕ
f : Fin m → α
a : α
h_sorted : Monotone f
j : Fin m
h1 : ∀ (k : Fin m), ↑k < Fintype.card { i // f i ≤ a } → f k ≤ a
h : f j ≤ a
hc : Fintype.card { i // f i ≤ a } ≤ ↑j
p : Fin m → Prop := fun x => f x ≤ a
q : Fin m → Prop := fun x => ↑x < Fintype.card { i // f i ≤ a }
q' : { i // f i ≤ a } → Prop := fun x => q ↑x
hw : 0 < Fintype.card { j // ¬q' j }
⊢ False
state_after: n : ℕ
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : DecidableRel LE.le
m : ℕ
f : Fin m → α
a : α
h_sorted : Monotone f
j : Fin m
h1 : ∀ (k : Fin m), ↑k < Fintype.card { i // f i ≤ a } → f k ≤ a
h : f j ≤ a
hc : Fintype.card { i // f i ≤ a } ≤ ↑j
p : Fin m → Prop := fun x => f x ≤ a
q : Fin m → Prop := fun x => ↑x < Fintype.card { i // f i ≤ a }
q' : { i // f i ≤ a } → Prop := fun x => q ↑x
hw : 0 < Fintype.card { j // ¬q' j }
⊢ Fintype.card { j // ¬q' j } = 0

tactic: have he := Fintype.card_congr <| Equiv.sumCompl <| q'
state_before: n : ℕ
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : DecidableRel LE.le
m : ℕ
f : Fin m → α
a : α
h_sorted : Monotone f
j : Fin m
h1 : ∀ (k : Fin m), ↑k < Fintype.card { i // f i ≤ a } → f k ≤ a
h : f j ≤ a
hc : Fintype.card { i // f i ≤ a } ≤ ↑j
p : Fin m → Prop := fun x => f x ≤ a
q : Fin m → Prop := fun x => ↑x < Fintype.card { i // f i ≤ a }
q' : { i // f i ≤ a } → Prop := fun x => q ↑x
hw : 0 < Fintype.card { j // ¬q' j }
⊢ Fintype.card { j // ¬q' j } = 0
state_after: n : ℕ
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : DecidableRel LE.le
m : ℕ
f : Fin m → α
a : α
h_sorted : Monotone f
j : Fin m
h1 : ∀ (k : Fin m), ↑k < Fintype.card { i // f i ≤ a } → f k ≤ a
h : f j ≤ a
hc : Fintype.card { i // f i ≤ a } ≤ ↑j
p : Fin m → Prop := fun x => f x ≤ a
q : Fin m → Prop := fun x => ↑x < Fintype.card { i // f i ≤ a }
q' : { i // f i ≤ a } → Prop := fun x => q ↑x
hw : 0 < Fintype.card { j // ¬q' j }
he : Fintype.card ({ a // q' a } ⊕ { a // ¬q' a }) = Fintype.card { i // f i ≤ a }
⊢ Fintype.card { j // ¬q' j } = 0

tactic: have h4 := (Fintype.card_congr (@Equiv.subtypeSubtypeEquivSubtype _ p q (h1 _)))
state_before: n : ℕ
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : DecidableRel LE.le
m : ℕ
f : Fin m → α
a : α
h_sorted : Monotone f
j : Fin m
h1 : ∀ (k : Fin m), ↑k < Fintype.card { i // f i ≤ a } → f k ≤ a
h : f j ≤ a
hc : Fintype.card { i // f i ≤ a } ≤ ↑j
p : Fin m → Prop := fun x => f x ≤ a
q : Fin m → Prop := fun x => ↑x < Fintype.card { i // f i ≤ a }
q' : { i // f i ≤ a } → Prop := fun x => q ↑x
hw : 0 < Fintype.card { j // ¬q' j }
he : Fintype.card ({ a // q' a } ⊕ { a // ¬q' a }) = Fintype.card { i // f i ≤ a }
⊢ Fintype.card { j // ¬q' j } = 0
state_after: n : ℕ
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : DecidableRel LE.le
m : ℕ
f : Fin m → α
a : α
h_sorted : Monotone f
j : Fin m
h1 : ∀ (k : Fin m), ↑k < Fintype.card { i // f i ≤ a } → f k ≤ a
h : f j ≤ a
hc : Fintype.card { i // f i ≤ a } ≤ ↑j
p : Fin m → Prop := fun x => f x ≤ a
q : Fin m → Prop := fun x => ↑x < Fintype.card { i // f i ≤ a }
q' : { i // f i ≤ a } → Prop := fun x => q ↑x
hw : 0 < Fintype.card { j // ¬q' j }
he : Fintype.card ({ a // q' a } ⊕ { a // ¬q' a }) = Fintype.card { i // f i ≤ a }
h4 : Fintype.card { x // q ↑x } = Fintype.card (Subtype q)
⊢ Fintype.card { j // ¬q' j } = 0

tactic: have h_le : Fintype.card { i // f i ≤ a } ≤ m := by
  conv_rhs => rw [← Fintype.card_fin m]
  exact Fintype.card_subtype_le _
state_before: n : ℕ
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : DecidableRel LE.le
m : ℕ
f : Fin m → α
a : α
h_sorted : Monotone f
j : Fin m
h1 : ∀ (k : Fin m), ↑k < Fintype.card { i // f i ≤ a } → f k ≤ a
h : f j ≤ a
hc : Fintype.card { i // f i ≤ a } ≤ ↑j
p : Fin m → Prop := fun x => f x ≤ a
q : Fin m → Prop := fun x => ↑x < Fintype.card { i // f i ≤ a }
q' : { i // f i ≤ a } → Prop := fun x => q ↑x
hw : 0 < Fintype.card { j // ¬q' j }
he : Fintype.card ({ a // q' a } ⊕ { a // ¬q' a }) = Fintype.card { i // f i ≤ a }
h4 : Fintype.card { x // q ↑x } = Fintype.card (Subtype q)
⊢ Fintype.card { j // ¬q' j } = 0
state_after: n : ℕ
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : DecidableRel LE.le
m : ℕ
f : Fin m → α
a : α
h_sorted : Monotone f
j : Fin m
h1 : ∀ (k : Fin m), ↑k < Fintype.card { i // f i ≤ a } → f k ≤ a
h : f j ≤ a
hc : Fintype.card { i // f i ≤ a } ≤ ↑j
p : Fin m → Prop := fun x => f x ≤ a
q : Fin m → Prop := fun x => ↑x < Fintype.card { i // f i ≤ a }
q' : { i // f i ≤ a } → Prop := fun x => q ↑x
hw : 0 < Fintype.card { j // ¬q' j }
he : Fintype.card ({ a // q' a } ⊕ { a // ¬q' a }) = Fintype.card { i // f i ≤ a }
h4 : Fintype.card { x // q ↑x } = Fintype.card (Subtype q)
h_le : Fintype.card { i // f i ≤ a } ≤ m
⊢ Fintype.card { j // ¬q' j } = 0

tactic: rwa [Fintype.card_sum, h4, Fintype.card_fin_lt_of_le h_le, add_right_eq_self] at he
state_before: n : ℕ
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : DecidableRel LE.le
m : ℕ
f : Fin m → α
a : α
h_sorted : Monotone f
j : Fin m
h1 : ∀ (k : Fin m), ↑k < Fintype.card { i // f i ≤ a } → f k ≤ a
h : f j ≤ a
hc : Fintype.card { i // f i ≤ a } ≤ ↑j
p : Fin m → Prop := fun x => f x ≤ a
q : Fin m → Prop := fun x => ↑x < Fintype.card { i // f i ≤ a }
q' : { i // f i ≤ a } → Prop := fun x => q ↑x
hw : 0 < Fintype.card { j // ¬q' j }
he : Fintype.card ({ a // q' a } ⊕ { a // ¬q' a }) = Fintype.card { i // f i ≤ a }
h4 : Fintype.card { x // q ↑x } = Fintype.card (Subtype q)
h_le : Fintype.card { i // f i ≤ a } ≤ m
⊢ Fintype.card { j // ¬q' j } = 0
state_after: no goals

tactic: conv_rhs => rw [← Fintype.card_fin m]
state_before: n : ℕ
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : DecidableRel LE.le
m : ℕ
f : Fin m → α
a : α
h_sorted : Monotone f
j : Fin m
h1 : ∀ (k : Fin m), ↑k < Fintype.card { i // f i ≤ a } → f k ≤ a
h : f j ≤ a
hc : Fintype.card { i // f i ≤ a } ≤ ↑j
p : Fin m → Prop := fun x => f x ≤ a
q : Fin m → Prop := fun x => ↑x < Fintype.card { i // f i ≤ a }
q' : { i // f i ≤ a } → Prop := fun x => q ↑x
hw : 0 < Fintype.card { j // ¬q' j }
he : Fintype.card ({ a // q' a } ⊕ { a // ¬q' a }) = Fintype.card { i // f i ≤ a }
h4 : Fintype.card { x // q ↑x } = Fintype.card (Subtype q)
⊢ Fintype.card { i // f i ≤ a } ≤ m
state_after: n : ℕ
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : DecidableRel LE.le
m : ℕ
f : Fin m → α
a : α
h_sorted : Monotone f
j : Fin m
h1 : ∀ (k : Fin m), ↑k < Fintype.card { i // f i ≤ a } → f k ≤ a
h : f j ≤ a
hc : Fintype.card { i // f i ≤ a } ≤ ↑j
p : Fin m → Prop := fun x => f x ≤ a
q : Fin m → Prop := fun x => ↑x < Fintype.card { i // f i ≤ a }
q' : { i // f i ≤ a } → Prop := fun x => q ↑x
hw : 0 < Fintype.card { j // ¬q' j }
he : Fintype.card ({ a // q' a } ⊕ { a // ¬q' a }) = Fintype.card { i // f i ≤ a }
h4 : Fintype.card { x // q ↑x } = Fintype.card (Subtype q)
⊢ Fintype.card { i // f i ≤ a } ≤ Fintype.card (Fin m)

tactic: exact Fintype.card_subtype_le _
state_before: n : ℕ
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : DecidableRel LE.le
m : ℕ
f : Fin m → α
a : α
h_sorted : Monotone f
j : Fin m
h1 : ∀ (k : Fin m), ↑k < Fintype.card { i // f i ≤ a } → f k ≤ a
h : f j ≤ a
hc : Fintype.card { i // f i ≤ a } ≤ ↑j
p : Fin m → Prop := fun x => f x ≤ a
q : Fin m → Prop := fun x => ↑x < Fintype.card { i // f i ≤ a }
q' : { i // f i ≤ a } → Prop := fun x => q ↑x
hw : 0 < Fintype.card { j // ¬q' j }
he : Fintype.card ({ a // q' a } ⊕ { a // ¬q' a }) = Fintype.card { i // f i ≤ a }
h4 : Fintype.card { x // q ↑x } = Fintype.card (Subtype q)
⊢ Fintype.card { i // f i ≤ a } ≤ Fintype.card (Fin m)
state_after: no goals