ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: LieIdeal.ker_incl
File: Mathlib/Algebra/Lie/Submodule.lean

Proof steps:
state_before: R : Type u
L : Type v
L' : Type w₂
M : Type w
M' : Type w₁
inst✝¹² : CommRing R
inst✝¹¹ : LieRing L
inst✝¹⁰ : LieAlgebra R L
inst✝⁹ : LieRing L'
inst✝⁸ : LieAlgebra R L'
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
f : L →ₗ⁅R⁆ L'
I : LieIdeal R L
J : LieIdeal R L'
⊢ I.incl.ker = ⊥
state_after: case h
R : Type u
L : Type v
L' : Type w₂
M : Type w
M' : Type w₁
inst✝¹² : CommRing R
inst✝¹¹ : LieRing L
inst✝¹⁰ : LieAlgebra R L
inst✝⁹ : LieRing L'
inst✝⁸ : LieAlgebra R L'
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
f : L →ₗ⁅R⁆ L'
I : LieIdeal R L
J : LieIdeal R L'
m✝ : ↥↑I
⊢ m✝ ∈ I.incl.ker ↔ m✝ ∈ ⊥
tactic: ext
state_before: case h
R : Type u
L : Type v
L' : Type w₂
M : Type w
M' : Type w₁
inst✝¹² : CommRing R
inst✝¹¹ : LieRing L
inst✝¹⁰ : LieAlgebra R L
inst✝⁹ : LieRing L'
inst✝⁸ : LieAlgebra R L'
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
f : L →ₗ⁅R⁆ L'
I : LieIdeal R L
J : LieIdeal R L'
m✝ : ↥↑I
⊢ m✝ ∈ I.incl.ker ↔ m✝ ∈ ⊥
state_after: no goals
tactic: simp
Theorem: groupCohomology.resolution.diagonalSucc_inv_single_single
File: Mathlib/RepresentationTheory/GroupCohomology/Resolution.lean

Proof steps:
state_before: k G : Type u
inst✝¹ : CommRing k
n : ℕ
inst✝ : Group G
g : G
f : Fin n → G
a b : k
⊢ (diagonalSucc k G n).inv.hom (single g a ⊗ₜ[k] single f b) = single (g • partialProd f) (a * b)
state_after: k G : Type u
inst✝¹ : CommRing k
n : ℕ
inst✝ : Group G
g : G
f : Fin n → G
a b : k
⊢ mapDomain (actionDiagonalSucc G n).inv.hom
      ((lcongr (Equiv.refl (G × (Fin n → G))) (TensorProduct.lid k k))
        ((finsuppTensorFinsupp k k k k G (Fin n → G)) (single g a ⊗ₜ[k] single f b))) =
    single (g • partialProd f) (a * b)
tactic: change mapDomain (actionDiagonalSucc G n).inv.hom
    (lcongr (Equiv.refl (G × (Fin n → G))) (TensorProduct.lid k k)
      (finsuppTensorFinsupp k k k k G (Fin n → G) (single g a ⊗ₜ[k] single f b)))
    = single (g • partialProd f) (a * b)
state_before: k G : Type u
inst✝¹ : CommRing k
n : ℕ
inst✝ : Group G
g : G
f : Fin n → G
a b : k
⊢ mapDomain (actionDiagonalSucc G n).inv.hom
      ((lcongr (Equiv.refl (G × (Fin n → G))) (TensorProduct.lid k k))
        ((finsuppTensorFinsupp k k k k G (Fin n → G)) (single g a ⊗ₜ[k] single f b))) =
    single (g • partialProd f) (a * b)
state_after: k G : Type u
inst✝¹ : CommRing k
n : ℕ
inst✝ : Group G
g : G
f : Fin n → G
a b : k
⊢ single (g • partialProd f) ((TensorProduct.lid k k) (a ⊗ₜ[k] b)) = single (g • partialProd f) (a * b)
tactic: rw [finsuppTensorFinsupp_single, lcongr_single, mapDomain_single, Equiv.refl_apply,
    actionDiagonalSucc_inv_apply]
