ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: AlgebraicGeometry.Spec.map_eqToHom
File: Mathlib/AlgebraicGeometry/Scheme.lean

Proof steps:
state_before: R S : CommRingCat
e : R = S
⊢ map (eqToHom e) = eqToHom ⋯
state_after: R : CommRingCat
⊢ map (eqToHom ⋯) = eqToHom ⋯
tactic: subst e
state_before: R : CommRingCat
⊢ map (eqToHom ⋯) = eqToHom ⋯
state_after: no goals
tactic: exact Spec.map_id _
Theorem: GenContFract.convs'_succ
File: Mathlib/Algebra/ContinuedFractions/Computation/Translations.lean

Proof steps:
state_before: K : Type u_1
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
v : K
n : ℕ
⊢ (of v).convs' (n + 1) = ↑⌊v⌋ + 1 / (of (fract v)⁻¹).convs' n
state_after: case inl
K : Type u_1
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
v : K
n : ℕ
h : fract v = 0
⊢ (of v).convs' (n + 1) = ↑⌊v⌋ + 1 / (of (fract v)⁻¹).convs' n

case inr
K : Type u_1
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
v : K
n : ℕ
h : fract v ≠ 0
⊢ (of v).convs' (n + 1) = ↑⌊v⌋ + 1 / (of (fract v)⁻¹).convs' n
tactic: rcases eq_or_ne (fract v) 0 with h | h
Theorem: Set.mulIndicator_union_of_not_mem_inter
File: Mathlib/Algebra/Group/Indicator.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
M : Type u_4
N : Type u_5
inst✝ : MulOneClass M
s t : Set α
f✝ g : α → M
a : α
h : a ∉ s ∩ t
f : α → M
⊢ (s ∪ t).mulIndicator f a = s.mulIndicator f a * t.mulIndicator f a
state_after: no goals
tactic: rw [← mulIndicator_union_mul_inter_apply f s t, mulIndicator_of_not_mem h, mul_one]
Theorem: CochainComplex.HomComplex.Cochain.δ_rightUnshift
File: Mathlib/Algebra/Homology/HomotopyCategory/HomComplexShift.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
K L M : CochainComplex C ℤ
n✝ : ℤ
γ✝ γ₁ γ₂ : Cochain K L n✝
a n' : ℤ
γ : Cochain K ((CategoryTheory.shiftFunctor (CochainComplex C ℤ) a).obj L) n'
n : ℤ
hn : n' + a = n
m m' : ℤ
hm' : m' + a = m
⊢ δ n m (γ.rightUnshift n hn) = a.negOnePow • (δ n' m' γ).rightUnshift m hm'
state_after: case intro
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
K L M : CochainComplex C ℤ
n✝ : ℤ
γ γ₁ γ₂ : Cochain K L n✝
a n' n : ℤ
hn : n' + a = n
m m' : ℤ
hm' : m' + a = m
γ' : Cochain K L n
⊢ δ n m (((rightShiftAddEquiv K L n a n' hn) γ').rightUnshift n hn) =
    a.negOnePow • (δ n' m' ((rightShiftAddEquiv K L n a n' hn) γ')).rightUnshift m hm'
tactic: obtain ⟨γ', rfl⟩ := (rightShiftAddEquiv K L n a n' hn).surjective γ
state_before: case intro
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
K L M : CochainComplex C ℤ
n✝ : ℤ
γ γ₁ γ₂ : Cochain K L n✝
a n' n : ℤ
hn : n' + a = n
m m' : ℤ
hm' : m' + a = m
γ' : Cochain K L n
⊢ δ n m (((rightShiftAddEquiv K L n a n' hn) γ').rightUnshift n hn) =
    a.negOnePow • (δ n' m' ((rightShiftAddEquiv K L n a n' hn) γ')).rightUnshift m hm'
state_after: case intro
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
K L M : CochainComplex C ℤ
n✝ : ℤ
γ γ₁ γ₂ : Cochain K L n✝
a n' n : ℤ
hn : n' + a = n
m m' : ℤ
hm' : m' + a = m
γ' : Cochain K L n
⊢ δ n m ((γ'.rightShift a n' hn).rightUnshift n hn) = a.negOnePow • (δ n' m' (γ'.rightShift a n' hn)).rightUnshift m hm'
tactic: dsimp
state_before: case intro
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
K L M : CochainComplex C ℤ
n✝ : ℤ
γ γ₁ γ₂ : Cochain K L n✝
a n' n : ℤ
hn : n' + a = n
m m' : ℤ
hm' : m' + a = m
γ' : Cochain K L n
⊢ δ n m ((γ'.rightShift a n' hn).rightUnshift n hn) = a.negOnePow • (δ n' m' (γ'.rightShift a n' hn)).rightUnshift m hm'
state_after: no goals
tactic: simp only [rightUnshift_rightShift, γ'.δ_rightShift a n' m' hn m hm', rightUnshift_units_smul,
    smul_smul, Int.units_mul_self, one_smul]
Theorem: WeierstrassCurve.Affine.equation_iff'
File: Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean

Proof steps:
state_before: R : Type u
inst✝ : CommRing R
W : Affine R
x y : R
⊢ W.Equation x y ↔ y ^ 2 + W.a₁ * x * y + W.a₃ * y - (x ^ 3 + W.a₂ * x ^ 2 + W.a₄ * x + W.a₆) = 0
state_after: no goals
tactic: rw [Equation, evalEval_polynomial]
Theorem: Ordinal.one_toPGame_moveLeft
File: Mathlib/SetTheory/Game/Ordinal.lean

Proof steps:
state_before: x : (toPGame 1).LeftMoves
⊢ (toPGame 1).moveLeft x = toPGame 0
state_after: no goals
tactic: simp
Theorem: MonoidHom.precompEquiv_symm_apply
File: Mathlib/Algebra/Category/Grp/ForgetCorepresentable.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : Monoid α
inst✝¹ : Monoid β
e : α ≃* β
γ : Type u_3
inst✝ : Monoid γ
x✝ : β →* γ
⊢ (fun g => g.comp ↑e.symm) ((fun f => f.comp ↑e) x✝) = x✝
state_after: case h
α : Type u_1
β : Type u_2
inst✝² : Monoid α
inst✝¹ : Monoid β
e : α ≃* β
γ : Type u_3
inst✝ : Monoid γ
x✝¹ : β →* γ
x✝ : β
⊢ ((fun g => g.comp ↑e.symm) ((fun f => f.comp ↑e) x✝¹)) x✝ = x✝¹ x✝
tactic: ext
state_before: case h
α : Type u_1
β : Type u_2
inst✝² : Monoid α
inst✝¹ : Monoid β
e : α ≃* β
γ : Type u_3
inst✝ : Monoid γ
x✝¹ : β →* γ
x✝ : β
⊢ ((fun g => g.comp ↑e.symm) ((fun f => f.comp ↑e) x✝¹)) x✝ = x✝¹ x✝
state_after: no goals
tactic: simp
state_before: α : Type u_1
β : Type u_2
inst✝² : Monoid α
inst✝¹ : Monoid β
e : α ≃* β
γ : Type u_3
inst✝ : Monoid γ
x✝ : α →* γ
⊢ (fun f => f.comp ↑e) ((fun g => g.comp ↑e.symm) x✝) = x✝
state_after: case h
α : Type u_1
β : Type u_2
inst✝² : Monoid α
inst✝¹ : Monoid β
e : α ≃* β
γ : Type u_3
inst✝ : Monoid γ
x✝¹ : α →* γ
x✝ : α
⊢ ((fun f => f.comp ↑e) ((fun g => g.comp ↑e.symm) x✝¹)) x✝ = x✝¹ x✝
tactic: ext
state_before: case h
α : Type u_1
β : Type u_2
inst✝² : Monoid α
inst✝¹ : Monoid β
e : α ≃* β
γ : Type u_3
inst✝ : Monoid γ
x✝¹ : α →* γ
x✝ : α
⊢ ((fun f => f.comp ↑e) ((fun g => g.comp ↑e.symm) x✝¹)) x✝ = x✝¹ x✝
state_after: no goals
tactic: simp
Theorem: List.getLast_replicate_succ
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
m : ℕ
a : α
⊢ (replicate (m + 1) a).getLast ⋯ = a
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
m : ℕ
a : α
⊢ (replicate m a ++ [a]).getLast ⋯ = a
tactic: simp only [replicate_succ']
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
m : ℕ
a : α
⊢ (replicate m a ++ [a]).getLast ⋯ = a
state_after: no goals
tactic: exact getLast_append_singleton _
Theorem: Submodule.comap_equiv_self_of_inj_of_le_apply
File: Mathlib/Algebra/Module/Submodule/Equiv.lean

Proof steps:
state_before: R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
M : Type u_5
M₁ : Type u_6
M₂ : Type u_7
M₃ : Type u_8
N : Type u_9
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid N
inst✝ : Module R N
f : M →ₗ[R] N
p : Submodule R N
hf : Injective ⇑f
h : p ≤ LinearMap.range f
x y : ↥(comap f p)
hxy :
  (LinearMap.codRestrict p (f ∘ₗ (comap f p).subtype) ⋯) x = (LinearMap.codRestrict p (f ∘ₗ (comap f p).subtype) ⋯) y
⊢ x = y
state_after: no goals
tactic: simpa using hf (Subtype.ext_iff.mp hxy)
state_before: R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
M : Type u_5
M₁ : Type u_6
M₂ : Type u_7
M₃ : Type u_8
N : Type u_9
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid N
inst✝ : Module R N
f : M →ₗ[R] N
p : Submodule R N
hf : Injective ⇑f
h : p ≤ LinearMap.range f
x✝ : ↥p
x : N
hx : x ∈ p
⊢ ∃ a, (LinearMap.codRestrict p (f ∘ₗ (comap f p).subtype) ⋯) a = ⟨x, hx⟩
state_after: case intro
R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
M : Type u_5
M₁ : Type u_6
M₂ : Type u_7
M₃ : Type u_8
N : Type u_9
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid N
inst✝ : Module R N
f : M →ₗ[R] N
p : Submodule R N
hf : Injective ⇑f
h : p ≤ LinearMap.range f
x✝ : ↥p
y : M
hx : f y ∈ p
⊢ ∃ a, (LinearMap.codRestrict p (f ∘ₗ (comap f p).subtype) ⋯) a = ⟨f y, hx⟩
tactic: obtain ⟨y, rfl⟩ := h hx
state_before: case intro
R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
M : Type u_5
M₁ : Type u_6
M₂ : Type u_7
M₃ : Type u_8
N : Type u_9
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid N
inst✝ : Module R N
f : M →ₗ[R] N
p : Submodule R N
hf : Injective ⇑f
h : p ≤ LinearMap.range f
x✝ : ↥p
y : M
hx : f y ∈ p
⊢ ∃ a, (LinearMap.codRestrict p (f ∘ₗ (comap f p).subtype) ⋯) a = ⟨f y, hx⟩
state_after: no goals
tactic: exact ⟨⟨y, hx⟩, by simp [Subtype.ext_iff]⟩
Theorem: ENNReal.toReal_sInf
File: Mathlib/Data/ENNReal/Real.lean

Proof steps:
state_before: ι : Sort u_1
f g : ι → ℝ≥0∞
a b c d : ℝ≥0∞
r p q : ℝ≥0
s : Set ℝ≥0∞
hf : ∀ r ∈ s, r ≠ ⊤
⊢ (sInf s).toReal = sInf (ENNReal.toReal '' s)
state_after: no goals
tactic: simp only [ENNReal.toReal, toNNReal_sInf s hf, NNReal.coe_sInf, Set.image_image]
Theorem: Quiver.Path.cast_eq_cast
File: Mathlib/Combinatorics/Quiver/Cast.lean

Proof steps:
state_before: U : Type u_1
inst✝ : Quiver U
u v u' v' : U
hu : u = u'
hv : v = v'
p : Path u v
⊢ Path u v = Path u' v'
state_after: no goals
tactic: rw [hu, hv]
state_before: U : Type u_1
inst✝ : Quiver U
u v u' v' : U
hu : u = u'
hv : v = v'
p : Path u v
⊢ cast hu hv p = _root_.cast ⋯ p
state_after: U : Type u_1
inst✝ : Quiver U
u' v' : U
p : Path u' v'
⊢ cast ⋯ ⋯ p = _root_.cast ⋯ p
tactic: subst_vars
state_before: U : Type u_1
inst✝ : Quiver U
u' v' : U
p : Path u' v'
⊢ cast ⋯ ⋯ p = _root_.cast ⋯ p
state_after: no goals
tactic: rfl
Theorem: Nat.Primrec.casesOn1
File: Mathlib/Computability/Primrec.lean

Proof steps:
state_before: f : ℕ → ℕ
m : ℕ
hf : Nat.Primrec f
⊢ ∀ (n : ℕ), Nat.rec m (fun y IH => f (unpair (Nat.pair y IH)).1) n = Nat.casesOn n m f
state_after: no goals
tactic: simp
Theorem: Sum.getLeft?_swap
File: .lake/packages/batteries/Batteries/Data/Sum/Lemmas.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
x : α ⊕ β
⊢ x.swap.getLeft? = x.getRight?
state_after: no goals
tactic: cases x <;> rfl
Theorem: OrderHom.lfp_lfp
File: Mathlib/Order/FixedPoints.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
inst✝¹ : CompleteLattice α
inst✝ : CompleteLattice β
f : β →o α
g : α →o β
h : α →o α →o α
⊢ lfp (lfp.comp h) = lfp h.onDiag
state_after: α : Type u
β : Type v
γ : Type w
inst✝¹ : CompleteLattice α
inst✝ : CompleteLattice β
f : β →o α
g : α →o β
h : α →o α →o α
a : α := lfp (lfp.comp h)
⊢ lfp (lfp.comp h) = lfp h.onDiag
tactic: let a := lfp (lfp.comp h)
state_before: α : Type u
β : Type v
γ : Type w
inst✝¹ : CompleteLattice α
inst✝ : CompleteLattice β
f : β →o α
g : α →o β
h : α →o α →o α
a : α := lfp (lfp.comp h)
⊢ lfp (lfp.comp h) = lfp h.onDiag
state_after: case refine_1
α : Type u
β : Type v
γ : Type w
inst✝¹ : CompleteLattice α
inst✝ : CompleteLattice β
f : β →o α
g : α →o β
h : α →o α →o α
a : α := lfp (lfp.comp h)
⊢ (lfp.comp h) (lfp h.onDiag) ≤ lfp h.onDiag

case refine_2
α : Type u
β : Type v
γ : Type w
inst✝¹ : CompleteLattice α
inst✝ : CompleteLattice β
f : β →o α
g : α →o β
h : α →o α →o α
a : α := lfp (lfp.comp h)
⊢ h.onDiag (lfp (lfp.comp h)) = lfp (lfp.comp h)
tactic: refine (lfp_le _ ?_).antisymm (lfp_le _ (Eq.le ?_))
state_before: case refine_2
α : Type u
β : Type v
γ : Type w
inst✝¹ : CompleteLattice α
inst✝ : CompleteLattice β
f : β →o α
g : α →o β
h : α →o α →o α
a : α := lfp (lfp.comp h)
⊢ h.onDiag (lfp (lfp.comp h)) = lfp (lfp.comp h)
state_after: case refine_2
α : Type u
β : Type v
γ : Type w
inst✝¹ : CompleteLattice α
inst✝ : CompleteLattice β
f : β →o α
g : α →o β
h : α →o α →o α
a : α := lfp (lfp.comp h)
ha : (⇑lfp ∘ ⇑h) a = a
⊢ h.onDiag (lfp (lfp.comp h)) = lfp (lfp.comp h)
tactic: have ha : (lfp ∘ h) a = a := (lfp.comp h).map_lfp
state_before: case refine_2
α : Type u
β : Type v
γ : Type w
inst✝¹ : CompleteLattice α
inst✝ : CompleteLattice β
f : β →o α
g : α →o β
h : α →o α →o α
a : α := lfp (lfp.comp h)
ha : (⇑lfp ∘ ⇑h) a = a
⊢ h.onDiag (lfp (lfp.comp h)) = lfp (lfp.comp h)
state_after: no goals
tactic: calc
    h a a = h a (lfp (h a)) := congr_arg (h a) ha.symm
    _ = lfp (h a) := (h a).map_lfp
    _ = a := ha
Theorem: Seminorm.bddAbove_iff
File: Mathlib/Analysis/Seminorm.lean

Proof steps:
state_before: R : Type u_1
R' : Type u_2
𝕜 : Type u_3
𝕜₂ : Type u_4
𝕜₃ : Type u_5
𝕝 : Type u_6
E : Type u_7
E₂ : Type u_8
E₃ : Type u_9
F : Type u_10
G : Type u_11
ι : Type u_12
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
p✝ q : Seminorm 𝕜 E
x✝ : E
s : Set (Seminorm 𝕜 E)
H : BddAbove (DFunLike.coe '' s)
p : Seminorm 𝕜 E
hp : p ∈ s
x : E
⊢ (fun f => ⇑f) p x ≤ (fun f => ⇑f) (sSup s) x
state_after: R : Type u_1
R' : Type u_2
𝕜 : Type u_3
𝕜₂ : Type u_4
𝕜₃ : Type u_5
𝕝 : Type u_6
E : Type u_7
E₂ : Type u_8
E₃ : Type u_9
F : Type u_10
G : Type u_11
ι : Type u_12
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
p✝ q : Seminorm 𝕜 E
x✝ : E
s : Set (Seminorm 𝕜 E)
H : BddAbove (DFunLike.coe '' s)
p : Seminorm 𝕜 E
hp : p ∈ s
x : E
⊢ p x ≤ (sSup s) x
tactic: dsimp
state_before: R : Type u_1
R' : Type u_2
𝕜 : Type u_3
𝕜₂ : Type u_4
𝕜₃ : Type u_5
𝕝 : Type u_6
E : Type u_7
E₂ : Type u_8
E₃ : Type u_9
F : Type u_10
G : Type u_11
ι : Type u_12
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
p✝ q : Seminorm 𝕜 E
x✝ : E
s : Set (Seminorm 𝕜 E)
H : BddAbove (DFunLike.coe '' s)
p : Seminorm 𝕜 E
hp : p ∈ s
x : E
⊢ p x ≤ (sSup s) x
state_after: R : Type u_1
R' : Type u_2
𝕜 : Type u_3
𝕜₂ : Type u_4
𝕜₃ : Type u_5
𝕝 : Type u_6
E : Type u_7
E₂ : Type u_8
E₃ : Type u_9
F : Type u_10
G : Type u_11
ι : Type u_12
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
p✝ q : Seminorm 𝕜 E
x✝ : E
s : Set (Seminorm 𝕜 E)
H : BddAbove (DFunLike.coe '' s)
p : Seminorm 𝕜 E
hp : p ∈ s
x : E
⊢ p x ≤ ⨆ i, ↑i x
tactic: rw [Seminorm.coe_sSup_eq' H, iSup_apply]
state_before: R : Type u_1
R' : Type u_2
𝕜 : Type u_3
𝕜₂ : Type u_4
𝕜₃ : Type u_5
𝕝 : Type u_6
E : Type u_7
E₂ : Type u_8
E₃ : Type u_9
F : Type u_10
G : Type u_11
ι : Type u_12
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
p✝ q : Seminorm 𝕜 E
x✝ : E
s : Set (Seminorm 𝕜 E)
H : BddAbove (DFunLike.coe '' s)
p : Seminorm 𝕜 E
hp : p ∈ s
x : E
⊢ p x ≤ ⨆ i, ↑i x
state_after: case intro
R : Type u_1
R' : Type u_2
𝕜 : Type u_3
𝕜₂ : Type u_4
𝕜₃ : Type u_5
𝕝 : Type u_6
E : Type u_7
E₂ : Type u_8
E₃ : Type u_9
F : Type u_10
G : Type u_11
ι : Type u_12
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
p✝ q✝ : Seminorm 𝕜 E
x✝ : E
s : Set (Seminorm 𝕜 E)
p : Seminorm 𝕜 E
hp : p ∈ s
x : E
q : E → ℝ
hq : q ∈ upperBounds (DFunLike.coe '' s)
⊢ p x ≤ ⨆ i, ↑i x
tactic: rcases H with ⟨q, hq⟩
state_before: case intro
R : Type u_1
R' : Type u_2
𝕜 : Type u_3
𝕜₂ : Type u_4
𝕜₃ : Type u_5
𝕝 : Type u_6
E : Type u_7
E₂ : Type u_8
E₃ : Type u_9
F : Type u_10
G : Type u_11
ι : Type u_12
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
p✝ q✝ : Seminorm 𝕜 E
x✝ : E
s : Set (Seminorm 𝕜 E)
p : Seminorm 𝕜 E
hp : p ∈ s
x : E
q : E → ℝ
hq : q ∈ upperBounds (DFunLike.coe '' s)
⊢ p x ≤ ⨆ i, ↑i x
state_after: no goals
tactic: exact
        le_ciSup ⟨q x, forall_mem_range.mpr fun i : s => hq (mem_image_of_mem _ i.2) x⟩ ⟨p, hp⟩
Theorem: Nat.doubleFactorial_eq_prod_even
File: Mathlib/Data/Nat/Factorial/DoubleFactorial.lean

Proof steps:
state_before: n : ℕ
⊢ (2 * (n + 1))‼ = ∏ i ∈ Finset.range (n + 1), 2 * (i + 1)
state_after: n : ℕ
⊢ (2 * n + 2)‼ = (2 * n + 2) * (2 * n)‼
tactic: rw [Finset.prod_range_succ, ← doubleFactorial_eq_prod_even _, mul_comm (2 * n)‼,
      (by ring : 2 * (n + 1) = 2 * n + 2)]
state_before: n : ℕ
⊢ (2 * n + 2)‼ = (2 * n + 2) * (2 * n)‼
state_after: no goals
tactic: rfl
Theorem: IsometryEquiv.piFinTwo_invFun
File: Mathlib/Topology/MetricSpace/Isometry.lean

Proof steps:
state_before: ι : Type u_1
α✝ : Type u
β : Type v
γ : Type w
inst✝³ : PseudoEMetricSpace α✝
inst✝² : PseudoEMetricSpace β
inst✝¹ : PseudoEMetricSpace γ
α : Fin 2 → Type u_2
inst✝ : (i : Fin 2) → PseudoEMetricSpace (α i)
x hx : (i : Fin 2) → α i
⊢ edist ((piFinTwoEquiv α).toFun x) ((piFinTwoEquiv α).toFun hx) = edist x hx
state_after: no goals
tactic: simp [edist_pi_def, Fin.univ_succ, Prod.edist_eq]
Theorem: Real.IsConjExponent.symm
File: Mathlib/Data/Real/ConjExponents.lean

Proof steps:
state_before: a b p q : ℝ
h✝ h : p.IsConjExponent q
⊢ 1 < q
state_after: no goals
tactic: simpa only [h.conj_eq] using (one_lt_div h.sub_one_pos).mpr (sub_one_lt p)
state_before: a b p q : ℝ
h✝ h : p.IsConjExponent q
⊢ q⁻¹ + p⁻¹ = 1
state_after: no goals
tactic: simpa [add_comm] using h.inv_add_inv_conj
Theorem: IsLowerSet.thickening
File: Mathlib/Analysis/Normed/Order/UpperLower.lean

Proof steps:
state_before: α : Type u_1
ι : Type u_2
inst✝ : NormedOrderedGroup α
s : Set α
hs : IsLowerSet s
ε : ℝ
⊢ IsLowerSet (thickening ε s)
state_after: α : Type u_1
ι : Type u_2
inst✝ : NormedOrderedGroup α
s : Set α
hs : IsLowerSet s
ε : ℝ
⊢ IsLowerSet (ball 1 ε * s)
tactic: rw [← ball_mul_one]
state_before: α : Type u_1
ι : Type u_2
inst✝ : NormedOrderedGroup α
s : Set α
hs : IsLowerSet s
ε : ℝ
⊢ IsLowerSet (ball 1 ε * s)
state_after: no goals
tactic: exact hs.mul_left
Theorem: Finset.biUnion_biUnion
File: Mathlib/Data/Finset/Union.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s✝ s₁ s₂ : Finset α
t t₁ t₂ : α → Finset β
inst✝¹ : DecidableEq β
inst✝ : DecidableEq γ
s : Finset α
f : α → Finset β
g : β → Finset γ
⊢ (s.biUnion f).biUnion g = s.biUnion fun a => (f a).biUnion g
state_after: case a
α : Type u_1
β : Type u_2
γ : Type u_3
s✝ s₁ s₂ : Finset α
t t₁ t₂ : α → Finset β
inst✝¹ : DecidableEq β
inst✝ : DecidableEq γ
s : Finset α
f : α → Finset β
g : β → Finset γ
a✝ : γ
⊢ a✝ ∈ (s.biUnion f).biUnion g ↔ a✝ ∈ s.biUnion fun a => (f a).biUnion g
tactic: ext
state_before: case a
α : Type u_1
β : Type u_2
γ : Type u_3
s✝ s₁ s₂ : Finset α
t t₁ t₂ : α → Finset β
inst✝¹ : DecidableEq β
inst✝ : DecidableEq γ
s : Finset α
f : α → Finset β
g : β → Finset γ
a✝ : γ
⊢ a✝ ∈ (s.biUnion f).biUnion g ↔ a✝ ∈ s.biUnion fun a => (f a).biUnion g
state_after: case a
α : Type u_1
β : Type u_2
γ : Type u_3
s✝ s₁ s₂ : Finset α
t t₁ t₂ : α → Finset β
inst✝¹ : DecidableEq β
inst✝ : DecidableEq γ
s : Finset α
f : α → Finset β
g : β → Finset γ
a✝ : γ
⊢ (∃ a, (∃ a_1 ∈ s, a ∈ f a_1) ∧ a✝ ∈ g a) ↔ ∃ a ∈ s, ∃ a_1 ∈ f a, a✝ ∈ g a_1
tactic: simp only [Finset.mem_biUnion, exists_prop]
state_before: case a
α : Type u_1
β : Type u_2
γ : Type u_3
s✝ s₁ s₂ : Finset α
t t₁ t₂ : α → Finset β
inst✝¹ : DecidableEq β
inst✝ : DecidableEq γ
s : Finset α
f : α → Finset β
g : β → Finset γ
a✝ : γ
⊢ (∃ a, (∃ a_1 ∈ s, a ∈ f a_1) ∧ a✝ ∈ g a) ↔ ∃ a ∈ s, ∃ a_1 ∈ f a, a✝ ∈ g a_1
state_after: case a
α : Type u_1
β : Type u_2
γ : Type u_3
s✝ s₁ s₂ : Finset α
t t₁ t₂ : α → Finset β
inst✝¹ : DecidableEq β
inst✝ : DecidableEq γ
s : Finset α
f : α → Finset β
g : β → Finset γ
a✝ : γ
⊢ (∃ a, ∃ x ∈ s, a ∈ f x ∧ a✝ ∈ g a) ↔ ∃ a x, a ∈ s ∧ x ∈ f a ∧ a✝ ∈ g x
tactic: simp_rw [← exists_and_right, ← exists_and_left, and_assoc]
state_before: case a
α : Type u_1
β : Type u_2
γ : Type u_3
s✝ s₁ s₂ : Finset α
t t₁ t₂ : α → Finset β
inst✝¹ : DecidableEq β
inst✝ : DecidableEq γ
s : Finset α
f : α → Finset β
g : β → Finset γ
a✝ : γ
⊢ (∃ a, ∃ x ∈ s, a ∈ f x ∧ a✝ ∈ g a) ↔ ∃ a x, a ∈ s ∧ x ∈ f a ∧ a✝ ∈ g x
state_after: no goals
tactic: rw [exists_comm]
Theorem: CategoryTheory.Adjunction.full_R_of_isSplitMono_counit_app
File: Mathlib/CategoryTheory/Adjunction/FullyFaithful.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
L : C ⥤ D
R : D ⥤ C
h : L ⊣ R
inst✝ : ∀ (X : D), IsSplitMono (h.counit.app X)
X Y : D
f : R.obj X ⟶ R.obj Y
⊢ ∃ a, R.map a = f
state_after: case h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
L : C ⥤ D
R : D ⥤ C
h : L ⊣ R
inst✝ : ∀ (X : D), IsSplitMono (h.counit.app X)
X Y : D
f : R.obj X ⟶ R.obj Y
⊢ R.map (retraction (h.counit.app X) ≫ (h.homEquiv (R.obj X) Y).symm f) = f
tactic: use (retraction (h.counit.app X) ≫ (h.homEquiv (R.obj X) Y).symm f)
state_before: case h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
L : C ⥤ D
R : D ⥤ C
h : L ⊣ R
inst✝ : ∀ (X : D), IsSplitMono (h.counit.app X)
X Y : D
f : R.obj X ⟶ R.obj Y
⊢ R.map (retraction (h.counit.app X) ≫ (h.homEquiv (R.obj X) Y).symm f) = f
state_after: case h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
L : C ⥤ D
R : D ⥤ C
h : L ⊣ R
inst✝ : ∀ (X : D), IsSplitMono (h.counit.app X)
X Y : D
f : R.obj X ⟶ R.obj Y
⊢ R.map (retraction (h.counit.app X)) = h.unit.app (R.obj X)
tactic: suffices R.map (retraction (h.counit.app X)) = h.unit.app (R.obj X) by simp [this]
state_before: case h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
L : C ⥤ D
R : D ⥤ C
h : L ⊣ R
inst✝ : ∀ (X : D), IsSplitMono (h.counit.app X)
X Y : D
f : R.obj X ⟶ R.obj Y
⊢ R.map (retraction (h.counit.app X)) = h.unit.app (R.obj X)
state_after: case h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
L : C ⥤ D
R : D ⥤ C
h : L ⊣ R
inst✝ : ∀ (X : D), IsSplitMono (h.counit.app X)
X Y : D
f : R.obj X ⟶ R.obj Y
⊢ 𝟙 (R.obj ((𝟭 D).obj X)) ≫ R.map (retraction (h.counit.app X)) = h.unit.app (R.obj X)
tactic: rw [← id_comp (R.map (retraction (h.counit.app X)))]
state_before: case h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
L : C ⥤ D
R : D ⥤ C
h : L ⊣ R
inst✝ : ∀ (X : D), IsSplitMono (h.counit.app X)
X Y : D
f : R.obj X ⟶ R.obj Y
⊢ 𝟙 (R.obj ((𝟭 D).obj X)) ≫ R.map (retraction (h.counit.app X)) = h.unit.app (R.obj X)
state_after: no goals
tactic: simp only [Functor.id_obj, Functor.comp_obj, id_comp, ← h.right_triangle_components X,
      assoc, ← Functor.map_comp, IsSplitMono.id, Functor.map_id, comp_id]
Theorem: suffixLevenshtein_nil_nil
File: Mathlib/Data/List/EditDistance/Defs.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
δ : Type u_3
inst✝¹ : AddZeroClass δ
inst✝ : Min δ
C : Cost α β δ
⊢ (suffixLevenshtein C [] []).val = [0]
state_after: no goals
tactic: rfl
Theorem: Filter.pi_inf_principal_pi_eq_bot
File: Mathlib/Order/Filter/Pi.lean

Proof steps:
state_before: ι : Type u_1
α : ι → Type u_2
f f₁ f₂ : (i : ι) → Filter (α i)
s : (i : ι) → Set (α i)
p : (i : ι) → α i → Prop
inst✝ : ∀ (i : ι), (f i).NeBot
I : Set ι
⊢ pi f ⊓ 𝓟 (I.pi s) = ⊥ ↔ ∃ i ∈ I, f i ⊓ 𝓟 (s i) = ⊥
state_after: ι : Type u_1
α : ι → Type u_2
f f₁ f₂ : (i : ι) → Filter (α i)
s : (i : ι) → Set (α i)
p : (i : ι) → α i → Prop
inst✝ : ∀ (i : ι), (f i).NeBot
I : Set ι
⊢ (∃ i, f i ⊓ 𝓟 (I.piecewise s (fun x => univ) i) = ⊥) ↔ ∃ i ∈ I, f i ⊓ 𝓟 (s i) = ⊥
tactic: rw [← univ_pi_piecewise_univ I, pi_inf_principal_univ_pi_eq_bot]
state_before: ι : Type u_1
α : ι → Type u_2
f f₁ f₂ : (i : ι) → Filter (α i)
s : (i : ι) → Set (α i)
p : (i : ι) → α i → Prop
inst✝ : ∀ (i : ι), (f i).NeBot
I : Set ι
⊢ (∃ i, f i ⊓ 𝓟 (I.piecewise s (fun x => univ) i) = ⊥) ↔ ∃ i ∈ I, f i ⊓ 𝓟 (s i) = ⊥
state_after: ι : Type u_1
α : ι → Type u_2
f f₁ f₂ : (i : ι) → Filter (α i)
s : (i : ι) → Set (α i)
p : (i : ι) → α i → Prop
inst✝ : ∀ (i : ι), (f i).NeBot
I : Set ι
i : ι
⊢ f i ⊓ 𝓟 (I.piecewise s (fun x => univ) i) = ⊥ ↔ i ∈ I ∧ f i ⊓ 𝓟 (s i) = ⊥
tactic: refine exists_congr fun i => ?_
state_before: ι : Type u_1
α : ι → Type u_2
f f₁ f₂ : (i : ι) → Filter (α i)
s : (i : ι) → Set (α i)
p : (i : ι) → α i → Prop
inst✝ : ∀ (i : ι), (f i).NeBot
I : Set ι
i : ι
⊢ f i ⊓ 𝓟 (I.piecewise s (fun x => univ) i) = ⊥ ↔ i ∈ I ∧ f i ⊓ 𝓟 (s i) = ⊥
state_after: no goals
tactic: by_cases hi : i ∈ I <;> simp [hi, NeBot.ne']
Theorem: Nat.image_cast_int_Iic
File: Mathlib/Data/Nat/Cast/SetInterval.lean

Proof steps:
state_before: a : ℕ
⊢ Nat.cast '' Iic a = Icc 0 ↑a
state_after: a : ℕ
⊢ Icc ↑⊥ ↑a = Icc 0 ↑a
tactic: rw [← Icc_bot, image_cast_int_Icc]
state_before: a : ℕ
⊢ Icc ↑⊥ ↑a = Icc 0 ↑a
state_after: no goals
tactic: rfl