ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Function.Exact.exact_mapQ_iff
File: Mathlib/Algebra/Exact.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
M' : Type u_3
N : Type u_4
N' : Type u_5
P : Type u_6
P' : Type u_7
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup P
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R P
f : M →ₗ[R] N
g : N →ₗ[R] P
hfg : Exact ⇑f ⇑g
p : Submodule R M
q : Submodule R N
r : Submodule R P
hpq : p ≤ comap f q
hqr : q ≤ comap g r
⊢ Exact ⇑(p.mapQ q f hpq) ⇑(q.mapQ r g hqr) ↔ range g ⊓ r ≤ map g q
state_after: R : Type u_1
M : Type u_2
M' : Type u_3
N : Type u_4
N' : Type u_5
P : Type u_6
P' : Type u_7
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup P
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R P
f : M →ₗ[R] N
g : N →ₗ[R] P
hfg : Exact ⇑f ⇑g
p : Submodule R M
q : Submodule R N
r : Submodule R P
hpq : p ≤ comap f q
hqr : q ≤ comap g r
⊢ comap q.mkQ (ker (q.mapQ r g hqr)) = comap q.mkQ (range (p.mapQ q f hpq)) ↔ range g ⊓ r ≤ map g q
tactic: rw [exact_iff, ← (comap_injective_of_surjective (mkQ_surjective _)).eq_iff]
state_before: R : Type u_1
M : Type u_2
M' : Type u_3
N : Type u_4
N' : Type u_5
P : Type u_6
P' : Type u_7
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup P
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R P
f : M →ₗ[R] N
g : N →ₗ[R] P
hfg : Exact ⇑f ⇑g
p : Submodule R M
q : Submodule R N
r : Submodule R P
hpq : p ≤ comap f q
hqr : q ≤ comap g r
⊢ comap q.mkQ (ker (q.mapQ r g hqr)) = comap q.mkQ (range (p.mapQ q f hpq)) ↔ range g ⊓ r ≤ map g q
state_after: R : Type u_1
M : Type u_2
M' : Type u_3
N : Type u_4
N' : Type u_5
P : Type u_6
P' : Type u_7
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup P
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R P
f : M →ₗ[R] N
g : N →ₗ[R] P
hfg : Exact ⇑f ⇑g
p : Submodule R M
q : Submodule R N
r : Submodule R P
hpq : p ≤ comap f q
hqr : q ≤ comap g r
⊢ comap q.mkQ (ker (q.liftQ (r.mkQ ∘ₗ g) ⋯)) = comap q.mkQ (range (p.liftQ (q.mkQ ∘ₗ f) ⋯)) ↔ range g ⊓ r ≤ map g q
tactic: dsimp only [mapQ]
state_before: R : Type u_1
M : Type u_2
M' : Type u_3
N : Type u_4
N' : Type u_5
P : Type u_6
P' : Type u_7
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup P
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R P
f : M →ₗ[R] N
g : N →ₗ[R] P
hfg : Exact ⇑f ⇑g
p : Submodule R M
q : Submodule R N
r : Submodule R P
hpq : p ≤ comap f q
hqr : q ≤ comap g r
⊢ comap q.mkQ (ker (q.liftQ (r.mkQ ∘ₗ g) ⋯)) = comap q.mkQ (range (p.liftQ (q.mkQ ∘ₗ f) ⋯)) ↔ range g ⊓ r ≤ map g q
state_after: no goals
tactic: rw [← ker_comp, range_liftQ, liftQ_mkQ, ker_comp, range_comp, comap_map_eq,
    ker_mkQ, ker_mkQ, ← hfg.linearMap_ker_eq, sup_comm,
    ← LE.le.le_iff_eq (sup_le hqr (ker_le_comap g)),
    ← comap_map_eq, ← map_le_iff_le_comap, map_comap_eq]
Theorem: List.get?_enumFrom
File: Mathlib/Data/List/Enum.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
n : ℕ
l : List α
m : ℕ
⊢ (enumFrom n l).get? m = Option.map (fun a => (n + m, a)) (l.get? m)
state_after: no goals
tactic: simp
Theorem: Finset.image_compl
File: Mathlib/Data/Finset/Sups.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝² : DecidableEq α
inst✝¹ : DecidableEq β
inst✝ : BooleanAlgebra α
s s₁ s₂ t t₁ t₂ u v : Finset α
a b c : α
⊢ image compl s = sᶜˢ
state_after: no goals
tactic: simp [compls, map_eq_image]
Theorem: FreeAlgebra.lift_unique
File: Mathlib/Algebra/FreeAlgebra.lean