state_before: k G : Type u
inst✝¹ : CommRing k
n : ℕ
inst✝ : Group G
g : G
f : Fin n → G
a b : k
⊢ single (g • partialProd f) ((TensorProduct.lid k k) (a ⊗ₜ[k] b)) = single (g • partialProd f) (a * b)
state_after: no goals
tactic: rfl
Theorem: CategoryTheory.Endofunctor.Algebra.Initial.left_inv'
File: Mathlib/CategoryTheory/Endofunctor/Algebra.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
F : C ⥤ C
A A₀ A₁ A₂ : Algebra F
f : A₀ ⟶ A₁
g : A₁ ⟶ A₂
h : Limits.IsInitial A
⊢ F.map (strInv h ≫ A.str) ≫ A.str = A.str ≫ strInv h ≫ A.str
state_after: no goals
tactic: rw [← Category.assoc, F.map_comp, strInv, ← Hom.h]
Theorem: Turing.ListBlank.nth_succ
File: Mathlib/Computability/TuringMachine.lean

Proof steps:
state_before: Γ : Type u_1
inst✝ : Inhabited Γ
l : ListBlank Γ
n : ℕ
⊢ l.nth (n + 1) = l.tail.nth n
state_after: Γ : Type u_1
inst✝ : Inhabited Γ
l : ListBlank Γ
n : ℕ
⊢ (cons l.head l.tail).nth (n + 1) = l.tail.nth n
tactic: conv => lhs; rw [← ListBlank.cons_head_tail l]
state_before: Γ : Type u_1
inst✝ : Inhabited Γ
l : ListBlank Γ
n : ℕ
⊢ (cons l.head l.tail).nth (n + 1) = l.tail.nth n
state_after: no goals
tactic: exact Quotient.inductionOn' l.tail fun l ↦ rfl
Theorem: dist_anti_left_pi
File: Mathlib/Analysis/Normed/Order/UpperLower.lean

