ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Denumerable.list_ofNat_succ
File: Mathlib/Logic/Equiv/List.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Denumerable α
inst✝ : Denumerable β
v : ℕ
⊢ decodeList v.succ = some (ofNat α (unpair v).1 :: ofNat (List α) (unpair v).2)
state_after: case mk
α : Type u_1
β : Type u_2
inst✝¹ : Denumerable α
inst✝ : Denumerable β
v v₁ v₂ : ℕ
e : unpair v = (v₁, v₂)
⊢ decodeList v.succ = some (ofNat α (v₁, v₂).1 :: ofNat (List α) (v₁, v₂).2)
tactic: cases' e : unpair v with v₁ v₂
state_before: case mk
α : Type u_1
β : Type u_2
inst✝¹ : Denumerable α
inst✝ : Denumerable β
v v₁ v₂ : ℕ
e : unpair v = (v₁, v₂)
⊢ decodeList v.succ = some (ofNat α (v₁, v₂).1 :: ofNat (List α) (v₁, v₂).2)
state_after: case mk
α : Type u_1
β : Type u_2
inst✝¹ : Denumerable α
inst✝ : Denumerable β
v v₁ v₂ : ℕ
e : unpair v = (v₁, v₂)
⊢ (Seq.seq (some fun x => ofNat α v₁ :: x) fun x => decodeList v₂) = some (ofNat α v₁ :: ofNat (List α) v₂)
tactic: simp [decodeList, e]
state_before: case mk
α : Type u_1
β : Type u_2
inst✝¹ : Denumerable α
inst✝ : Denumerable β
v v₁ v₂ : ℕ
e : unpair v = (v₁, v₂)
⊢ (Seq.seq (some fun x => ofNat α v₁ :: x) fun x => decodeList v₂) = some (ofNat α v₁ :: ofNat (List α) v₂)
state_after: no goals
tactic: rw [show decodeList v₂ = decode (α := List α) v₂ from rfl, decode_eq_ofNat, Option.seq_some]
Theorem: finSuccEquiv'_last_apply_castSucc
File: Mathlib/Logic/Equiv/Fin.lean