Proof steps:
state_before: R : Type u_1
inst✝² : CommSemiring R
X : Type u_2
A : Type u_3
inst✝¹ : Semiring A
inst✝ : Algebra R A
f : X → A
g : FreeAlgebra R X →ₐ[R] A
⊢ ⇑g ∘ ι R = f ↔ g = (lift R) f
state_after: R : Type u_1
inst✝² : CommSemiring R
X : Type u_2
A : Type u_3
inst✝¹ : Semiring A
inst✝ : Algebra R A
f : X → A
g : FreeAlgebra R X →ₐ[R] A
⊢ ⇑g ∘ ι R = f ↔
    { toFun := FreeAlgebra.liftAux R, invFun := fun F => ⇑F ∘ ι R, left_inv := ⋯, right_inv := ⋯ }.symm g = f
tactic: rw [← (lift R).symm_apply_eq, lift]
state_before: R : Type u_1
inst✝² : CommSemiring R
X : Type u_2
A : Type u_3
inst✝¹ : Semiring A
inst✝ : Algebra R A
f : X → A
g : FreeAlgebra R X →ₐ[R] A
⊢ ⇑g ∘ ι R = f ↔
    { toFun := FreeAlgebra.liftAux R, invFun := fun F => ⇑F ∘ ι R, left_inv := ⋯, right_inv := ⋯ }.symm g = f
state_after: no goals
tactic: rfl
Theorem: Equiv.Perm.disjoint_mul_inv_of_mem_cycleFactorsFinset
File: Mathlib/GroupTheory/Perm/Cycle/Factors.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ f g : Perm α
h : f ∈ g.cycleFactorsFinset
⊢ (g * f⁻¹).Disjoint f
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ f g : Perm α
h : f.IsCycle ∧ ∀ a ∈ f.support, f a = g a
⊢ (g * f⁻¹).Disjoint f
tactic: rw [mem_cycleFactorsFinset_iff] at h
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ f g : Perm α
h : f.IsCycle ∧ ∀ a ∈ f.support, f a = g a
⊢ (g * f⁻¹).Disjoint f
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ f g : Perm α
h : f.IsCycle ∧ ∀ a ∈ f.support, f a = g a
x : α
⊢ (g * f⁻¹) x = x ∨ f x = x
tactic: intro x
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ f g : Perm α
h : f.IsCycle ∧ ∀ a ∈ f.support, f a = g a
x : α
⊢ (g * f⁻¹) x = x ∨ f x = x
state_after: case pos
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ f g : Perm α
h : f.IsCycle ∧ ∀ a ∈ f.support, f a = g a
x : α
hx : f x = x
⊢ (g * f⁻¹) x = x ∨ f x = x

case neg
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ f g : Perm α
h : f.IsCycle ∧ ∀ a ∈ f.support, f a = g a
x : α
hx : ¬f x = x
⊢ (g * f⁻¹) x = x ∨ f x = x
tactic: by_cases hx : f x = x
Theorem: List.perm_insertNth
File: .lake/packages/batteries/Batteries/Data/List/Perm.lean

Proof steps:
state_before: α✝ : Sort ?u.57203
inst✝ : DecidableEq α✝
α : Type u_1
x : α
l : List α
n : Nat
h : n ≤ l.length
⊢ insertNth n x l ~ x :: l
state_after: no goals
tactic: induction l generalizing n with
  | nil =>
    cases n with
    | zero => rfl
    | succ => cases h
  | cons _ _ ih =>
    cases n with
    | zero => simp [insertNth]
    | succ =>
      simp only [insertNth, modifyNthTail]
      refine .trans (.cons _ (ih (Nat.le_of_succ_le_succ h))) (.swap ..)
Theorem: MeasureTheory.measure_unitBall_eq_integral_div_gamma
File: Mathlib/MeasureTheory/Measure/Lebesgue/VolumeOfBalls.lean

