ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Submodule.comap_neg
File: Mathlib/Algebra/Module/Submodule/Map.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
inst✝⁴ : Ring R
inst✝³ : AddCommGroup M
inst✝² : Module R M
p✝ : Submodule R M
inst✝¹ : AddCommGroup M₂
inst✝ : Module R M₂
f : M →ₗ[R] M₂
p : Submodule R M₂
⊢ comap (-f) p = comap f p
state_after: case h
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
inst✝⁴ : Ring R
inst✝³ : AddCommGroup M
inst✝² : Module R M
p✝ : Submodule R M
inst✝¹ : AddCommGroup M₂
inst✝ : Module R M₂
f : M →ₗ[R] M₂
p : Submodule R M₂
x✝ : M
⊢ x✝ ∈ comap (-f) p ↔ x✝ ∈ comap f p
tactic: ext
state_before: case h
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
inst✝⁴ : Ring R
inst✝³ : AddCommGroup M
inst✝² : Module R M
p✝ : Submodule R M
inst✝¹ : AddCommGroup M₂
inst✝ : Module R M₂
f : M →ₗ[R] M₂
p : Submodule R M₂
x✝ : M
⊢ x✝ ∈ comap (-f) p ↔ x✝ ∈ comap f p
state_after: no goals
tactic: simp
Theorem: Set.image2_inter_left
File: Mathlib/Data/Set/NAry.lean