Proof steps:
state_before: m n : ℕ
i : Fin n
⊢ (finSuccEquiv' (Fin.last n)) i.castSucc = some i
state_after: no goals
tactic: rw [← Fin.succAbove_last, finSuccEquiv'_succAbove]
Theorem: CategoryTheory.OplaxFunctor.bicategory_id_naturality
File: Mathlib/CategoryTheory/Bicategory/FunctorBicategory.lean

Proof steps:
state_before: B : Type u₁
inst✝¹ : Bicategory B
C : Type u₂
inst✝ : Bicategory C
F G H I a b c : OplaxFunctor B C
f g : a ⟶ b
h i : b ⟶ c
η : f ⟶ g
θ : h ⟶ i
⊢ (fun {F G H} η x x_1 Γ => OplaxNatTrans.whiskerLeft η Γ) f h i θ ≫
      (fun {F G H} x x_1 Γ η => OplaxNatTrans.whiskerRight Γ η) f g η i =
    (fun {F G H} x x_1 Γ η => OplaxNatTrans.whiskerRight Γ η) f g η h ≫
      (fun {F G H} η x x_1 Γ => OplaxNatTrans.whiskerLeft η Γ) g h i θ
state_after: case w
B : Type u₁
inst✝¹ : Bicategory B
C : Type u₂
inst✝ : Bicategory C
F G H I a b c : OplaxFunctor B C
f g : a ⟶ b
h i : b ⟶ c
η : f ⟶ g
θ : h ⟶ i
b✝ : B
⊢ ((fun {F G H} η x x_1 Γ => OplaxNatTrans.whiskerLeft η Γ) f h i θ ≫
          (fun {F G H} x x_1 Γ η => OplaxNatTrans.whiskerRight Γ η) f g η i).app
      b✝ =
    ((fun {F G H} x x_1 Γ η => OplaxNatTrans.whiskerRight Γ η) f g η h ≫
          (fun {F G H} η x x_1 Γ => OplaxNatTrans.whiskerLeft η Γ) g h i θ).app
      b✝
tactic: ext
state_before: case w
B : Type u₁
inst✝¹ : Bicategory B
C : Type u₂
inst✝ : Bicategory C
F G H I a b c : OplaxFunctor B C
f g : a ⟶ b
h i : b ⟶ c
η : f ⟶ g
θ : h ⟶ i
b✝ : B
⊢ ((fun {F G H} η x x_1 Γ => OplaxNatTrans.whiskerLeft η Γ) f h i θ ≫
          (fun {F G H} x x_1 Γ η => OplaxNatTrans.whiskerRight Γ η) f g η i).app
      b✝ =
    ((fun {F G H} x x_1 Γ η => OplaxNatTrans.whiskerRight Γ η) f g η h ≫
          (fun {F G H} η x x_1 Γ => OplaxNatTrans.whiskerLeft η Γ) g h i θ).app
      b✝
state_after: no goals
tactic: exact whisker_exchange _ _
Theorem: IntermediateField.adjoin.range_algebraMap_subset
File: Mathlib/FieldTheory/Adjoin.lean

Proof steps:
state_before: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set E
⊢ Set.range ⇑(algebraMap F E) ⊆ ↑(adjoin F S)
state_after: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set E
x : E
hx : x ∈ Set.range ⇑(algebraMap F E)
⊢ x ∈ ↑(adjoin F S)
tactic: intro x hx
state_before: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set E
x : E
hx : x ∈ Set.range ⇑(algebraMap F E)
⊢ x ∈ ↑(adjoin F S)
state_after: case intro
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set E
x : E
f : F
hf : (algebraMap F E) f = x
⊢ x ∈ ↑(adjoin F S)
tactic: cases' hx with f hf
state_before: case intro
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set E
x : E
f : F
hf : (algebraMap F E) f = x
⊢ x ∈ ↑(adjoin F S)
state_after: case intro
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set E
x : E
f : F
hf : (algebraMap F E) f = x
⊢ (algebraMap F E) f ∈ ↑(adjoin F S)
tactic: rw [← hf]
state_before: case intro
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set E
x : E
f : F
hf : (algebraMap F E) f = x
⊢ (algebraMap F E) f ∈ ↑(adjoin F S)
state_after: no goals
tactic: exact adjoin.algebraMap_mem F S f
Theorem: hasSum_zero_iff_of_nonneg
File: Mathlib/Topology/Algebra/InfiniteSum/Order.lean

Proof steps:
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
inst✝² : OrderedCommMonoid α
inst✝¹ : TopologicalSpace α
inst✝ : OrderClosedTopology α
f g : ι → α
a a₁ a₂ : α
hf : ∀ (i : ι), 1 ≤ f i
⊢ HasProd f 1 ↔ f = 1
state_after: case refine_1
ι : Type u_1
κ : Type u_2
α : Type u_3
inst✝² : OrderedCommMonoid α
inst✝¹ : TopologicalSpace α
inst✝ : OrderClosedTopology α
f g : ι → α
a a₁ a₂ : α
hf : ∀ (i : ι), 1 ≤ f i
hf' : HasProd f 1
⊢ f = 1

case refine_2
ι : Type u_1
κ : Type u_2
α : Type u_3
inst✝² : OrderedCommMonoid α
inst✝¹ : TopologicalSpace α
inst✝ : OrderClosedTopology α
f g : ι → α
a a₁ a₂ : α
hf : ∀ (i : ι), 1 ≤ f i
⊢ f = 1 → HasProd f 1
tactic: refine ⟨fun hf' ↦ ?_, ?_⟩
Theorem: Basis.toDual_apply
File: Mathlib/LinearAlgebra/Dual.lean

Proof steps:
state_before: R : Type uR
M : Type uM
K : Type uK
V : Type uV
ι : Type uι
inst✝³ : CommSemiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : DecidableEq ι
b : Basis ι R M
i j : ι
⊢ (b.toDual (b i)) (b j) = if i = j then 1 else 0
state_after: R : Type uR
M : Type uM
K : Type uK
V : Type uV
ι : Type uι
inst✝³ : CommSemiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : DecidableEq ι
b : Basis ι R M
i j : ι
⊢ (if j = i then 1 else 0) = if i = j then 1 else 0
tactic: erw [constr_basis b, constr_basis b]
state_before: R : Type uR
M : Type uM
K : Type uK
V : Type uV
ι : Type uι
inst✝³ : CommSemiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : DecidableEq ι
b : Basis ι R M
i j : ι
⊢ (if j = i then 1 else 0) = if i = j then 1 else 0
state_after: no goals
tactic: simp only [eq_comm]
Theorem: ContDiffBump.hasCompactSupport_normed
File: Mathlib/Analysis/Calculus/BumpFunction/Normed.lean

Proof steps:
state_before: E : Type u_1
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : HasContDiffBump E
inst✝⁴ : MeasurableSpace E
c : E
f : ContDiffBump c
x : E
n : ℕ∞
μ : Measure E
inst✝³ : BorelSpace E
inst✝² : FiniteDimensional ℝ E
inst✝¹ : IsLocallyFiniteMeasure μ
inst✝ : μ.IsOpenPosMeasure
⊢ HasCompactSupport (f.normed μ)
state_after: no goals
tactic: simp only [HasCompactSupport, f.tsupport_normed_eq (μ := μ), isCompact_closedBall]
Theorem: wcovBy_iff_Ioo_eq
File: Mathlib/Order/Cover.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : Preorder β
a b c : α
⊢ (∀ ⦃c : α⦄, a < c → ¬c < b) ↔ Ioo a b = ∅
state_after: no goals
tactic: simp [eq_empty_iff_forall_not_mem]
Theorem: ProbabilityTheory.cond_add_cond_compl_eq
File: Mathlib/Probability/ConditionalProbability.lean

Proof steps:
state_before: Ω : Type u_1
Ω' : Type u_2
α : Type u_3
m : MeasurableSpace Ω
m' : MeasurableSpace Ω'
μ : Measure Ω
s t : Set Ω
inst✝ : IsFiniteMeasure μ
hms : MeasurableSet s
⊢ μ[|s] t * μ s + μ[|sᶜ] t * μ sᶜ = μ t
state_after: Ω : Type u_1
Ω' : Type u_2
α : Type u_3
m : MeasurableSpace Ω
m' : MeasurableSpace Ω'
μ : Measure Ω
s t : Set Ω
inst✝ : IsFiniteMeasure μ
hms : MeasurableSet s
⊢ μ (t ∩ s) + μ (t ∩ sᶜ) = μ t
tactic: rw [cond_mul_eq_inter μ hms, cond_mul_eq_inter μ hms.compl, Set.inter_comm _ t,
    Set.inter_comm _ t]
state_before: Ω : Type u_1
Ω' : Type u_2
α : Type u_3
m : MeasurableSpace Ω
m' : MeasurableSpace Ω'
μ : Measure Ω
s t : Set Ω
inst✝ : IsFiniteMeasure μ
hms : MeasurableSet s
⊢ μ (t ∩ s) + μ (t ∩ sᶜ) = μ t
state_after: no goals
tactic: exact measure_inter_add_diff t hms
Theorem: Set.EqOn.inter_preimage_eq
File: Mathlib/Data/Set/Function.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s s₁ s₂ : Set α
t✝ t₁ t₂ : Set β
p : Set γ
f f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
heq : EqOn f₁ f₂ s
t : Set β
x : α
hx : x ∈ s
⊢ x ∈ f₁ ⁻¹' t ↔ x ∈ f₂ ⁻¹' t
state_after: no goals
tactic: rw [mem_preimage, mem_preimage, heq hx]
Theorem: Pi.orthonormalBasis.toBasis
File: Mathlib/Analysis/InnerProductSpace/PiL2.lean

Proof steps:
state_before: ι✝ : Type u_1
ι' : Type u_2
𝕜✝ : Type u_3
inst✝¹⁴ : _root_.RCLike 𝕜✝
E✝ : Type u_4
inst✝¹³ : NormedAddCommGroup E✝
inst✝¹² : InnerProductSpace 𝕜✝ E✝
E' : Type u_5
inst✝¹¹ : NormedAddCommGroup E'
inst✝¹⁰ : InnerProductSpace 𝕜✝ E'
F : Type u_6
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : InnerProductSpace ℝ F
F' : Type u_7
inst✝⁷ : NormedAddCommGroup F'
inst✝⁶ : InnerProductSpace ℝ F'
inst✝⁵ : Fintype ι✝
η : Type u_8
inst✝⁴ : Fintype η
ι : η → Type u_9
inst✝³ : (i : η) → Fintype (ι i)
𝕜 : Type u_10
inst✝² : _root_.RCLike 𝕜
E : η → Type u_11
inst✝¹ : (i : η) → NormedAddCommGroup (E i)
inst✝ : (i : η) → InnerProductSpace 𝕜 (E i)
B : (i : η) → OrthonormalBasis (ι i) 𝕜 (E i)
⊢ (Pi.orthonormalBasis B).toBasis = (Pi.basis fun i => (B i).toBasis).map (WithLp.linearEquiv 2 𝕜 ((j : η) → E j)).symm
state_after: case a.h
ι✝ : Type u_1
ι' : Type u_2
𝕜✝ : Type u_3
inst✝¹⁴ : _root_.RCLike 𝕜✝
E✝ : Type u_4
inst✝¹³ : NormedAddCommGroup E✝
inst✝¹² : InnerProductSpace 𝕜✝ E✝
E' : Type u_5
inst✝¹¹ : NormedAddCommGroup E'
inst✝¹⁰ : InnerProductSpace 𝕜✝ E'
F : Type u_6
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : InnerProductSpace ℝ F
F' : Type u_7
inst✝⁷ : NormedAddCommGroup F'
inst✝⁶ : InnerProductSpace ℝ F'
inst✝⁵ : Fintype ι✝
η : Type u_8
inst✝⁴ : Fintype η
ι : η → Type u_9
inst✝³ : (i : η) → Fintype (ι i)
𝕜 : Type u_10
inst✝² : _root_.RCLike 𝕜
E : η → Type u_11
inst✝¹ : (i : η) → NormedAddCommGroup (E i)
inst✝ : (i : η) → InnerProductSpace 𝕜 (E i)
B : (i : η) → OrthonormalBasis (ι i) 𝕜 (E i)
i✝¹ : (i : η) × ι i
i✝ : η
⊢ (Pi.orthonormalBasis B).toBasis i✝¹ i✝ =
    ((Pi.basis fun i => (B i).toBasis).map (WithLp.linearEquiv 2 𝕜 ((j : η) → E j)).symm) i✝¹ i✝
tactic: ext
state_before: case a.h
ι✝ : Type u_1
ι' : Type u_2
𝕜✝ : Type u_3
inst✝¹⁴ : _root_.RCLike 𝕜✝
E✝ : Type u_4
inst✝¹³ : NormedAddCommGroup E✝
inst✝¹² : InnerProductSpace 𝕜✝ E✝
E' : Type u_5
inst✝¹¹ : NormedAddCommGroup E'
inst✝¹⁰ : InnerProductSpace 𝕜✝ E'
F : Type u_6
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : InnerProductSpace ℝ F
F' : Type u_7
inst✝⁷ : NormedAddCommGroup F'
inst✝⁶ : InnerProductSpace ℝ F'
inst✝⁵ : Fintype ι✝
η : Type u_8
inst✝⁴ : Fintype η
ι : η → Type u_9
inst✝³ : (i : η) → Fintype (ι i)
𝕜 : Type u_10
inst✝² : _root_.RCLike 𝕜
E : η → Type u_11
inst✝¹ : (i : η) → NormedAddCommGroup (E i)
inst✝ : (i : η) → InnerProductSpace 𝕜 (E i)
B : (i : η) → OrthonormalBasis (ι i) 𝕜 (E i)
i✝¹ : (i : η) × ι i
i✝ : η
⊢ (Pi.orthonormalBasis B).toBasis i✝¹ i✝ =
    ((Pi.basis fun i => (B i).toBasis).map (WithLp.linearEquiv 2 𝕜 ((j : η) → E j)).symm) i✝¹ i✝
state_after: no goals
tactic: rfl
Theorem: CategoryTheory.Abelian.Pseudoelement.apply_zero
File: Mathlib/CategoryTheory/Abelian/Pseudoelements.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Abelian C
P Q : C
f : P ⟶ Q
⊢ pseudoApply f 0 = 0
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Abelian C
P Q : C
f : P ⟶ Q
⊢ ⟦Over.mk ((Over.mk 0).hom ≫ f)⟧ = 0
tactic: rw [pseudoZero_def, pseudoApply_mk']
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Abelian C
P Q : C
f : P ⟶ Q
⊢ ⟦Over.mk ((Over.mk 0).hom ≫ f)⟧ = 0
state_after: no goals
tactic: simp
Theorem: CategoryTheory.congrArg_mpr_hom_left
File: Mathlib/CategoryTheory/EqToHom.lean

Proof steps:
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
β : Sort u_1
X Y Z : C
p : X = Y
q : Y ⟶ Z
⊢ ⋯.mpr q = eqToHom p ≫ q
state_after: case refl
C : Type u₁
inst✝ : Category.{v₁, u₁} C
β : Sort u_1
X Z : C
q : X ⟶ Z
⊢ ⋯.mpr q = eqToHom ⋯ ≫ q
tactic: cases p
state_before: case refl
C : Type u₁
inst✝ : Category.{v₁, u₁} C
β : Sort u_1
X Z : C
q : X ⟶ Z
⊢ ⋯.mpr q = eqToHom ⋯ ≫ q
state_after: no goals
tactic: simp
Theorem: tendsto_order
File: Mathlib/Topology/Order/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : TopologicalSpace α
inst✝¹ : Preorder α
inst✝ : OrderTopology α
f : β → α
a : α
x : Filter β
⊢ Tendsto f x (𝓝 a) ↔ (∀ a' < a, ∀ᶠ (b : β) in x, a' < f b) ∧ ∀ a' > a, ∀ᶠ (b : β) in x, f b < a'
state_after: α : Type u
β : Type v
γ : Type w
inst✝² : TopologicalSpace α
inst✝¹ : Preorder α
inst✝ : OrderTopology α
f : β → α
a : α
x : Filter β
⊢ ((∀ i ∈ Iio a, ∀ᶠ (a : β) in x, f a ∈ Ioi i) ∧ ∀ i ∈ Ioi a, ∀ᶠ (a : β) in x, f a ∈ Iio i) ↔
    (∀ a' < a, ∀ᶠ (b : β) in x, a' < f b) ∧ ∀ a' > a, ∀ᶠ (b : β) in x, f b < a'
tactic: simp only [nhds_eq_order a, tendsto_inf, tendsto_iInf, tendsto_principal]
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : TopologicalSpace α
inst✝¹ : Preorder α
inst✝ : OrderTopology α
f : β → α
a : α
x : Filter β
⊢ ((∀ i ∈ Iio a, ∀ᶠ (a : β) in x, f a ∈ Ioi i) ∧ ∀ i ∈ Ioi a, ∀ᶠ (a : β) in x, f a ∈ Iio i) ↔
    (∀ a' < a, ∀ᶠ (b : β) in x, a' < f b) ∧ ∀ a' > a, ∀ᶠ (b : β) in x, f b < a'
state_after: no goals
tactic: rfl
Theorem: Basis.coe_sumCoords_of_fintype
File: Mathlib/LinearAlgebra/Basis.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
R : Type u_3
R₂ : Type u_4
K : Type u_5
M : Type u_6
M' : Type u_7
M'' : Type u_8
V : Type u
V' : Type u_9
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : AddCommMonoid M'
inst✝¹ : Module R M'
b b₁ : Basis ι R M
i : ι
c : R
x : M
inst✝ : Fintype ι
⊢ ⇑b.sumCoords = ⇑(∑ i : ι, b.coord i)
state_after: case h
ι : Type u_1
ι' : Type u_2
R : Type u_3
R₂ : Type u_4
K : Type u_5
M : Type u_6
M' : Type u_7
M'' : Type u_8
V : Type u
V' : Type u_9
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : AddCommMonoid M'
inst✝¹ : Module R M'
b b₁ : Basis ι R M
i : ι
c : R
x : M
inst✝ : Fintype ι
m : M
⊢ b.sumCoords m = (∑ i : ι, b.coord i) m
tactic: ext m
state_before: case h
ι : Type u_1
ι' : Type u_2
R : Type u_3
R₂ : Type u_4
K : Type u_5
M : Type u_6
M' : Type u_7
M'' : Type u_8
V : Type u
V' : Type u_9
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : AddCommMonoid M'
inst✝¹ : Module R M'
b b₁ : Basis ι R M
i : ι
c : R
x : M
inst✝ : Fintype ι
m : M
⊢ b.sumCoords m = (∑ i : ι, b.coord i) m
state_after: no goals
tactic: simp only [sumCoords, Finsupp.sum_fintype, LinearMap.id_coe, LinearEquiv.coe_coe, coord_apply,
    id, Fintype.sum_apply, imp_true_iff, Finsupp.coe_lsum, LinearMap.coe_comp, comp_apply,
    LinearMap.coeFn_sum]
Theorem: Monoid.CoprodI.Word.mem_rcons_iff
File: Mathlib/GroupTheory/CoprodI.lean

Proof steps:
state_before: ι : Type u_1
M : ι → Type u_2
inst✝² : (i : ι) → Monoid (M i)
N : Type u_3
inst✝¹ : Monoid N
inst✝ : (i : ι) → DecidableEq (M i)
i j : ι
p : Pair M i
m : M j
⊢ ⟨j, m⟩ ∈ (rcons p).toList ↔ ⟨j, m⟩ ∈ p.tail.toList ∨ m ≠ 1 ∧ ∃ (h : i = j), m = h ▸ p.head
state_after: ι : Type u_1
M : ι → Type u_2
inst✝² : (i : ι) → Monoid (M i)
N : Type u_3
inst✝¹ : Monoid N
inst✝ : (i : ι) → DecidableEq (M i)
i j : ι
p : Pair M i
m : M j
⊢ ⟨j, m⟩ ∈
      (if h : p.head = 1 then p.tail
        else { toList := ⟨i, p.head⟩ :: p.tail.toList, ne_one := ⋯, chain_ne := ⋯ }).toList ↔
    ⟨j, m⟩ ∈ p.tail.toList ∨ ¬m = 1 ∧ ∃ (h : i = j), m = h ▸ p.head
tactic: simp only [rcons, cons, ne_eq]
state_before: ι : Type u_1
M : ι → Type u_2
inst✝² : (i : ι) → Monoid (M i)
N : Type u_3
inst✝¹ : Monoid N
inst✝ : (i : ι) → DecidableEq (M i)
i j : ι
p : Pair M i
m : M j
⊢ ⟨j, m⟩ ∈
      (if h : p.head = 1 then p.tail
        else { toList := ⟨i, p.head⟩ :: p.tail.toList, ne_one := ⋯, chain_ne := ⋯ }).toList ↔
    ⟨j, m⟩ ∈ p.tail.toList ∨ ¬m = 1 ∧ ∃ (h : i = j), m = h ▸ p.head
state_after: case pos
ι : Type u_1
M : ι → Type u_2
inst✝² : (i : ι) → Monoid (M i)
N : Type u_3
inst✝¹ : Monoid N
inst✝ : (i : ι) → DecidableEq (M i)
i j : ι
p : Pair M i
m : M j
hij : i = j
⊢ ⟨j, m⟩ ∈
      (if h : p.head = 1 then p.tail
        else { toList := ⟨i, p.head⟩ :: p.tail.toList, ne_one := ⋯, chain_ne := ⋯ }).toList ↔
    ⟨j, m⟩ ∈ p.tail.toList ∨ ¬m = 1 ∧ ∃ (h : i = j), m = h ▸ p.head

case neg
ι : Type u_1
M : ι → Type u_2
inst✝² : (i : ι) → Monoid (M i)
N : Type u_3
inst✝¹ : Monoid N
inst✝ : (i : ι) → DecidableEq (M i)
i j : ι
p : Pair M i
m : M j
hij : ¬i = j
⊢ ⟨j, m⟩ ∈
      (if h : p.head = 1 then p.tail
        else { toList := ⟨i, p.head⟩ :: p.tail.toList, ne_one := ⋯, chain_ne := ⋯ }).toList ↔
    ⟨j, m⟩ ∈ p.tail.toList ∨ ¬m = 1 ∧ ∃ (h : i = j), m = h ▸ p.head
tactic: by_cases hij : i = j
Theorem: IsOpen.exists_Ioo_subset
File: Mathlib/Topology/Order/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : Nontrivial α
s : Set α
hs : IsOpen s
h : s.Nonempty
⊢ ∃ a b, a < b ∧ Ioo a b ⊆ s
state_after: case intro
α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : Nontrivial α
s : Set α
hs : IsOpen s
x : α
hx : x ∈ s
⊢ ∃ a b, a < b ∧ Ioo a b ⊆ s
tactic: obtain ⟨x, hx⟩ : ∃ x, x ∈ s := h
state_before: case intro
α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : Nontrivial α
s : Set α
hs : IsOpen s
x : α
hx : x ∈ s
⊢ ∃ a b, a < b ∧ Ioo a b ⊆ s
state_after: case intro.intro
α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : Nontrivial α
s : Set α
hs : IsOpen s
x : α
hx : x ∈ s
y : α
hy : y ≠ x
⊢ ∃ a b, a < b ∧ Ioo a b ⊆ s
tactic: obtain ⟨y, hy⟩ : ∃ y, y ≠ x := exists_ne x
state_before: case intro.intro
α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : Nontrivial α
s : Set α
hs : IsOpen s
x : α
hx : x ∈ s
y : α
hy : y ≠ x
⊢ ∃ a b, a < b ∧ Ioo a b ⊆ s
state_after: case intro.intro.inl
α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : Nontrivial α
s : Set α
hs : IsOpen s
x : α
hx : x ∈ s
y : α
hy : y ≠ x
H : x < y
⊢ ∃ a b, a < b ∧ Ioo a b ⊆ s

case intro.intro.inr.inl
α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : Nontrivial α
s : Set α
hs : IsOpen s
x : α
hx : x ∈ s
hy : x ≠ x
⊢ ∃ a b, a < b ∧ Ioo a b ⊆ s

case intro.intro.inr.inr
α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : Nontrivial α
s : Set α
hs : IsOpen s
x : α
hx : x ∈ s
y : α
hy : y ≠ x
H : y < x
⊢ ∃ a b, a < b ∧ Ioo a b ⊆ s
tactic: rcases lt_trichotomy x y with (H | rfl | H)
Theorem: div_le_div
File: Mathlib/Algebra/Order/Field/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
hc : 0 ≤ c
hac : a ≤ c
hd : 0 < d
hbd : d ≤ b
⊢ a / b ≤ c / d
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
hc : 0 ≤ c
hac : a ≤ c
hd : 0 < d
hbd : d ≤ b
⊢ a * d ≤ c * b
tactic: rw [div_le_div_iff (hd.trans_le hbd) hd]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
hc : 0 ≤ c
hac : a ≤ c
hd : 0 < d
hbd : d ≤ b
⊢ a * d ≤ c * b
state_after: no goals
tactic: exact mul_le_mul hac hbd hd.le hc
Theorem: Nat.le_or_le_of_add_eq_add_pred
File: Mathlib/Data/Nat/Defs.lean

Proof steps:
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
h : a + c = b + d - 1
⊢ b ≤ a ∨ d ≤ c
state_after: case inl.h
a b c d m n k : ℕ
p q : ℕ → Prop
h : a + c = b + d - 1
h' : b ≤ a
⊢ b ≤ a

case inr.h
a b c d m n k : ℕ
p q : ℕ → Prop
h : a + c = b + d - 1
h' : a < b
⊢ d ≤ c
tactic: rcases le_or_lt b a with h' | h' <;> [left; right]
Theorem: Orientation.two_zsmul_oangle_neg_left
File: Mathlib/Geometry/Euclidean/Angle/Oriented/Basic.lean

Proof steps:
state_before: V : Type u_1
V' : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : NormedAddCommGroup V'
inst✝³ : InnerProductSpace ℝ V
inst✝² : InnerProductSpace ℝ V'
inst✝¹ : Fact (finrank ℝ V = 2)
inst✝ : Fact (finrank ℝ V' = 2)
o : Orientation ℝ V (Fin 2)
x y : V
⊢ 2 • o.oangle (-x) y = 2 • o.oangle x y
state_after: case pos
V : Type u_1
V' : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : NormedAddCommGroup V'
inst✝³ : InnerProductSpace ℝ V
inst✝² : InnerProductSpace ℝ V'
inst✝¹ : Fact (finrank ℝ V = 2)
inst✝ : Fact (finrank ℝ V' = 2)
o : Orientation ℝ V (Fin 2)
x y : V
hx : x = 0
⊢ 2 • o.oangle (-x) y = 2 • o.oangle x y

case neg
V : Type u_1
V' : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : NormedAddCommGroup V'
inst✝³ : InnerProductSpace ℝ V
inst✝² : InnerProductSpace ℝ V'
inst✝¹ : Fact (finrank ℝ V = 2)
inst✝ : Fact (finrank ℝ V' = 2)
o : Orientation ℝ V (Fin 2)
x y : V
hx : ¬x = 0
⊢ 2 • o.oangle (-x) y = 2 • o.oangle x y
tactic: by_cases hx : x = 0
Theorem: Nat.coprime_fintype_prod_right_iff
File: Mathlib/Data/Nat/GCD/BigOperators.lean

Proof steps:
state_before: ι : Type u_1
inst✝ : Fintype ι
x : ℕ
s : ι → ℕ
⊢ x.Coprime (∏ i : ι, s i) ↔ ∀ (i : ι), x.Coprime (s i)
state_after: no goals
tactic: simp [coprime_prod_right_iff]
Theorem: CategoryTheory.Limits.image.ι_zero
File: Mathlib/CategoryTheory/Limits/Shapes/ZeroMorphisms.lean

Proof steps:
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
inst✝² : HasZeroMorphisms C
inst✝¹ : HasZeroObject C
X Y : C
inst✝ : HasImage 0
⊢ ι 0 = 0
state_after: C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
inst✝² : HasZeroMorphisms C
inst✝¹ : HasZeroObject C
X Y : C
inst✝ : HasImage 0
⊢ lift (monoFactorisationZero X Y) ≫ (monoFactorisationZero X Y).m = 0
tactic: rw [← image.lift_fac (monoFactorisationZero X Y)]
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
inst✝² : HasZeroMorphisms C
inst✝¹ : HasZeroObject C
X Y : C
inst✝ : HasImage 0
⊢ lift (monoFactorisationZero X Y) ≫ (monoFactorisationZero X Y).m = 0
state_after: no goals
tactic: simp
Theorem: Nat.dvd_ord_compl_of_dvd_not_dvd
File: Mathlib/Data/Nat/Factorization/Basic.lean

Proof steps:
state_before: a b m n✝ p✝ p d n : ℕ
hdn : d ∣ n
hpd : ¬p ∣ d
⊢ d ∣ n / p ^ n.factorization p
state_after: no goals
tactic: if hn0 : n = 0 then simp [hn0] else
  if hd0 : d = 0 then simp [hd0] at hpd else
  rw [← factorization_le_iff_dvd hd0 (ord_compl_pos p hn0).ne', factorization_ord_compl]
  intro q
  if hqp : q = p then
    simp [factorization_eq_zero_iff, hqp, hpd]
  else
    simp [hqp, (factorization_le_iff_dvd hd0 hn0).2 hdn q]
Theorem: AddCircle.finite_setOf_add_order_eq
File: Mathlib/Topology/Instances/AddCircle.lean

Proof steps:
state_before: 𝕜 : Type u_1
B : Type u_2
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
p q : 𝕜
hp : Fact (0 < p)
n : ℕ
hn : 0 < n
⊢ Nat.card ↑{u | addOrderOf u = n} ≠ 0
state_after: no goals
tactic: simp [hn.ne']
Theorem: Finset.inj_on_of_surj_on_of_card_le
File: Mathlib/Data/Finset/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
R : Type u_3
s t✝ u : Finset α
f✝ : α → β
n : ℕ
t : Finset β
f : (a : α) → a ∈ s → β
hf : ∀ (a : α) (ha : a ∈ s), f a ha ∈ t
hsurj : ∀ b ∈ t, ∃ a, ∃ (ha : a ∈ s), f a ha = b
hst : s.card ≤ t.card
a₁ : α
ha₁ : a₁ ∈ s
a₂ : α
ha₂ : a₂ ∈ s
ha₁a₂ : f a₁ ha₁ = f a₂ ha₂
this : Inhabited { x // x ∈ s }
f' : { x // x ∈ s } → { x // x ∈ t } := fun x => ⟨f ↑x ⋯, ⋯⟩
g : { x // x ∈ t } → { x // x ∈ s } := surjInv ⋯
hg : Injective g
x : { x // x ∈ s }
⊢ s.attach.card ≤ t.attach.card
state_after: no goals
tactic: simpa