Proof steps:
state_before: E : Type u_1
p : ℝ
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
inst✝³ : FiniteDimensional ℝ E
inst✝² : MeasurableSpace E
inst✝¹ : BorelSpace E
μ : Measure E
inst✝ : μ.IsAddHaarMeasure
hp : 0 < p
⊢ μ (Metric.ball 0 1) = ENNReal.ofReal ((∫ (x : E), Real.exp (-‖x‖ ^ p) ∂μ) / Real.Gamma (↑(finrank ℝ E) / p + 1))
state_after: case inl
E : Type u_1
p : ℝ
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
inst✝³ : FiniteDimensional ℝ E
inst✝² : MeasurableSpace E
inst✝¹ : BorelSpace E
μ : Measure E
inst✝ : μ.IsAddHaarMeasure
hp : 0 < p
hE : Subsingleton E
⊢ μ (Metric.ball 0 1) = ENNReal.ofReal ((∫ (x : E), Real.exp (-‖x‖ ^ p) ∂μ) / Real.Gamma (↑(finrank ℝ E) / p + 1))

case inr
E : Type u_1
p : ℝ
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
inst✝³ : FiniteDimensional ℝ E
inst✝² : MeasurableSpace E
inst✝¹ : BorelSpace E
μ : Measure E
inst✝ : μ.IsAddHaarMeasure
hp : 0 < p
hE : Nontrivial E
⊢ μ (Metric.ball 0 1) = ENNReal.ofReal ((∫ (x : E), Real.exp (-‖x‖ ^ p) ∂μ) / Real.Gamma (↑(finrank ℝ E) / p + 1))
tactic: obtain hE | hE := subsingleton_or_nontrivial E
Theorem: Ordinal.cof_omega
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

Proof steps:
state_before: α : Type u_1
r : α → α → Prop
⊢ ω.cof ≤ ℵ₀
state_after: α : Type u_1
r : α → α → Prop
⊢ ω.cof ≤ ω.card
tactic: rw [← card_omega]
state_before: α : Type u_1
r : α → α → Prop
⊢ ω.cof ≤ ω.card
state_after: no goals
tactic: apply cof_le_card
Theorem: CategoryTheory.obj_ε_app
File: Mathlib/CategoryTheory/Monoidal/End.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
M : Type u_1
inst✝¹ : Category.{u_2, u_1} M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
n : M
X : C
⊢ (F.obj n).map (F.ε.app X) = (F.map (λ_ n).inv).app X ≫ (F.μIso (𝟙_ M) n).inv.app X
state_after: C : Type u
inst✝² : Category.{v, u} C
M : Type u_1
inst✝¹ : Category.{u_2, u_1} M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
n : M
X : C
⊢ (F.obj n).map (F.ε.app X) =
    𝟙 ((F.obj n).obj ((𝟙_ (C ⥤ C)).obj X)) ≫ (F.map (λ_ n).inv).app X ≫ (F.μIso (𝟙_ M) n).inv.app X
tactic: refine Eq.trans ?_ (Category.id_comp _)
state_before: C : Type u
inst✝² : Category.{v, u} C
M : Type u_1
inst✝¹ : Category.{u_2, u_1} M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
n : M
X : C
⊢ (F.obj n).map (F.ε.app X) =
    𝟙 ((F.obj n).obj ((𝟙_ (C ⥤ C)).obj X)) ≫ (F.map (λ_ n).inv).app X ≫ (F.μIso (𝟙_ M) n).inv.app X
state_after: C : Type u
inst✝² : Category.{v, u} C
M : Type u_1
inst✝¹ : Category.{u_2, u_1} M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
n : M
X : C
⊢ (F.obj n).map (F.ε.app X) ≫ inv ((F.μIso (𝟙_ M) n).inv.app X) ≫ inv ((F.map (λ_ n).inv).app X) =
    𝟙 ((F.obj n).obj ((𝟙_ (C ⥤ C)).obj X))
tactic: rw [← Category.assoc, ← IsIso.comp_inv_eq, ← IsIso.comp_inv_eq, Category.assoc]
state_before: C : Type u
inst✝² : Category.{v, u} C
M : Type u_1
inst✝¹ : Category.{u_2, u_1} M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
n : M
X : C
⊢ (F.obj n).map (F.ε.app X) ≫ inv ((F.μIso (𝟙_ M) n).inv.app X) ≫ inv ((F.map (λ_ n).inv).app X) =
    𝟙 ((F.obj n).obj ((𝟙_ (C ⥤ C)).obj X))