Proof steps:
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
ζ : Type u_11
ζ' : Type u_12
ν : Type u_13
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
hf : Injective2 f
⊢ image2 f (s ∩ s') t = image2 f s t ∩ image2 f s' t
state_after: no goals
tactic: simp_rw [← image_uncurry_prod, inter_prod, image_inter hf.uncurry]
Theorem: Option.map_uncurry
File: Mathlib/Data/Option/NAry.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
f✝ : α → β → γ
a : Option α
b : Option β
c : Option γ
f : α → β → γ
x : Option (α × β)
⊢ Option.map (uncurry f) x = map₂ f (Option.map Prod.fst x) (Option.map Prod.snd x)
state_after: no goals
tactic: cases x <;> rfl
Theorem: FirstOrder.Language.BoundedFormula.isPrenex_toPrenexImpRight
File: Mathlib/ModelTheory/Complexity.lean

Proof steps:
state_before: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n l : ℕ
φ✝ ψ✝ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v : α → M
xs : Fin l → M
φ ψ : L.BoundedFormula α n
hφ : φ.IsQF
hψ : ψ.IsPrenex
⊢ (φ.toPrenexImpRight ψ).IsPrenex
state_after: case of_isQF
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n l : ℕ
φ✝¹ ψ✝ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v : α → M
xs : Fin l → M
ψ : L.BoundedFormula α n
n✝ : ℕ
φ✝ : L.BoundedFormula α n✝
hψ : φ✝.IsQF
φ : L.BoundedFormula α n✝
hφ : φ.IsQF
⊢ (φ.toPrenexImpRight φ✝).IsPrenex

case all
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n l : ℕ
φ✝¹ ψ✝ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v : α → M
xs : Fin l → M
ψ : L.BoundedFormula α n
n✝ : ℕ
φ✝ : L.BoundedFormula α (n✝ + 1)
h✝ : φ✝.IsPrenex
ih1 : ∀ {φ : L.BoundedFormula α (n✝ + 1)}, φ.IsQF → (φ.toPrenexImpRight φ✝).IsPrenex
φ : L.BoundedFormula α n✝
hφ : φ.IsQF
⊢ (φ.toPrenexImpRight (∀'φ✝)).IsPrenex

case ex
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n l : ℕ
φ✝¹ ψ✝ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v : α → M
xs : Fin l → M
ψ : L.BoundedFormula α n
n✝ : ℕ
φ✝ : L.BoundedFormula α (n✝ + 1)
h✝ : φ✝.IsPrenex
ih2 : ∀ {φ : L.BoundedFormula α (n✝ + 1)}, φ.IsQF → (φ.toPrenexImpRight φ✝).IsPrenex
φ : L.BoundedFormula α n✝
hφ : φ.IsQF
⊢ (φ.toPrenexImpRight (∃'φ✝)).IsPrenex
tactic: induction' hψ with _ _ hψ _ _ _ ih1 _ _ _ ih2
Theorem: AdjoinRoot.Polynomial.quotQuotEquivComm_mk
File: Mathlib/RingTheory/AdjoinRoot.lean

Proof steps:
state_before: R : Type u
S : Type v
K : Type w
inst✝ : CommRing R
I : Ideal R
f p : R[X]
⊢ (quotQuotEquivComm I f)
      ((Ideal.Quotient.mk (span {Polynomial.map (Ideal.Quotient.mk I) f})) (Polynomial.map (Ideal.Quotient.mk I) p)) =
    (Ideal.Quotient.mk (span {(Ideal.Quotient.mk (Ideal.map C I)) f})) ((Ideal.Quotient.mk (Ideal.map C I)) p)
state_after: no goals
tactic: simp only [Polynomial.quotQuotEquivComm, quotientEquiv_mk,
    polynomialQuotientEquivQuotientPolynomial_map_mk]
Theorem: Real.mk_zero
File: Mathlib/Data/Real/Basic.lean

Proof steps:
state_before: x y : ℝ
⊢ mk 0 = 0
state_after: x y : ℝ
⊢ mk 0 = { cauchy := 0 }
tactic: rw [← ofCauchy_zero]
state_before: x y : ℝ
⊢ mk 0 = { cauchy := 0 }
state_after: no goals
tactic: rfl
Theorem: HomologicalComplex.isZero_extend_X
File: Mathlib/Algebra/Homology/Embedding/Extend.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
c : ComplexShape ι
c' : ComplexShape ι'
C : Type u_3
inst✝² : Category.{u_4, u_3} C
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
K : HomologicalComplex C c
e : c.Embedding c'
i' : ι'
hi' : ∀ (i : ι), e.f i ≠ i'
⊢ e.r i' = none
state_after: case inl
ι : Type u_1
ι' : Type u_2
c : ComplexShape ι
c' : ComplexShape ι'
C : Type u_3
inst✝² : Category.{u_4, u_3} C
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
K : HomologicalComplex C c
e : c.Embedding c'
i' : ι'
hi'✝ : ∀ (i : ι), e.f i ≠ i'
hi' : e.r i' = none
⊢ e.r i' = none

case inr.intro
ι : Type u_1
ι' : Type u_2
c : ComplexShape ι
c' : ComplexShape ι'
C : Type u_3
inst✝² : Category.{u_4, u_3} C
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
K : HomologicalComplex C c
e : c.Embedding c'
i' : ι'
hi' : ∀ (i : ι), e.f i ≠ i'
i : ι
hi : e.r i' = some i
⊢ e.r i' = none
tactic: obtain hi'|⟨i, hi⟩ := (e.r i').eq_none_or_eq_some
Theorem: List.countP_bind
File: Mathlib/Algebra/BigOperators/Group/List.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
p : β → Bool
l : List α
f : α → List β
⊢ countP p (l.bind f) = (map (countP p ∘ f) l).sum
state_after: no goals
tactic: rw [List.bind, countP_join, map_map]
Theorem: FDerivMeasurableAux.A_mono
File: Mathlib/Analysis/Calculus/FDeriv/Measurable.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
f : E → F
K : Set (E →L[𝕜] F)
L : E →L[𝕜] F
r ε δ : ℝ
h : ε ≤ δ
⊢ A f L r ε ⊆ A f L r δ
state_after: case intro.intro
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
f : E → F
K : Set (E →L[𝕜] F)
L : E →L[𝕜] F
r ε δ : ℝ
h : ε ≤ δ
x : E
r' : ℝ
r'r : r' ∈ Ioc (r / 2) r
hr' : ∀ y ∈ ball x r', ∀ z ∈ ball x r', ‖f z - f y - L (z - y)‖ < ε * r
⊢ x ∈ A f L r δ
tactic: rintro x ⟨r', r'r, hr'⟩
state_before: case intro.intro
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
f : E → F
K : Set (E →L[𝕜] F)
L : E →L[𝕜] F
r ε δ : ℝ
h : ε ≤ δ
x : E
r' : ℝ
r'r : r' ∈ Ioc (r / 2) r
hr' : ∀ y ∈ ball x r', ∀ z ∈ ball x r', ‖f z - f y - L (z - y)‖ < ε * r
⊢ x ∈ A f L r δ
state_after: case intro.intro
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
f : E → F
K : Set (E →L[𝕜] F)
L : E →L[𝕜] F
r ε δ : ℝ
h : ε ≤ δ
x : E
r' : ℝ
r'r : r' ∈ Ioc (r / 2) r
hr' : ∀ y ∈ ball x r', ∀ z ∈ ball x r', ‖f z - f y - L (z - y)‖ < ε * r
y : E
hy : y ∈ ball x r'
z : E
hz : z ∈ ball x r'
⊢ 0 ≤ r
tactic: refine ⟨r', r'r, fun y hy z hz => (hr' y hy z hz).trans_le (mul_le_mul_of_nonneg_right h ?_)⟩
state_before: case intro.intro
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
f : E → F
K : Set (E →L[𝕜] F)
L : E →L[𝕜] F
r ε δ : ℝ
h : ε ≤ δ
x : E
r' : ℝ
r'r : r' ∈ Ioc (r / 2) r
hr' : ∀ y ∈ ball x r', ∀ z ∈ ball x r', ‖f z - f y - L (z - y)‖ < ε * r
y : E
hy : y ∈ ball x r'
z : E
hz : z ∈ ball x r'
⊢ 0 ≤ r
state_after: no goals
tactic: linarith [mem_ball.1 hy, r'r.2, @dist_nonneg _ _ y x]
Theorem: Fin.castSucc_pred_add_one_eq
File: Mathlib/Data/Fin/Basic.lean

Proof steps:
state_before: n m : ℕ
a : Fin (n + 1)
ha : a ≠ 0
⊢ (a.pred ha).castSucc + 1 = a
state_after: case zero
n m : ℕ
ha : 0 ≠ 0
⊢ (pred 0 ha).castSucc + 1 = 0

case succ
n m : ℕ
a : Fin n
ha : a.succ ≠ 0
⊢ (a.succ.pred ha).castSucc + 1 = a.succ
tactic: cases' a using cases with a
Theorem: LinearPMap.sSup_apply
File: Mathlib/LinearAlgebra/LinearPMap.lean

Proof steps:
state_before: R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
c : Set (E →ₗ.[R] F)
hc : DirectedOn (fun x x_1 => x ≤ x_1) c
l : E →ₗ.[R] F
hl : l ∈ c
x : ↥l.domain
⊢ ↑(LinearPMap.sSup c hc) ⟨↑x, ⋯⟩ = ↑l x
state_after: R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
c : Set (E →ₗ.[R] F)
hc : DirectedOn (fun x x_1 => x ≤ x_1) c
l : E →ₗ.[R] F
hl : l ∈ c
x : ↥l.domain
⊢ ↑l x = ↑(LinearPMap.sSup c hc) ⟨↑x, ⋯⟩
tactic: symm
state_before: R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
c : Set (E →ₗ.[R] F)
hc : DirectedOn (fun x x_1 => x ≤ x_1) c
l : E →ₗ.[R] F
hl : l ∈ c
x : ↥l.domain
⊢ ↑l x = ↑(LinearPMap.sSup c hc) ⟨↑x, ⋯⟩
state_after: case _h
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
c : Set (E →ₗ.[R] F)
hc : DirectedOn (fun x x_1 => x ≤ x_1) c
l : E →ₗ.[R] F
hl : l ∈ c
x : ↥l.domain
⊢ ↑x = ↑⟨↑x, ⋯⟩
tactic: apply (Classical.choose_spec (sSup_aux c hc) hl).2
state_before: case _h
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
c : Set (E →ₗ.[R] F)
hc : DirectedOn (fun x x_1 => x ≤ x_1) c
l : E →ₗ.[R] F
hl : l ∈ c
x : ↥l.domain
⊢ ↑x = ↑⟨↑x, ⋯⟩
state_after: no goals
tactic: rfl
Theorem: IsCompact.isClosed
File: Mathlib/Topology/Separation.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
inst✝⁴ : TopologicalSpace X
inst✝³ : FirstCountableTopology X
Z : Type u_3
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : T2Space X
s : Set X
hs : IsCompact s
x : X
hx : x ∈ sᶜ
u v : Set X
left✝ : IsOpen u
vo : IsOpen v
su : s ⊆ u
xv : {x} ⊆ v
uv : Disjoint u v
⊢ x ∈ v
state_after: no goals
tactic: simpa using xv
Theorem: LieModule.mem_ker
File: Mathlib/Algebra/Lie/Abelian.lean

Proof steps:
state_before: R : Type u
L : Type v
M : Type w
N : Type w₁
inst✝¹⁰ : CommRing R
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 N
inst✝² : Module R N
inst✝¹ : LieRingModule L N
inst✝ : LieModule R L N
x : L
⊢ x ∈ LieModule.ker R L M ↔ ∀ (m : M), ⁅x, m⁆ = 0
state_after: no goals
tactic: simp only [LieModule.ker, LieHom.mem_ker, LinearMap.ext_iff, LinearMap.zero_apply,
    toEnd_apply_apply]
Theorem: MvPolynomial.X_mem_supported
File: Mathlib/Algebra/MvPolynomial/Supported.lean

Proof steps:
state_before: σ : Type u_1
τ : Type u_2
R : Type u
S : Type v
r : R
e : ℕ
n m : σ
inst✝¹ : CommSemiring R
p q : MvPolynomial σ R
s t : Set σ
inst✝ : Nontrivial R
i : σ
⊢ X i ∈ supported R s ↔ i ∈ s
state_after: no goals
tactic: simp [mem_supported]
Theorem: derangements.Equiv.RemoveNone.fiber_some
File: Mathlib/Combinatorics/Derangements/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
a : α
⊢ fiber (some a) = {f | fixedPoints ⇑f ⊆ {a}}
state_after: case h
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
a : α
f : Perm α
⊢ f ∈ fiber (some a) ↔ f ∈ {f | fixedPoints ⇑f ⊆ {a}}
tactic: ext f
state_before: case h
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
a : α
f : Perm α
⊢ f ∈ fiber (some a) ↔ f ∈ {f | fixedPoints ⇑f ⊆ {a}}
state_after: case h.mp
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
a : α
f : Perm α
⊢ f ∈ fiber (some a) → f ∈ {f | fixedPoints ⇑f ⊆ {a}}

case h.mpr
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
a : α
f : Perm α
⊢ f ∈ {f | fixedPoints ⇑f ⊆ {a}} → f ∈ fiber (some a)
tactic: constructor
Theorem: tendsto_pow_div_pow_atTop_zero
File: Mathlib/Analysis/Asymptotics/SpecificAsymptotics.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
p q : ℕ
hpq : p < q
⊢ Tendsto (fun x => x ^ p / x ^ q) atTop (𝓝 0)
state_after: 𝕜 : Type u_1
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
p q : ℕ
hpq : p < q
⊢ Tendsto (fun x => x ^ (↑p - ↑q)) atTop (𝓝 0)
tactic: rw [tendsto_congr' pow_div_pow_eventuallyEq_atTop]
state_before: 𝕜 : Type u_1
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
p q : ℕ
hpq : p < q
⊢ Tendsto (fun x => x ^ (↑p - ↑q)) atTop (𝓝 0)
state_after: case hn
𝕜 : Type u_1
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
p q : ℕ
hpq : p < q
⊢ ↑p - ↑q < 0
tactic: apply tendsto_zpow_atTop_zero
state_before: case hn
𝕜 : Type u_1
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
p q : ℕ
hpq : p < q
⊢ ↑p - ↑q < 0
state_after: no goals
tactic: omega
Theorem: SimpleGraph.boxProdAssoc_apply
File: Mathlib/Combinatorics/SimpleGraph/Prod.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
G : SimpleGraph α
H : SimpleGraph β
I : SimpleGraph γ
x y : (α × β) × γ
⊢ (G □ (H □ I)).Adj ((Equiv.prodAssoc α β γ) x) ((Equiv.prodAssoc α β γ) y) ↔ (G □ H □ I).Adj x y
state_after: no goals
tactic: simp only [boxProd_adj, Equiv.prodAssoc_apply, or_and_right, or_assoc, Prod.ext_iff,
      and_assoc, @and_comm (x.fst.fst = _)]
Theorem: Fin.list_succ
File: .lake/packages/batteries/Batteries/Data/Fin/Lemmas.lean

Proof steps:
state_before: n : Nat
⊢ list (n + 1) = 0 :: List.map succ (list n)
state_after: case hl
n : Nat
⊢ (list (n + 1)).length = (0 :: List.map succ (list n)).length

case h
n : Nat
⊢ ∀ (n_1 : Nat) (h₁ : n_1 < (list (n + 1)).length) (h₂ : n_1 < (0 :: List.map succ (list n)).length),
    (list (n + 1)).get ⟨n_1, h₁⟩ = (0 :: List.map succ (list n)).get ⟨n_1, h₂⟩
tactic: apply List.ext_get
state_before: case hl
n : Nat
⊢ (list (n + 1)).length = (0 :: List.map succ (list n)).length

case h
n : Nat
⊢ ∀ (n_1 : Nat) (h₁ : n_1 < (list (n + 1)).length) (h₂ : n_1 < (0 :: List.map succ (list n)).length),
    (list (n + 1)).get ⟨n_1, h₁⟩ = (0 :: List.map succ (list n)).get ⟨n_1, h₂⟩
state_after: case h
n : Nat
⊢ ∀ (n_1 : Nat) (h₁ : n_1 < (list (n + 1)).length) (h₂ : n_1 < (0 :: List.map succ (list n)).length),
    (list (n + 1)).get ⟨n_1, h₁⟩ = (0 :: List.map succ (list n)).get ⟨n_1, h₂⟩
tactic: simp
state_before: case h
n : Nat
⊢ ∀ (n_1 : Nat) (h₁ : n_1 < (list (n + 1)).length) (h₂ : n_1 < (0 :: List.map succ (list n)).length),
    (list (n + 1)).get ⟨n_1, h₁⟩ = (0 :: List.map succ (list n)).get ⟨n_1, h₂⟩
state_after: case h
n i : Nat
⊢ ∀ (h₁ : i < (list (n + 1)).length) (h₂ : i < (0 :: List.map succ (list n)).length),
    (list (n + 1)).get ⟨i, h₁⟩ = (0 :: List.map succ (list n)).get ⟨i, h₂⟩
tactic: intro i
state_before: case h
n i : Nat
⊢ ∀ (h₁ : i < (list (n + 1)).length) (h₂ : i < (0 :: List.map succ (list n)).length),
    (list (n + 1)).get ⟨i, h₁⟩ = (0 :: List.map succ (list n)).get ⟨i, h₂⟩
state_after: no goals
tactic: cases i <;> simp
Theorem: finprod_mem_mulSupport
File: Mathlib/Algebra/BigOperators/Finprod.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f : α → M
a : α
⊢ ∏ᶠ (_ : f a ≠ 1), f a = f a
state_after: no goals
tactic: rw [← mem_mulSupport, finprod_eq_mulIndicator_apply, mulIndicator_mulSupport]
Theorem: MvPolynomial.totalDegree_sub_C_le
File: Mathlib/Algebra/MvPolynomial/CommRing.lean

Proof steps:
state_before: R : Type u
S : Type v
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝ : CommRing R
p✝ q p : MvPolynomial σ R
r : R
⊢ max p.totalDegree (C r).totalDegree = p.totalDegree
state_after: no goals
tactic: rw [totalDegree_C, Nat.max_zero]
Theorem: CategoryTheory.Localization.homEquiv_eq
File: Mathlib/CategoryTheory/Localization/HomEquiv.lean

Proof steps:
state_before: C : Type u_1
C₁ : Type u_2
C₂ : Type u_3
C₃ : Type u_4
D₁ : Type u_5
D₂ : Type u_6
D₃ : Type u_7
inst✝⁹ : Category.{u_10, u_1} C
inst✝⁸ : Category.{?u.40310, u_2} C₁
inst✝⁷ : Category.{?u.40314, u_3} C₂
inst✝⁶ : Category.{?u.40318, u_4} C₃
inst✝⁵ : Category.{u_8, u_5} D₁
inst✝⁴ : Category.{u_9, u_6} D₂
inst✝³ : Category.{?u.40330, u_7} D₃
W : MorphismProperty C
L₁ : C ⥤ D₁
inst✝² : L₁.IsLocalization W
L₂ : C ⥤ D₂
inst✝¹ : L₂.IsLocalization W
L₃ : C ⥤ D₃
inst✝ : L₃.IsLocalization W
X Y Z : C
G : D₁ ⥤ D₂
e : L₁ ⋙ G ≅ L₂
f : L₁.obj X ⟶ L₁.obj Y
⊢ (homEquiv W L₁ L₂) f = e.inv.app X ≫ G.map f ≫ e.hom.app Y
state_after: no goals
tactic: rw [homEquiv_apply, LocalizerMorphism.homMap_apply (LocalizerMorphism.id W) L₁ L₂ G e.symm,
    Iso.symm_hom, Iso.symm_inv]
Theorem: FiniteInter.finiteInterClosure_insert
File: Mathlib/Data/Set/Constructions.lean

Proof steps:
state_before: α : Type u_1
S : Set (Set α)
A : Set α
cond : FiniteInter S
P : Set α
H : P ∈ finiteInterClosure (insert A S)
⊢ P ∈ S ∨ ∃ Q ∈ S, P = A ∩ Q
state_after: case basic
α : Type u_1
S✝ : Set (Set α)
A : Set α
cond : FiniteInter S✝
P S : Set α
h : S ∈ insert A S✝
⊢ S ∈ S✝ ∨ ∃ Q ∈ S✝, S = A ∩ Q

case univ
α : Type u_1
S : Set (Set α)
A : Set α
cond : FiniteInter S
P : Set α
⊢ Set.univ ∈ S ∨ ∃ Q ∈ S, Set.univ = A ∩ Q

case inter
α : Type u_1
S : Set (Set α)
A : Set α
cond : FiniteInter S
P T1 T2 : Set α
a✝¹ : finiteInterClosure (insert A S) T1
a✝ : finiteInterClosure (insert A S) T2
h1 : T1 ∈ S ∨ ∃ Q ∈ S, T1 = A ∩ Q
h2 : T2 ∈ S ∨ ∃ Q ∈ S, T2 = A ∩ Q
⊢ T1 ∩ T2 ∈ S ∨ ∃ Q ∈ S, T1 ∩ T2 = A ∩ Q
tactic: induction' H with S h T1 T2 _ _ h1 h2
Theorem: CategoryTheory.Limits.IsColimit.coconePointsIsoOfNatIso_inv
File: Mathlib/CategoryTheory/Limits/IsLimit.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
F✝ : J ⥤ C
t✝ : Cocone F✝
F G : J ⥤ C
s : Cocone F
t : Cocone G
P : IsColimit s
Q : IsColimit t
w : F ≅ G
⊢ ∀ (j : J), s.ι.app j ≫ P.map t w.hom ≫ Q.map s w.inv = s.ι.app j ≫ 𝟙 s.pt
state_after: no goals
tactic: aesop_cat
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
F✝ : J ⥤ C
t✝ : Cocone F✝
F G : J ⥤ C
s : Cocone F
t : Cocone G
P : IsColimit s
Q : IsColimit t
w : F ≅ G
⊢ ∀ (j : J), t.ι.app j ≫ Q.map s w.inv ≫ P.map t w.hom = t.ι.app j ≫ 𝟙 t.pt
state_after: no goals
tactic: aesop_cat
Theorem: ContDiffBump.one_lt_rOut_div_rIn
File: Mathlib/Analysis/Calculus/BumpFunction/Basic.lean

Proof steps:
state_before: E : Type u_1
X : Type u_2
c : E
f : ContDiffBump c
⊢ 1 < f.rOut / f.rIn
state_after: E : Type u_1
X : Type u_2
c : E
f : ContDiffBump c
⊢ f.rIn < f.rOut
tactic: rw [one_lt_div f.rIn_pos]
state_before: E : Type u_1
X : Type u_2
c : E
f : ContDiffBump c
⊢ f.rIn < f.rOut
state_after: no goals
tactic: exact f.rIn_lt_rOut
Theorem: UpperHalfPlane.sinh_half_dist
File: Mathlib/Analysis/Complex/UpperHalfPlane/Metric.lean

Proof steps:
state_before: z✝ w✝ : ℍ
r R : ℝ
z w : ℍ
⊢ sinh (dist z w / 2) = dist ↑z ↑w / (2 * √(z.im * w.im))
state_after: no goals
tactic: rw [dist_eq, mul_div_cancel_left₀ (arsinh _) two_ne_zero, sinh_arsinh]
Theorem: AddOreLocalization.add_cancel'
File: Mathlib/RingTheory/OreLocalization/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝² : Monoid R
S : Submonoid R
inst✝¹ : OreSet S
X : Type ?u.109587
inst✝ : MulAction R X
r₁ r₂ : R
s t : ↥S
⊢ r₁ * ↑s /ₒ t * (r₂ /ₒ s) = r₁ * r₂ /ₒ t
state_after: no goals
tactic: simp [oreDiv_mul_char (r₁ * s) r₂ t s r₁ 1 (by simp)]
Theorem: Matroid.Indep.closure_inter_eq_inter_closure
File: Mathlib/Data/Matroid/Closure.lean

Proof steps:
state_before: ι✝ : Type u_1
α : Type u_2
M : Matroid α
F X Y : Set α
e : α
ι : Sort u_3
I J B : Set α
f x y : α
h : M.Indep (I ∪ J)
⊢ M.closure (I ∩ J) = M.closure I ∩ M.closure J
state_after: ι✝ : Type u_1
α : Type u_2
M : Matroid α
F X Y : Set α
e : α
ι : Sort u_3
I J B : Set α
f x y : α
h : M.Indep (I ∪ J)
⊢ ⋂ i, M.closure (bif i then I else J) = ⋂ b, bif b then M.closure I else M.closure J

case h
ι✝ : Type u_1
α : Type u_2
M : Matroid α
F X Y : Set α
e : α
ι : Sort u_3
I J B : Set α
f x y : α
h : M.Indep (I ∪ J)
⊢ M.Indep (⋃ i, bif i then I else J)
tactic: rw [inter_eq_iInter, closure_iInter_eq_iInter_closure_of_iUnion_indep, inter_eq_iInter]
state_before: case h
ι✝ : Type u_1
α : Type u_2
M : Matroid α
F X Y : Set α
e : α
ι : Sort u_3
I J B : Set α
f x y : α
h : M.Indep (I ∪ J)
⊢ M.Indep (⋃ i, bif i then I else J)
state_after: no goals
tactic: rwa [← union_eq_iUnion]
Theorem: Metric.hausdorffDist_zero_iff_closure_eq_closure
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x y : α
Φ : α → β
fin : hausdorffEdist s t ≠ ⊤
⊢ hausdorffDist s t = 0 ↔ closure s = closure t
state_after: no goals
tactic: simp [← hausdorffEdist_zero_iff_closure_eq_closure, hausdorffDist,
    ENNReal.toReal_eq_zero_iff, fin]
Theorem: hasSum_ite_sub_hasSum
File: Mathlib/Topology/Algebra/InfiniteSum/Group.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : CommGroup α
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalGroup α
f g : β → α
a a₁ a₂ : α
inst✝ : DecidableEq β
hf : HasProd f a
b : β
⊢ HasProd (fun n => if n = b then 1 else f n) (a / f b)
state_after: case h.e'_5
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : CommGroup α
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalGroup α
f g : β → α
a a₁ a₂ : α
inst✝ : DecidableEq β
hf : HasProd f a
b : β
⊢ (fun n => if n = b then 1 else f n) = update f b 1

case h.e'_6
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : CommGroup α
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalGroup α
f g : β → α
a a₁ a₂ : α
inst✝ : DecidableEq β
hf : HasProd f a
b : β
⊢ a / f b = 1 / f b * a
tactic: convert hf.update b 1 using 1