Proof steps:
state_before: α : Type u_1
ι : Type u_2
inst✝ : Fintype ι
s t : Set (ι → ℝ)
a₁ a₂ b₁ b₂ x y : ι → ℝ
δ : ℝ
⊢ AntitoneOn (fun x => dist x y) (Iic y)
state_after: α : Type u_1
ι : Type u_2
inst✝ : Fintype ι
s t : Set (ι → ℝ)
a₁ a₂ b₁ b₂ x y : ι → ℝ
δ : ℝ
y₁ : ι → ℝ
hy₁ : y₁ ∈ Iic y
y₂ : ι → ℝ
hy₂ : y₂ ∈ Iic y
hy : y₁ ≤ y₂
i : ι
x✝ : i ∈ Finset.univ
⊢ nndist (y₂ i) (y i) ≤ nndist (y₁ i) (y i)
tactic: refine fun y₁ hy₁ y₂ hy₂ hy ↦ NNReal.coe_le_coe.2 (Finset.sup_mono_fun fun i _ ↦ ?_)
state_before: α : Type u_1
ι : Type u_2
inst✝ : Fintype ι
s t : Set (ι → ℝ)
a₁ a₂ b₁ b₂ x y : ι → ℝ
δ : ℝ
y₁ : ι → ℝ
hy₁ : y₁ ∈ Iic y
y₂ : ι → ℝ
hy₂ : y₂ ∈ Iic y
hy : y₁ ≤ y₂
i : ι
x✝ : i ∈ Finset.univ
⊢ nndist (y₂ i) (y i) ≤ nndist (y₁ i) (y i)
state_after: α : Type u_1
ι : Type u_2
inst✝ : Fintype ι
s t : Set (ι → ℝ)
a₁ a₂ b₁ b₂ x y : ι → ℝ
δ : ℝ
y₁ : ι → ℝ
hy₁ : y₁ ∈ Iic y
y₂ : ι → ℝ
hy₂ : y₂ ∈ Iic y
hy : y₁ ≤ y₂
i : ι
x✝ : i ∈ Finset.univ
⊢ (y i - y₂ i).toNNReal ≤ (y i - y₁ i).toNNReal
tactic: rw [Real.nndist_eq', Real.nnabs_of_nonneg (sub_nonneg_of_le (‹_ ≤ y› i : y₂ i ≤ y i)),
    Real.nndist_eq', Real.nnabs_of_nonneg (sub_nonneg_of_le (‹_ ≤ y› i : y₁ i ≤ y i))]
state_before: α : Type u_1
ι : Type u_2
inst✝ : Fintype ι
s t : Set (ι → ℝ)
a₁ a₂ b₁ b₂ x y : ι → ℝ
δ : ℝ
y₁ : ι → ℝ
hy₁ : y₁ ∈ Iic y
y₂ : ι → ℝ
hy₂ : y₂ ∈ Iic y
hy : y₁ ≤ y₂
i : ι
x✝ : i ∈ Finset.univ
⊢ (y i - y₂ i).toNNReal ≤ (y i - y₁ i).toNNReal
state_after: no goals
tactic: exact Real.toNNReal_mono (sub_le_sub_left (hy _) _)
Theorem: MonoidAlgebra.mul_apply_right
File: Mathlib/Algebra/MonoidAlgebra/Basic.lean

Proof steps:
state_before: k : Type u₁
G : Type u₂
H : Type u_1
R : Type u_2
inst✝¹ : Semiring k
inst✝ : Group G
f g : MonoidAlgebra k G
x : G
⊢ (f * g) x = sum g fun a b => (f * single a b) x
state_after: no goals
tactic: rw [← Finsupp.sum_apply, ← Finsupp.mul_sum f g, g.sum_single]
state_before: k : Type u₁
G : Type u₂
H : Type u_1
R : Type u_2
inst✝¹ : Semiring k
inst✝ : Group G
f g : MonoidAlgebra k G
x : G
⊢ (sum g fun a b => (f * single a b) x) = sum g fun a b => f (x * a⁻¹) * b
state_after: no goals
tactic: simp only [mul_single_apply, Finsupp.sum]
Theorem: Finsupp.split_apply
File: Mathlib/Data/Finsupp/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
αs : ι → Type u_13
inst✝ : Zero M
l : (i : ι) × αs i →₀ M
i : ι
x : αs i
⊢ (l.split i) x = l ⟨i, x⟩
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
αs : ι → Type u_13
inst✝ : Zero M
l : (i : ι) × αs i →₀ M
i : ι
x : αs i
⊢ (comapDomain (Sigma.mk i) l ⋯) x = l ⟨i, x⟩
tactic: dsimp only [split]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
αs : ι → Type u_13
inst✝ : Zero M
l : (i : ι) × αs i →₀ M
i : ι
x : αs i
⊢ (comapDomain (Sigma.mk i) l ⋯) x = l ⟨i, x⟩
state_after: no goals
tactic: rw [comapDomain_apply]
Theorem: MvPolynomial.pderiv_X_of_ne
File: Mathlib/Algebra/MvPolynomial/PDeriv.lean

Proof steps:
state_before: R : Type u
σ : Type v
a a' a₁ a₂ : R
s : σ →₀ ℕ
inst✝ : CommSemiring R
i j : σ
h : j ≠ i
⊢ (pderiv i) (X j) = 0
state_after: no goals
tactic: classical simp [h]
Theorem: Set.countable_setOf_nonempty_of_disjoint
File: Mathlib/Data/Set/Countable.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
f : β → Set α
hf : Pairwise (Disjoint on f)
s : Set α
h'f : ∀ (t : β), f t ⊆ s
hs : s.Countable
⊢ {t | (f t).Nonempty}.Countable
state_after: α : Type u
β : Type v
γ : Type w
ι : Sort x
f : β → Set α
hf : Pairwise (Disjoint on f)
s : Set α
h'f : ∀ (t : β), f t ⊆ s
hs : Countable ↑s
⊢ Countable ↑{t | (f t).Nonempty}
tactic: rw [← Set.countable_coe_iff] at hs ⊢
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
f : β → Set α
hf : Pairwise (Disjoint on f)
s : Set α
h'f : ∀ (t : β), f t ⊆ s
hs : Countable ↑s
⊢ Countable ↑{t | (f t).Nonempty}
state_after: α : Type u
β : Type v
γ : Type w
ι : Sort x
f : β → Set α
hf : Pairwise (Disjoint on f)
s : Set α
h'f : ∀ (t : β), f t ⊆ s
hs : Countable ↑s
this : ∀ (t : { t // (f t).Nonempty }), ∃ x, ↑x ∈ f ↑t
⊢ Countable ↑{t | (f t).Nonempty}
tactic: have : ∀ t : {t // (f t).Nonempty}, ∃ x : s, x.1 ∈ f t := by
    rintro ⟨t, ⟨x, hx⟩⟩
    exact ⟨⟨x, (h'f t hx)⟩, hx⟩
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
f : β → Set α
hf : Pairwise (Disjoint on f)
s : Set α
h'f : ∀ (t : β), f t ⊆ s
hs : Countable ↑s
this : ∀ (t : { t // (f t).Nonempty }), ∃ x, ↑x ∈ f ↑t
⊢ Countable ↑{t | (f t).Nonempty}
state_after: α : Type u
β : Type v
γ : Type w
ι : Sort x
f : β → Set α
hf : Pairwise (Disjoint on f)
s : Set α
h'f : ∀ (t : β), f t ⊆ s
hs : Countable ↑s
F : { t // (f t).Nonempty } → ↑s
hF : ∀ (t : { t // (f t).Nonempty }), ↑(F t) ∈ f ↑t
⊢ Countable ↑{t | (f t).Nonempty}
tactic: choose F hF using this
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
f : β → Set α
hf : Pairwise (Disjoint on f)
s : Set α
h'f : ∀ (t : β), f t ⊆ s
hs : Countable ↑s
F : { t // (f t).Nonempty } → ↑s
hF : ∀ (t : { t // (f t).Nonempty }), ↑(F t) ∈ f ↑t
⊢ Countable ↑{t | (f t).Nonempty}
state_after: α : Type u
β : Type v
γ : Type w
ι : Sort x
f : β → Set α
hf : Pairwise (Disjoint on f)
s : Set α
h'f : ∀ (t : β), f t ⊆ s
hs : Countable ↑s
F : { t // (f t).Nonempty } → ↑s
hF : ∀ (t : { t // (f t).Nonempty }), ↑(F t) ∈ f ↑t
A : Injective F
⊢ Countable ↑{t | (f t).Nonempty}
tactic: have A : Injective F := by
    rintro ⟨t, ht⟩ ⟨t', ht'⟩ htt'
    have A : (f t ∩ f t').Nonempty := by
      refine ⟨F ⟨t, ht⟩, hF _, ?_⟩
      rw [htt']
      exact hF _
    simp only [Subtype.mk.injEq]
    by_contra H
    exact not_disjoint_iff_nonempty_inter.2 A (hf H)
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
f : β → Set α
hf : Pairwise (Disjoint on f)
s : Set α
h'f : ∀ (t : β), f t ⊆ s
hs : Countable ↑s
F : { t // (f t).Nonempty } → ↑s
hF : ∀ (t : { t // (f t).Nonempty }), ↑(F t) ∈ f ↑t
A : Injective F
⊢ Countable ↑{t | (f t).Nonempty}
state_after: no goals
tactic: exact Injective.countable A
Theorem: Finset.property_of_mem_map_subtype
File: Mathlib/Data/Finset/Image.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p : α → Prop
s : Finset { x // p x }
a : α
h : a ∈ map (Embedding.subtype fun x => p x) s
⊢ p a
state_after: case intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
p : α → Prop
s : Finset { x // p x }
x : { x // p x }
left✝ : x ∈ s
h : (Embedding.subtype fun x => p x) x ∈ map (Embedding.subtype fun x => p x) s
⊢ p ((Embedding.subtype fun x => p x) x)
tactic: rcases mem_map.1 h with ⟨x, _, rfl⟩
state_before: case intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
p : α → Prop
s : Finset { x // p x }
x : { x // p x }
left✝ : x ∈ s
h : (Embedding.subtype fun x => p x) x ∈ map (Embedding.subtype fun x => p x) s
⊢ p ((Embedding.subtype fun x => p x) x)
state_after: no goals
tactic: exact x.2
Theorem: Multiset.mem_sup
File: Mathlib/Data/Finset/Lattice.lean

Proof steps:
state_before: F : Type u_1
α✝ : Type u_2
β✝ : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
α : Type u_7
β : Type u_8
inst✝ : DecidableEq β
s : Finset α
f : α → Multiset β
x : β
⊢ x ∈ s.sup f ↔ ∃ v ∈ s, x ∈ f v
state_after: no goals
tactic: induction s using Finset.cons_induction <;> simp [*]
Theorem: SimpleGraph.Subgraph.le_induce_union
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

Proof steps:
state_before: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' G'' : G.Subgraph
s s' : Set V
⊢ G'.induce s ⊔ G'.induce s' ≤ G'.induce (s ∪ s')
state_after: case left
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' G'' : G.Subgraph
s s' : Set V
⊢ (G'.induce s ⊔ G'.induce s').verts ⊆ (G'.induce (s ∪ s')).verts

case right
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' G'' : G.Subgraph
s s' : Set V
⊢ ∀ ⦃v w : V⦄, (G'.induce s ⊔ G'.induce s').Adj v w → (G'.induce (s ∪ s')).Adj v w
tactic: constructor
Theorem: PNat.gcd_eq_left_iff_dvd
File: Mathlib/Data/PNat/Prime.lean

Proof steps:
state_before: m n : ℕ+
⊢ m ∣ n ↔ m.gcd n = m
state_after: m n : ℕ+
⊢ ↑m ∣ ↑n ↔ m.gcd n = m
tactic: rw [dvd_iff]
state_before: m n : ℕ+
⊢ ↑m ∣ ↑n ↔ m.gcd n = m
state_after: m n : ℕ+
⊢ (↑m).gcd ↑n = ↑m ↔ m.gcd n = m
tactic: rw [Nat.gcd_eq_left_iff_dvd]
state_before: m n : ℕ+
⊢ (↑m).gcd ↑n = ↑m ↔ m.gcd n = m
state_after: m n : ℕ+
⊢ (↑m).gcd ↑n = ↑m ↔ ↑(m.gcd n) = ↑m
tactic: rw [← coe_inj]
state_before: m n : ℕ+
⊢ (↑m).gcd ↑n = ↑m ↔ ↑(m.gcd n) = ↑m
state_after: no goals
tactic: simp
Theorem: DFinsupp.filter_apply_neg
File: Mathlib/Data/DFinsupp/Basic.lean

Proof steps:
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝¹ : (i : ι) → Zero (β i)
p : ι → Prop
inst✝ : DecidablePred p
f : Π₀ (i : ι), β i
i : ι
h : ¬p i
⊢ (filter p f) i = 0
state_after: no goals
tactic: simp only [filter_apply, if_neg h]
Theorem: WeierstrassCurve.Affine.CoordinateRing.C_addPolynomial
File: Mathlib/AlgebraicGeometry/EllipticCurve/Group.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : Affine R
f : R →+* S
x y L : R
⊢ C (W.addPolynomial x y L) - (Y - C (linePolynomial x y L)) * (W.negPolynomial - C (linePolynomial x y L)) =
    W.polynomial * 1
state_after: no goals
tactic: rw [W.C_addPolynomial, add_sub_cancel_left, mul_one]
Theorem: Nat.maxPowDiv.zero
File: Mathlib/Data/Nat/MaxPowDiv.lean

Proof steps:
state_before: p : ℕ
⊢ p.maxPowDiv 0 = 0
state_after: p : ℕ
⊢ go 0 p 0 = 0
tactic: dsimp [maxPowDiv]
state_before: p : ℕ
⊢ go 0 p 0 = 0
state_after: p : ℕ
⊢ (if 1 < p ∧ 0 < 0 ∧ 0 % p = 0 then go (0 + 1) p (0 / p) else 0) = 0
tactic: rw [maxPowDiv.go]
state_before: p : ℕ
⊢ (if 1 < p ∧ 0 < 0 ∧ 0 % p = 0 then go (0 + 1) p (0 / p) else 0) = 0
state_after: no goals
tactic: simp
Theorem: Complex.HadamardThreeLines.interpStrip_eq_of_pos
File: Mathlib/Analysis/Complex/Hadamard.lean

Proof steps:
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℂ → E
z : ℂ
h0 : 0 < sSupNormIm f 0
h1 : 0 < sSupNormIm f 1
⊢ interpStrip f z = ↑(sSupNormIm f 0) ^ (1 - z) * ↑(sSupNormIm f 1) ^ z
state_after: no goals
tactic: simp only [ne_of_gt h0, ne_of_gt h1, interpStrip, if_false, or_false]
Theorem: Set.iUnion₂_inter
File: Mathlib/Data/Set/Lattice.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
s : (i : ι) → κ i → Set α
t : Set α
⊢ (⋃ i, ⋃ j, s i j) ∩ t = ⋃ i, ⋃ j, s i j ∩ t
state_after: no goals
tactic: simp_rw [iUnion_inter]
Theorem: Set.wcovBy_insert
File: Mathlib/Order/Cover.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
s✝ t : Set α
a x : α
s : Set α
⊢ s ⩿ insert x s
state_after: α : Type u_1
β : Type u_2
s✝ t✝ : Set α
a x : α
s t : Set α
hst : s ≤ t
h2t : t ≤ insert x s
⊢ t = s ∨ t = insert x s
tactic: refine wcovBy_of_eq_or_eq (subset_insert x s) fun t hst h2t => ?_
state_before: α : Type u_1
β : Type u_2
s✝ t✝ : Set α
a x : α
s t : Set α
hst : s ≤ t
h2t : t ≤ insert x s
⊢ t = s ∨ t = insert x s
state_after: case pos
α : Type u_1
β : Type u_2
s✝ t✝ : Set α
a x : α
s t : Set α
hst : s ≤ t
h2t : t ≤ insert x s
h : x ∈ t
⊢ t = s ∨ t = insert x s

case neg
α : Type u_1
β : Type u_2
s✝ t✝ : Set α
a x : α
s t : Set α
hst : s ≤ t
h2t : t ≤ insert x s
h : x ∉ t
⊢ t = s ∨ t = insert x s
tactic: by_cases h : x ∈ t
Theorem: Commute.invOf_right
File: Mathlib/Algebra/Group/Invertible/Basic.lean

Proof steps:
state_before: α : Type u
inst✝¹ : Monoid α
a b : α
inst✝ : Invertible b
h : Commute a b
⊢ a * ⅟b = ⅟b * (b * a * ⅟b)
state_after: no goals
tactic: simp [mul_assoc]
state_before: α : Type u
inst✝¹ : Monoid α
a b : α
inst✝ : Invertible b
h : Commute a b
⊢ ⅟b * (b * a * ⅟b) = ⅟b * (a * b * ⅟b)
state_after: no goals
tactic: rw [h.eq]
state_before: α : Type u
inst✝¹ : Monoid α
a b : α
inst✝ : Invertible b
h : Commute a b
⊢ ⅟b * (a * b * ⅟b) = ⅟b * a
state_after: no goals
tactic: simp [mul_assoc]
Theorem: Filter.map_atTop_finset_sum_le_of_sum_eq
File: Mathlib/Order/Filter/AtTopBot.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝ : CommMonoid α
f : β → α
g : γ → α
h_eq : ∀ (u : Finset γ), ∃ v, ∀ (v' : Finset β), v ⊆ v' → ∃ u', u ⊆ u' ∧ ∏ x ∈ u', g x = ∏ b ∈ v', f b
⊢ map (fun s => ∏ b ∈ s, f b) atTop ≤ map (fun s => ∏ x ∈ s, g x) atTop
state_after: no goals
tactic: classical
    refine ((atTop_basis.map _).le_basis_iff (atTop_basis.map _)).2 fun b _ => ?_
    let ⟨v, hv⟩ := h_eq b
    refine ⟨v, trivial, ?_⟩
    simpa [image_subset_iff] using hv
Theorem: Primrec.list_append
File: Mathlib/Computability/Primrec.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
l₁ l₂ : List α
⊢ List.foldr (fun b s => ((l₁, l₂), b, s).2.1 :: ((l₁, l₂), b, s).2.2) (l₁, l₂).2 (l₁, l₂).1 = l₁ ++ l₂
state_after: no goals
tactic: induction l₁ <;> simp [*]
Theorem: PNat.XgcdType.finish_v
File: Mathlib/Data/PNat/Xgcd.lean

Proof steps:
state_before: u : XgcdType
hr : u.r = 0
⊢ u.finish.v = u.v
state_after: u : XgcdType
hr : u.r = 0
ha : u.r + ↑u.b * u.q = ↑u.a := rq_eq u
⊢ u.finish.v = u.v
tactic: let ha : u.r + u.b * u.q = u.a := u.rq_eq
state_before: u : XgcdType
hr : u.r = 0
ha : u.r + ↑u.b * u.q = ↑u.a := rq_eq u
⊢ u.finish.v = u.v
state_after: u : XgcdType
hr : u.r = 0
ha : ↑u.b * u.q = ↑u.a
⊢ u.finish.v = u.v
tactic: rw [hr, zero_add] at ha
state_before: u : XgcdType
hr : u.r = 0
ha : ↑u.b * u.q = ↑u.a
⊢ u.finish.v = u.v
state_after: case a
u : XgcdType
hr : u.r = 0
ha : ↑u.b * u.q = ↑u.a
⊢ u.finish.v.1 = u.v.1

case a
u : XgcdType
hr : u.r = 0
ha : ↑u.b * u.q = ↑u.a
⊢ u.finish.v.2 = u.v.2
tactic: ext
Theorem: MeasureTheory.martingalePart_eq_sum
File: Mathlib/Probability/Martingale/Centering.lean

Proof steps:
state_before: Ω : Type u_1
E : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f : ℕ → Ω → E
ℱ : Filtration ℕ m0
n : ℕ
⊢ martingalePart f ℱ μ = fun n => f 0 + ∑ i ∈ Finset.range n, (f (i + 1) - f i - μ[f (i + 1) - f i|↑ℱ i])
state_after: Ω : Type u_1
E : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f : ℕ → Ω → E
ℱ : Filtration ℕ m0
n : ℕ
⊢ (fun n => f n - ∑ i ∈ Finset.range n, μ[f (i + 1) - f i|↑ℱ i]) = fun n =>
    f 0 + ∑ i ∈ Finset.range n, (f (i + 1) - f i - μ[f (i + 1) - f i|↑ℱ i])
tactic: unfold martingalePart predictablePart
state_before: Ω : Type u_1
E : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f : ℕ → Ω → E
ℱ : Filtration ℕ m0
n : ℕ
⊢ (fun n => f n - ∑ i ∈ Finset.range n, μ[f (i + 1) - f i|↑ℱ i]) = fun n =>
    f 0 + ∑ i ∈ Finset.range n, (f (i + 1) - f i - μ[f (i + 1) - f i|↑ℱ i])
state_after: case h
Ω : Type u_1
E : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f : ℕ → Ω → E
ℱ : Filtration ℕ m0
n✝ n : ℕ
⊢ f n - ∑ i ∈ Finset.range n, μ[f (i + 1) - f i|↑ℱ i] =
    f 0 + ∑ i ∈ Finset.range n, (f (i + 1) - f i - μ[f (i + 1) - f i|↑ℱ i])
tactic: ext1 n
state_before: case h
Ω : Type u_1
E : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f : ℕ → Ω → E
ℱ : Filtration ℕ m0
n✝ n : ℕ
⊢ f n - ∑ i ∈ Finset.range n, μ[f (i + 1) - f i|↑ℱ i] =
    f 0 + ∑ i ∈ Finset.range n, (f (i + 1) - f i - μ[f (i + 1) - f i|↑ℱ i])
state_after: no goals
tactic: rw [Finset.eq_sum_range_sub f n, ← add_sub, ← Finset.sum_sub_distrib]
Theorem: AlgebraicGeometry.Scheme.Pullback.cocycle_fst_fst_snd
File: Mathlib/AlgebraicGeometry/Pullbacks.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : X.OpenCover
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (𝒰.map i ≫ f) g
i j k : 𝒰.J
⊢ t' 𝒰 f g i j k ≫
      t' 𝒰 f g j k i ≫
        t' 𝒰 f g k i j ≫
          pullback.fst (fV 𝒰 f g i j) (fV 𝒰 f g i k) ≫
            pullback.fst (pullback.fst (𝒰.map i ≫ f) g ≫ 𝒰.map i) (𝒰.map j) ≫ pullback.snd (𝒰.map i ≫ f) g =
    pullback.fst (fV 𝒰 f g i j) (fV 𝒰 f g i k) ≫
      pullback.fst (pullback.fst (𝒰.map i ≫ f) g ≫ 𝒰.map i) (𝒰.map j) ≫ pullback.snd (𝒰.map i ≫ f) g
state_after: no goals
tactic: simp only [t'_fst_fst_snd]
Theorem: MeasureTheory.measure_compl₀
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s s₁ s₂ t : Set α
h : NullMeasurableSet s μ
hs : μ s ≠ ⊤
⊢ μ sᶜ = μ univ - μ s
state_after: no goals
tactic: rw [← measure_add_measure_compl₀ h, ENNReal.add_sub_cancel_left hs]
Theorem: CategoryTheory.Limits.colimit.toOver_pt
File: Mathlib/CategoryTheory/Limits/ConeCategory.lean

Proof steps:
state_before: J : Type u₁
inst✝⁴ : Category.{v₁, u₁} J
K : Type u₂
inst✝³ : Category.{v₂, u₂} K
C : Type u₃
inst✝² : Category.{v₃, u₃} C
D : Type u₄
inst✝¹ : Category.{v₄, u₄} D
F : J ⥤ C
inst✝ : HasColimit F
j : J
⊢ ι F j ≫ (((const J).obj (Over.mk (𝟙 (colimit F)))).obj j).hom =
    ((toCostructuredArrow F ⋙ CostructuredArrow.toOver F (colimit F)).obj j).hom
state_after: no goals
tactic: simp
Theorem: cmp_self_eq_eq
File: Mathlib/Order/Compare.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
x y : α
⊢ cmp x x = eq
state_after: no goals
tactic: rw [cmp_eq_eq_iff]
Theorem: ENat.add_one_le_iff
File: Mathlib/Data/ENat/Basic.lean

Proof steps:
state_before: m n : ℕ∞
hm : m ≠ ⊤
⊢ ¬IsMax m
state_after: no goals
tactic: rwa [isMax_iff_eq_top]
Theorem: CategoryTheory.Presieve.FamilyOfElements.Compatible.functorPullback
File: Mathlib/CategoryTheory/Sites/IsSheafFor.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : D ⥤ C
Z : D
T : Presieve (F.obj Z)
x : FamilyOfElements P T
h : x.Compatible
⊢ (FamilyOfElements.functorPullback F x).Compatible
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : D ⥤ C
Z : D
T : Presieve (F.obj Z)
x : FamilyOfElements P T
h : x.Compatible
Z₁ Z₂ W : D
g₁ : W ⟶ Z₁
g₂ : W ⟶ Z₂
f₁ : Z₁ ⟶ Z
f₂ : Z₂ ⟶ Z
h₁ : Presieve.functorPullback F T f₁
h₂ : Presieve.functorPullback F T f₂
eq : g₁ ≫ f₁ = g₂ ≫ f₂
⊢ (F.op ⋙ P).map g₁.op (FamilyOfElements.functorPullback F x f₁ h₁) =
    (F.op ⋙ P).map g₂.op (FamilyOfElements.functorPullback F x f₂ h₂)
tactic: intro Z₁ Z₂ W g₁ g₂ f₁ f₂ h₁ h₂ eq
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : D ⥤ C
Z : D
T : Presieve (F.obj Z)
x : FamilyOfElements P T
h : x.Compatible
Z₁ Z₂ W : D
g₁ : W ⟶ Z₁
g₂ : W ⟶ Z₂
f₁ : Z₁ ⟶ Z
f₂ : Z₂ ⟶ Z
h₁ : Presieve.functorPullback F T f₁
h₂ : Presieve.functorPullback F T f₂
eq : g₁ ≫ f₁ = g₂ ≫ f₂
⊢ (F.op ⋙ P).map g₁.op (FamilyOfElements.functorPullback F x f₁ h₁) =
    (F.op ⋙ P).map g₂.op (FamilyOfElements.functorPullback F x f₂ h₂)
state_after: no goals
tactic: exact h (F.map g₁) (F.map g₂) h₁ h₂ (by simp only [← F.map_comp, eq])