state_after: case h.e'_2.h.h.e'_7.h.h.e'_6
C : Type u
inst✝² : Category.{v, u} C
M : Type u_1
inst✝¹ : Category.{u_2, u_1} M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
n : M
X : C
e_1✝ :
  ((F.obj n).obj ((𝟙_ (C ⥤ C)).obj X) ⟶ (F.obj n).obj ((𝟙_ (C ⥤ C)).obj X)) =
    ((F.obj n).obj ((𝟙_ (C ⥤ C)).obj X) ⟶ (F.obj n).obj X)
e_5✝ : (F.obj n).obj ((𝟙_ (C ⥤ C)).obj X) = (F.obj n).obj X
⊢ inv ((F.μIso (𝟙_ M) n).inv.app X) = (F.μ (𝟙_ M) n).app X

case h.e'_2.h.h.e'_7.h.h.e'_7.h
C : Type u
inst✝² : Category.{v, u} C
M : Type u_1
inst✝¹ : Category.{u_2, u_1} M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
n : M
X : C
e_1✝ :
  ((F.obj n).obj ((𝟙_ (C ⥤ C)).obj X) ⟶ (F.obj n).obj ((𝟙_ (C ⥤ C)).obj X)) =
    ((F.obj n).obj ((𝟙_ (C ⥤ C)).obj X) ⟶ (F.obj n).obj X)
e_5✝ : (F.obj n).obj ((𝟙_ (C ⥤ C)).obj X) = (F.obj n).obj X
⊢ inv ((F.map (λ_ n).inv).app X) = (F.map (λ_ n).hom).app X
tactic: convert left_unitality_app F n X
Theorem: AlgebraicClosureAux.exists_root
File: Mathlib/FieldTheory/IsAlgClosed/AlgebraicClosure.lean

Proof steps:
state_before: k : Type u
inst✝ : Field k
f : (AlgebraicClosureAux k)[X]
hfm : f.Monic
hfi : Irreducible f
⊢ ∃ x, eval x f = 0
state_after: k : Type u
inst✝ : Field k
f : (AlgebraicClosureAux k)[X]
hfm : f.Monic
hfi : Irreducible f
this : ∃ n p, map (ofStep k n) p = f
⊢ ∃ x, eval x f = 0
tactic: have : ∃ n p, Polynomial.map (ofStep k n) p = f := by
    convert Ring.DirectLimit.Polynomial.exists_of f
state_before: k : Type u
inst✝ : Field k
f : (AlgebraicClosureAux k)[X]
hfm : f.Monic
hfi : Irreducible f
this : ∃ n p, map (ofStep k n) p = f
⊢ ∃ x, eval x f = 0
state_after: case intro.intro
k : Type u
inst✝ : Field k
n : ℕ
p : (Step k n)[X]
hfm : (map (ofStep k n) p).Monic
hfi : Irreducible (map (ofStep k n) p)
⊢ ∃ x, eval x (map (ofStep k n) p) = 0
tactic: obtain ⟨n, p, rfl⟩ := this
state_before: case intro.intro
k : Type u
inst✝ : Field k
n : ℕ
p : (Step k n)[X]
hfm : (map (ofStep k n) p).Monic
hfi : Irreducible (map (ofStep k n) p)
⊢ ∃ x, eval x (map (ofStep k n) p) = 0
state_after: case intro.intro
k : Type u
inst✝ : Field k
n : ℕ
p : (Step k n)[X]
hfm : p.Monic
hfi : Irreducible (map (ofStep k n) p)
⊢ ∃ x, eval x (map (ofStep k n) p) = 0
tactic: rw [monic_map_iff] at hfm
state_before: case intro.intro
k : Type u
inst✝ : Field k
n : ℕ
p : (Step k n)[X]
hfm : p.Monic
hfi : Irreducible (map (ofStep k n) p)
⊢ ∃ x, eval x (map (ofStep k n) p) = 0
state_after: case intro.intro
k : Type u
inst✝ : Field k
n : ℕ
p : (Step k n)[X]
hfm : p.Monic
hfi : Irreducible (map (ofStep k n) p)
this : Irreducible p
⊢ ∃ x, eval x (map (ofStep k n) p) = 0
tactic: have := hfm.irreducible_of_irreducible_map (ofStep k n) p hfi
state_before: case intro.intro
k : Type u
inst✝ : Field k
n : ℕ
p : (Step k n)[X]
hfm : p.Monic
hfi : Irreducible (map (ofStep k n) p)
this : Irreducible p
⊢ ∃ x, eval x (map (ofStep k n) p) = 0
state_after: case intro.intro.intro
k : Type u
inst✝ : Field k
n : ℕ
p : (Step k n)[X]
hfm : p.Monic
hfi : Irreducible (map (ofStep k n) p)
this : Irreducible p
x : Step k (n + 1)
hx : eval₂ (toStepSucc k n) x p = 0
⊢ ∃ x, eval x (map (ofStep k n) p) = 0
tactic: obtain ⟨x, hx⟩ := toStepSucc.exists_root k hfm this
state_before: case intro.intro.intro
k : Type u
inst✝ : Field k
n : ℕ
p : (Step k n)[X]
hfm : p.Monic
hfi : Irreducible (map (ofStep k n) p)
this : Irreducible p
x : Step k (n + 1)
hx : eval₂ (toStepSucc k n) x p = 0
⊢ ∃ x, eval x (map (ofStep k n) p) = 0
state_after: case intro.intro.intro
k : Type u
inst✝ : Field k
n : ℕ
p : (Step k n)[X]
hfm : p.Monic
hfi : Irreducible (map (ofStep k n) p)
this : Irreducible p
x : Step k (n + 1)
hx : eval₂ (toStepSucc k n) x p = 0
⊢ eval ((ofStep k (n + 1)) x) (map (ofStep k n) p) = 0
tactic: refine ⟨ofStep k (n + 1) x, ?_⟩
state_before: case intro.intro.intro
k : Type u
inst✝ : Field k
n : ℕ
p : (Step k n)[X]
hfm : p.Monic
hfi : Irreducible (map (ofStep k n) p)
this : Irreducible p
x : Step k (n + 1)
hx : eval₂ (toStepSucc k n) x p = 0
⊢ eval ((ofStep k (n + 1)) x) (map (ofStep k n) p) = 0
state_after: no goals
tactic: rw [← ofStep_succ k n, eval_map, ← hom_eval₂, hx, RingHom.map_zero]
Theorem: CategoryTheory.NatTrans.mono_iff_mono_app
File: Mathlib/CategoryTheory/Adjunction/Evaluation.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : ∀ (a b : C), HasCoproductsOfShape (a ⟶ b) D
F G : C ⥤ D
η : F ⟶ G
⊢ Mono η ↔ ∀ (c : C), Mono (η.app c)
state_after: case mp
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : ∀ (a b : C), HasCoproductsOfShape (a ⟶ b) D
F G : C ⥤ D
η : F ⟶ G
⊢ Mono η → ∀ (c : C), Mono (η.app c)

case mpr
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : ∀ (a b : C), HasCoproductsOfShape (a ⟶ b) D
F G : C ⥤ D
η : F ⟶ G
⊢ (∀ (c : C), Mono (η.app c)) → Mono η
tactic: constructor
Theorem: unitInterval.mul_pos_mem_iff
File: Mathlib/Topology/UnitInterval.lean

Proof steps:
state_before: a t : ℝ
ha : 0 < a
⊢ a * t ∈ I ↔ t ∈ Icc 0 (1 / a)
state_after: case mp.intro.left
a t : ℝ
ha : 0 < a
h₁ : 0 ≤ a * t
h₂ : a * t ≤ 1
⊢ 0 ≤ t

case mp.intro.right
a t : ℝ
ha : 0 < a
h₁ : 0 ≤ a * t
h₂ : a * t ≤ 1
⊢ t ≤ 1 / a

case mpr.intro.left
a t : ℝ
ha : 0 < a
h₁ : 0 ≤ t
h₂ : t ≤ 1 / a
⊢ 0 ≤ a * t

case mpr.intro.right
a t : ℝ
ha : 0 < a
h₁ : 0 ≤ t
h₂ : t ≤ 1 / a
⊢ a * t ≤ 1
tactic: constructor <;> rintro ⟨h₁, h₂⟩ <;> constructor
Theorem: Set.toFinset_Iio
File: Mathlib/Order/Interval/Finset/Defs.lean

Proof steps:
state_before: α✝ : Type u_1
β : Type u_2
inst✝⁴ : Preorder α✝
p : α✝ → Prop
inst✝³ : DecidablePred p
y : α✝
α : Type u_3
inst✝² : Preorder α
inst✝¹ : LocallyFiniteOrderBot α
a : α
inst✝ : Fintype ↑(Iio a)
⊢ (Iio a).toFinset = Finset.Iio a
state_after: case a
α✝ : Type u_1
β : Type u_2
inst✝⁴ : Preorder α✝
p : α✝ → Prop
inst✝³ : DecidablePred p
y : α✝
α : Type u_3
inst✝² : Preorder α
inst✝¹ : LocallyFiniteOrderBot α
a : α
inst✝ : Fintype ↑(Iio a)
a✝ : α
⊢ a✝ ∈ (Iio a).toFinset ↔ a✝ ∈ Finset.Iio a
tactic: ext
state_before: case a
α✝ : Type u_1
β : Type u_2
inst✝⁴ : Preorder α✝
p : α✝ → Prop
inst✝³ : DecidablePred p
y : α✝
α : Type u_3
inst✝² : Preorder α
inst✝¹ : LocallyFiniteOrderBot α
a : α
inst✝ : Fintype ↑(Iio a)
a✝ : α
⊢ a✝ ∈ (Iio a).toFinset ↔ a✝ ∈ Finset.Iio a
state_after: no goals
tactic: simp
Theorem: CategoryTheory.ShiftedHom.id_map
File: Mathlib/CategoryTheory/Shift/ShiftedHom.lean

Proof steps:
state_before: C : Type u_1
inst✝⁶ : Category.{u_5, u_1} C
D : Type u_2
inst✝⁵ : Category.{?u.55630, u_2} D
E : Type u_3
inst✝⁴ : Category.{?u.55637, u_3} E
M : Type u_4
inst✝³ : AddMonoid M
inst✝² : HasShift C M
inst✝¹ : HasShift D M
inst✝ : HasShift E M
X Y Z T : C
a : M
f : ShiftedHom X Y a
⊢ f.map (𝟭 C) = f
state_after: no goals
tactic: simp [map, Functor.commShiftIso, Functor.CommShift.iso]
Theorem: Set.zero_div_subset
File: Mathlib/Data/Set/Pointwise/Basic.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : GroupWithZero α
s✝ t s : Set α
⊢ 0 / s ⊆ 0
state_after: no goals
tactic: simp [subset_def, mem_div]
Theorem: Function.apply_update₂
File: Mathlib/Logic/Function/Basic.lean

Proof steps:
state_before: α✝ : Sort u
β✝ : α✝ → Sort v
α' : Sort w
inst✝² : DecidableEq α✝
inst✝¹ : DecidableEq α'
f✝ g✝ : (a : α✝) → β✝ a
a : α✝
b : β✝ a
ι : Sort u_1
inst✝ : DecidableEq ι
α : ι → Sort u_2
β : ι → Sort u_3
γ : ι → Sort u_4
f : (i : ι) → α i → β i → γ i
g : (i : ι) → α i
h : (i : ι) → β i
i : ι
v : α i
w : β i
j : ι
⊢ f j (update g i v j) (update h i w j) = update (fun k => f k (g k) (h k)) i (f i v w) j
state_after: case pos
α✝ : Sort u
β✝ : α✝ → Sort v
α' : Sort w
inst✝² : DecidableEq α✝
inst✝¹ : DecidableEq α'
f✝ g✝ : (a : α✝) → β✝ a
a : α✝
b : β✝ a
ι : Sort u_1
inst✝ : DecidableEq ι
α : ι → Sort u_2
β : ι → Sort u_3
γ : ι → Sort u_4
f : (i : ι) → α i → β i → γ i
g : (i : ι) → α i
h✝ : (i : ι) → β i
i : ι
v : α i
w : β i
j : ι
h : j = i
⊢ f j (update g i v j) (update h✝ i w j) = update (fun k => f k (g k) (h✝ k)) i (f i v w) j

case neg
α✝ : Sort u
β✝ : α✝ → Sort v
α' : Sort w
inst✝² : DecidableEq α✝
inst✝¹ : DecidableEq α'
f✝ g✝ : (a : α✝) → β✝ a
a : α✝
b : β✝ a
ι : Sort u_1
inst✝ : DecidableEq ι
α : ι → Sort u_2
β : ι → Sort u_3
γ : ι → Sort u_4
f : (i : ι) → α i → β i → γ i
g : (i : ι) → α i
h✝ : (i : ι) → β i
i : ι
v : α i
w : β i
j : ι
h : ¬j = i
⊢ f j (update g i v j) (update h✝ i w j) = update (fun k => f k (g k) (h✝ k)) i (f i v w) j
tactic: by_cases h : j = i
Theorem: Stream'.WSeq.get?_terminates_le
File: Mathlib/Data/Seq/WSeq.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
s : WSeq α
m n : ℕ
h : m ≤ n
⊢ (s.get? n).Terminates → (s.get? m).Terminates
state_after: case refl
α : Type u
β : Type v
γ : Type w
s : WSeq α
m n : ℕ
⊢ (s.get? m).Terminates → (s.get? m).Terminates

case step
α : Type u
β : Type v
γ : Type w
s : WSeq α
m n m' : ℕ
a✝ : m.le m'
IH : (s.get? m').Terminates → (s.get? m).Terminates
⊢ (s.get? m'.succ).Terminates → (s.get? m).Terminates
tactic: induction' h with m' _ IH
state_before: case refl
α : Type u
β : Type v
γ : Type w
s : WSeq α
m n : ℕ
⊢ (s.get? m).Terminates → (s.get? m).Terminates

case step
α : Type u
β : Type v
γ : Type w
s : WSeq α
m n m' : ℕ
a✝ : m.le m'
IH : (s.get? m').Terminates → (s.get? m).Terminates
⊢ (s.get? m'.succ).Terminates → (s.get? m).Terminates
state_after: no goals
tactic: exacts [id, fun T => IH (@head_terminates_of_head_tail_terminates _ _ T)]
Theorem: LinearMap.span_singleton_eq_range
File: Mathlib/LinearAlgebra/Span.lean

Proof steps:
state_before: R : Type u_1
R₂ : Type u_2
K : Type u_3
M : Type u_4
M₂ : Type u_5
V : Type u_6
S : Type u_7
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
x y : M
⊢ y ∈ span R {x} ↔ y ∈ range (toSpanSingleton R M x)
state_after: R : Type u_1
R₂ : Type u_2
K : Type u_3
M : Type u_4
M₂ : Type u_5
V : Type u_6
S : Type u_7
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
x y : M
⊢ y ∈ span R {x} ↔ ∃ y_1, (toSpanSingleton R M x) y_1 = y
tactic: refine Iff.trans ?_ LinearMap.mem_range.symm
state_before: R : Type u_1
R₂ : Type u_2
K : Type u_3
M : Type u_4
M₂ : Type u_5
V : Type u_6
S : Type u_7
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
x y : M
⊢ y ∈ span R {x} ↔ ∃ y_1, (toSpanSingleton R M x) y_1 = y
state_after: no goals
tactic: exact mem_span_singleton
Theorem: PNat.dvd_iff'
File: Mathlib/Data/PNat/Basic.lean

Proof steps:
state_before: k m : ℕ+
⊢ k ∣ m ↔ m.mod k = k
state_after: k m : ℕ+
⊢ ↑k ∣ ↑m ↔ m.mod k = k
tactic: rw [dvd_iff]
state_before: k m : ℕ+
⊢ ↑k ∣ ↑m ↔ m.mod k = k
state_after: k m : ℕ+
⊢ ↑m % ↑k = 0 ↔ m.mod k = k
tactic: rw [Nat.dvd_iff_mod_eq_zero]
state_before: k m : ℕ+
⊢ ↑m % ↑k = 0 ↔ m.mod k = k
state_after: case mp
k m : ℕ+
⊢ ↑m % ↑k = 0 → m.mod k = k

case mpr
k m : ℕ+
⊢ m.mod k = k → ↑m % ↑k = 0
tactic: constructor
Theorem: CategoryTheory.Limits.Types.iUnion_descSet_singleton
File: Mathlib/CategoryTheory/Limits/Preserves/Ulift.lean

Proof steps:
state_before: J : Type u_1
inst✝ : Category.{u_2, u_1} J
K : J ⥤ Type u
c : Cocone K
hc : IsColimit c
lc : Cocone (K ⋙ uliftFunctor.{v, u})
⊢ ⋃ x, descSet hc {x} = Set.univ
state_after: J : Type u_1
inst✝ : Category.{u_2, u_1} J
K : J ⥤ Type u
c : Cocone K
hc : IsColimit c
lc : Cocone (K ⋙ uliftFunctor.{v, u})
⊢ ∀ (j : J) (x : K.obj j), lc.ι.app j { down := x } ∈ Set.univ ↔ c.ι.app j x ∈ ⋃ x, descSet hc {x}
tactic: rw [← descSet_univ hc lc, eq_comm, descSet_spec]
state_before: J : Type u_1
inst✝ : Category.{u_2, u_1} J
K : J ⥤ Type u
c : Cocone K
hc : IsColimit c
lc : Cocone (K ⋙ uliftFunctor.{v, u})
⊢ ∀ (j : J) (x : K.obj j), lc.ι.app j { down := x } ∈ Set.univ ↔ c.ι.app j x ∈ ⋃ x, descSet hc {x}
state_after: J : Type u_1
inst✝ : Category.{u_2, u_1} J
K : J ⥤ Type u
c : Cocone K
hc : IsColimit c
lc : Cocone (K ⋙ uliftFunctor.{v, u})
j : J
x : K.obj j
⊢ lc.ι.app j { down := x } ∈ Set.univ ↔ c.ι.app j x ∈ ⋃ x, descSet hc {x}
tactic: intro j x
state_before: J : Type u_1
inst✝ : Category.{u_2, u_1} J
K : J ⥤ Type u
c : Cocone K
hc : IsColimit c
lc : Cocone (K ⋙ uliftFunctor.{v, u})
j : J
x : K.obj j
⊢ lc.ι.app j { down := x } ∈ Set.univ ↔ c.ι.app j x ∈ ⋃ x, descSet hc {x}
state_after: J : Type u_1
inst✝ : Category.{u_2, u_1} J
K : J ⥤ Type u
c : Cocone K
hc : IsColimit c
lc : Cocone (K ⋙ uliftFunctor.{v, u})
j : J
x : K.obj j
⊢ ∃ i, c.ι.app j x ∈ descSet hc {i}
tactic: erw [true_iff, Set.mem_iUnion]
state_before: J : Type u_1
inst✝ : Category.{u_2, u_1} J
K : J ⥤ Type u
c : Cocone K
hc : IsColimit c
lc : Cocone (K ⋙ uliftFunctor.{v, u})
j : J
x : K.obj j
⊢ ∃ i, c.ι.app j x ∈ descSet hc {i}
state_after: case h
J : Type u_1
inst✝ : Category.{u_2, u_1} J
K : J ⥤ Type u
c : Cocone K
hc : IsColimit c
lc : Cocone (K ⋙ uliftFunctor.{v, u})
j : J
x : K.obj j
⊢ c.ι.app j x ∈ descSet hc {lc.ι.app j { down := x }}
tactic: use lc.ι.app j ⟨x⟩
state_before: case h
J : Type u_1
inst✝ : Category.{u_2, u_1} J
K : J ⥤ Type u
c : Cocone K
hc : IsColimit c
lc : Cocone (K ⋙ uliftFunctor.{v, u})
j : J
x : K.obj j
⊢ c.ι.app j x ∈ descSet hc {lc.ι.app j { down := x }}
state_after: no goals
tactic: rw [mem_descSet_singleton]
Theorem: Codisjoint.map_orderIso
File: Mathlib/Order/Hom/Basic.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝³ : SemilatticeSup α
inst✝² : OrderTop α
inst✝¹ : SemilatticeSup β
inst✝ : OrderTop β
a b : α
f : α ≃o β
ha : Codisjoint a b
⊢ Codisjoint (f a) (f b)
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝³ : SemilatticeSup α
inst✝² : OrderTop α
inst✝¹ : SemilatticeSup β
inst✝ : OrderTop β
a b : α
f : α ≃o β
ha : Codisjoint a b
⊢ f ⊤ ≤ f (a ⊔ b)
tactic: rw [codisjoint_iff_le_sup, ← f.map_sup, ← f.map_top]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝³ : SemilatticeSup α
inst✝² : OrderTop α
inst✝¹ : SemilatticeSup β
inst✝ : OrderTop β
a b : α
f : α ≃o β
ha : Codisjoint a b
⊢ f ⊤ ≤ f (a ⊔ b)
state_after: no goals
tactic: exact f.monotone ha.top_le