ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: PMF.toMeasure_apply_eq_of_inter_support_eq
File: Mathlib/Probability/ProbabilityMassFunction/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : MeasurableSpace α
p : PMF α
s✝ t✝ s t : Set α
hs : MeasurableSet s
ht : MeasurableSet t
h : s ∩ p.support = t ∩ p.support
⊢ p.toMeasure s = p.toMeasure t
state_after: no goals
tactic: simpa only [p.toMeasure_apply_eq_toOuterMeasure_apply, hs, ht] using
    toOuterMeasure_apply_eq_of_inter_support_eq p h
Theorem: Ordinal.nadd_assoc
File: Mathlib/SetTheory/Ordinal/NaturalOps.lean

Proof steps:
state_before: a✝ b✝ c✝ : Ordinal.{u}
a b c : Ordinal.{u_1}
⊢ a ♯ b ♯ c = a ♯ (b ♯ c)
state_after: a✝ b✝ c✝ : Ordinal.{u}
a b c : Ordinal.{u_1}
⊢ max (a.blsub fun a' ha' => a' ♯ b ♯ c) (max (b.blsub fun b' hb' => a ♯ b' ♯ c) (c.blsub fun b' x => a ♯ b ♯ b')) =
    max (a.blsub fun a' x => a' ♯ (b ♯ c))
      (max (b.blsub fun a' ha' => a ♯ (a' ♯ c)) (c.blsub fun b' hb' => a ♯ (b ♯ b')))

case hf
a✝ b✝ c✝ : Ordinal.{u}
a b c : Ordinal.{u_1}
⊢ ∀ {i j : Ordinal.{u_1}}, i < b ♯ c → j < b ♯ c → i ≤ j → a ♯ i ≤ a ♯ j

case hf
a✝ b✝ c✝ : Ordinal.{u}
a b c : Ordinal.{u_1}
⊢ ∀ {i j : Ordinal.{u_1}}, i < a ♯ b → j < a ♯ b → i ≤ j → i ♯ c ≤ j ♯ c
tactic: rw [nadd_def a (b ♯ c), nadd_def, blsub_nadd_of_mono, blsub_nadd_of_mono, max_assoc]
Theorem: deriv_sub_const
File: Mathlib/Analysis/Calculus/Deriv/Add.lean

Proof steps:
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L : Filter 𝕜
c : F
⊢ deriv (fun y => f y - c) x = deriv f x
state_after: no goals
tactic: simp only [deriv, fderiv_sub_const]
Theorem: isRelPrime_mul_unit_right
File: Mathlib/Algebra/Divisibility/Units.lean

Proof steps:
state_before: α : Type u_1
inst✝ : CommMonoid α
x y z : α
hu : IsUnit x
⊢ IsRelPrime (y * x) (z * x) ↔ IsRelPrime y z
state_after: no goals
tactic: rw [isRelPrime_mul_unit_right_left hu, isRelPrime_mul_unit_right_right hu]
Theorem: LinearMap.toMatrix_mul
File: Mathlib/LinearAlgebra/Matrix/ToLin.lean

Proof steps:
state_before: R : Type u_1
inst✝⁹ : CommSemiring R
l : Type u_2
m : Type u_3
n : Type u_4
inst✝⁸ : Fintype n
inst✝⁷ : Fintype m
inst✝⁶ : DecidableEq n
M₁ : Type u_5
M₂ : Type u_6
inst✝⁵ : AddCommMonoid M₁
inst✝⁴ : AddCommMonoid M₂
inst✝³ : Module R M₁
inst✝² : Module R M₂
v₁ : Basis n R M₁
v₂ : Basis m R M₂
M₃ : Type u_7
inst✝¹ : AddCommMonoid M₃
inst✝ : Module R M₃
v₃ : Basis l R M₃
f g : M₁ →ₗ[R] M₁
⊢ (toMatrix v₁ v₁) (f * g) = (toMatrix v₁ v₁) f * (toMatrix v₁ v₁) g
state_after: no goals
tactic: rw [LinearMap.mul_eq_comp, LinearMap.toMatrix_comp v₁ v₁ v₁ f g]
Theorem: cmpLE_swap
File: Mathlib/Order/Compare.lean

Proof steps:
state_before: α✝ : Type u_1
β : Type u_2
α : Type u_3
inst✝² : LE α
inst✝¹ : IsTotal α fun x x_1 => x ≤ x_1
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
x y : α
⊢ (cmpLE x y).swap = cmpLE y x
state_after: case neg
α✝ : Type u_1
β : Type u_2
α : Type u_3
inst✝² : LE α
inst✝¹ : IsTotal α fun x x_1 => x ≤ x_1
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
x y : α
xy : ¬x ≤ y
yx : ¬y ≤ x
⊢ False
tactic: by_cases xy : x ≤ y <;> by_cases yx : y ≤ x <;> simp [cmpLE, *, Ordering.swap]
state_before: case neg
α✝ : Type u_1
β : Type u_2
α : Type u_3
inst✝² : LE α
inst✝¹ : IsTotal α fun x x_1 => x ≤ x_1
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
x y : α
xy : ¬x ≤ y
yx : ¬y ≤ x
⊢ False
state_after: no goals
tactic: cases not_or_of_not xy yx (total_of _ _ _)
Theorem: Int.ModEq.mul_left'
File: Mathlib/Data/Int/ModEq.lean

Proof steps:
state_before: m n a b c d : ℤ
h : a ≡ b [ZMOD n]
⊢ c * a ≡ c * b [ZMOD c * n]
state_after: case inl
m n a b c d : ℤ
h : a ≡ b [ZMOD n]
hc : c < 0
⊢ c * a ≡ c * b [ZMOD c * n]

case inr.inl
m n a b d : ℤ
h : a ≡ b [ZMOD n]
⊢ 0 * a ≡ 0 * b [ZMOD 0 * n]

case inr.inr
m n a b c d : ℤ
h : a ≡ b [ZMOD n]
hc : 0 < c
⊢ c * a ≡ c * b [ZMOD c * n]
tactic: obtain hc | rfl | hc := lt_trichotomy c 0
Theorem: MeasureTheory.Measure.AbsolutelyContinuous.prod
File: Mathlib/MeasureTheory/Constructions/Prod/Basic.lean

Proof steps:
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
E : Type u_6
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MeasurableSpace α'
inst✝⁵ : MeasurableSpace β
inst✝⁴ : MeasurableSpace β'
inst✝³ : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝² : NormedAddCommGroup E
inst✝¹ : SFinite ν
inst✝ : SFinite ν'
h1 : μ ≪ μ'
h2 : ν ≪ ν'
⊢ μ.prod ν ≪ μ'.prod ν'
state_after: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
E : Type u_6
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MeasurableSpace α'
inst✝⁵ : MeasurableSpace β
inst✝⁴ : MeasurableSpace β'
inst✝³ : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝² : NormedAddCommGroup E
inst✝¹ : SFinite ν
inst✝ : SFinite ν'
h1 : μ ≪ μ'
h2 : ν ≪ ν'
s : Set (α × β)
hs : MeasurableSet s
h2s : (μ'.prod ν') s = 0
⊢ (μ.prod ν) s = 0
tactic: refine AbsolutelyContinuous.mk fun s hs h2s => ?_
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
E : Type u_6
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MeasurableSpace α'
inst✝⁵ : MeasurableSpace β
inst✝⁴ : MeasurableSpace β'
inst✝³ : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝² : NormedAddCommGroup E
inst✝¹ : SFinite ν
inst✝ : SFinite ν'
h1 : μ ≪ μ'
h2 : ν ≪ ν'
s : Set (α × β)
hs : MeasurableSet s
h2s : (μ'.prod ν') s = 0
⊢ (μ.prod ν) s = 0
state_after: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
E : Type u_6
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MeasurableSpace α'
inst✝⁵ : MeasurableSpace β
inst✝⁴ : MeasurableSpace β'
inst✝³ : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝² : NormedAddCommGroup E
inst✝¹ : SFinite ν
inst✝ : SFinite ν'
h1 : μ ≪ μ'
h2 : ν ≪ ν'
s : Set (α × β)
hs : MeasurableSet s
h2s : (fun x => ν' (Prod.mk x ⁻¹' s)) =ᶠ[ae μ'] 0
⊢ (fun x => ν (Prod.mk x ⁻¹' s)) =ᶠ[ae μ] 0
tactic: rw [measure_prod_null hs] at h2s ⊢
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
E : Type u_6
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MeasurableSpace α'
inst✝⁵ : MeasurableSpace β
inst✝⁴ : MeasurableSpace β'
inst✝³ : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝² : NormedAddCommGroup E
inst✝¹ : SFinite ν
inst✝ : SFinite ν'
h1 : μ ≪ μ'
h2 : ν ≪ ν'
s : Set (α × β)
hs : MeasurableSet s
h2s : (fun x => ν' (Prod.mk x ⁻¹' s)) =ᶠ[ae μ'] 0
⊢ (fun x => ν (Prod.mk x ⁻¹' s)) =ᶠ[ae μ] 0
state_after: no goals
tactic: exact (h2s.filter_mono h1.ae_le).mono fun _ h => h2 h
Theorem: MeasureTheory.integrable_average
File: Mathlib/MeasureTheory/Function/L1Space.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝³ : MeasurableSpace δ
inst✝² : NormedAddCommGroup β
inst✝¹ : NormedAddCommGroup γ
inst✝ : IsFiniteMeasure μ
f : α → β
h : μ = 0
⊢ Integrable f ((μ univ)⁻¹ • μ) ↔ Integrable f μ
state_after: no goals
tactic: simp [h]
Theorem: Polynomial.eval₂_comp
File: Mathlib/Algebra/Polynomial/Eval.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝¹ : Semiring R
p q : R[X]
x✝ : R
inst✝ : CommSemiring S
f : R →+* S
x : S
⊢ eval₂ f x (p.comp q) = eval₂ f (eval₂ f x q) p
state_after: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝¹ : Semiring R
p q : R[X]
x✝ : R
inst✝ : CommSemiring S
f : R →+* S
x : S
⊢ eval₂ f x (eval₂ C q (∑ i ∈ range (p.natDegree + 1), (monomial i) (p.coeff i))) =
    eval₂ f (eval₂ f x q) (∑ i ∈ range (p.natDegree + 1), (monomial i) (p.coeff i))
tactic: rw [comp, p.as_sum_range]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝¹ : Semiring R
p q : R[X]
x✝ : R
inst✝ : CommSemiring S
f : R →+* S
x : S
⊢ eval₂ f x (eval₂ C q (∑ i ∈ range (p.natDegree + 1), (monomial i) (p.coeff i))) =
    eval₂ f (eval₂ f x q) (∑ i ∈ range (p.natDegree + 1), (monomial i) (p.coeff i))
state_after: no goals
tactic: simp [eval₂_finset_sum, eval₂_pow]
Theorem: Finset.subset_insert_iff_of_not_mem
File: Mathlib/Data/Finset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s t u v : Finset α
a b : α
h : a ∉ s
⊢ s ⊆ insert a t ↔ s ⊆ t
state_after: no goals
tactic: rw [subset_insert_iff, erase_eq_of_not_mem h]
Theorem: Real.cauSeq_converges
File: Mathlib/Data/Real/Archimedean.lean

Proof steps:
state_before: f : CauSeq ℝ abs
⊢ ∃ x, f ≈ const abs x
state_after: f : CauSeq ℝ abs
S : Set ℝ := {x | const abs x < f}
⊢ ∃ x, f ≈ const abs x
tactic: let S := { x : ℝ | const abs x < f }
state_before: f : CauSeq ℝ abs
S : Set ℝ := {x | const abs x < f}
⊢ ∃ x, f ≈ const abs x
state_after: f : CauSeq ℝ abs
S : Set ℝ := {x | const abs x < f}
lb : ∃ x, x ∈ S
⊢ ∃ x, f ≈ const abs x
tactic: have lb : ∃ x, x ∈ S := exists_lt f
state_before: f : CauSeq ℝ abs
S : Set ℝ := {x | const abs x < f}
lb : ∃ x, x ∈ S
⊢ ∃ x, f ≈ const abs x
state_after: f : CauSeq ℝ abs
S : Set ℝ := {x | const abs x < f}
lb : ∃ x, x ∈ S
ub' : ∀ (x : ℝ), f < const abs x → ∀ y ∈ S, y ≤ x
⊢ ∃ x, f ≈ const abs x
tactic: have ub' : ∀ x, f < const abs x → ∀ y ∈ S, y ≤ x := fun x h y yS =>
    le_of_lt <| const_lt.1 <| CauSeq.lt_trans yS h
state_before: f : CauSeq ℝ abs
S : Set ℝ := {x | const abs x < f}
lb : ∃ x, x ∈ S
ub' : ∀ (x : ℝ), f < const abs x → ∀ y ∈ S, y ≤ x
⊢ ∃ x, f ≈ const abs x
state_after: f : CauSeq ℝ abs
S : Set ℝ := {x | const abs x < f}
lb : ∃ x, x ∈ S
ub' : ∀ (x : ℝ), f < const abs x → ∀ y ∈ S, y ≤ x
ub : ∃ x, ∀ y ∈ S, y ≤ x
⊢ ∃ x, f ≈ const abs x
tactic: have ub : ∃ x, ∀ y ∈ S, y ≤ x := (exists_gt f).imp ub'
state_before: f : CauSeq ℝ abs
S : Set ℝ := {x | const abs x < f}
lb : ∃ x, x ∈ S
ub' : ∀ (x : ℝ), f < const abs x → ∀ y ∈ S, y ≤ x
ub : ∃ x, ∀ y ∈ S, y ≤ x
⊢ ∃ x, f ≈ const abs x
state_after: case refine_1
f : CauSeq ℝ abs
S : Set ℝ := {x | const abs x < f}
lb : ∃ x, x ∈ S
ub' : ∀ (x : ℝ), f < const abs x → ∀ y ∈ S, y ≤ x
ub : ∃ x, ∀ y ∈ S, y ≤ x
h : f < const abs (sSup S)
⊢ False

case refine_2
f : CauSeq ℝ abs
S : Set ℝ := {x | const abs x < f}
lb : ∃ x, x ∈ S
ub' : ∀ (x : ℝ), f < const abs x → ∀ y ∈ S, y ≤ x
ub : ∃ x, ∀ y ∈ S, y ≤ x
h : const abs (sSup S) < f
⊢ False
tactic: refine ⟨sSup S, ((lt_total _ _).resolve_left fun h => ?_).resolve_right fun h => ?_⟩
Theorem: List.nodupKeys_join
File: Mathlib/Data/List/Sigma.lean

Proof steps:
state_before: α : Type u
β : α → Type v
l l₁ l₂ : List (Sigma β)
L : List (List (Sigma β))
⊢ L.join.NodupKeys ↔ (∀ l ∈ L, l.NodupKeys) ∧ Pairwise Disjoint (map keys L)
state_after: α : Type u
β : α → Type v
l l₁ l₂ : List (Sigma β)
L : List (List (Sigma β))
⊢ (∀ l ∈ L, Pairwise (fun s s' => s.fst ≠ s'.fst) l) ∧ Pairwise (fun l₁ l₂ => ∀ x ∈ l₁, ∀ y ∈ l₂, x.fst ≠ y.fst) L ↔
    (∀ l ∈ L, l.NodupKeys) ∧ Pairwise (fun a b => a.keys.Disjoint b.keys) L
tactic: rw [nodupKeys_iff_pairwise, pairwise_join, pairwise_map]
state_before: α : Type u
β : α → Type v
l l₁ l₂ : List (Sigma β)
L : List (List (Sigma β))
⊢ (∀ l ∈ L, Pairwise (fun s s' => s.fst ≠ s'.fst) l) ∧ Pairwise (fun l₁ l₂ => ∀ x ∈ l₁, ∀ y ∈ l₂, x.fst ≠ y.fst) L ↔
    (∀ l ∈ L, l.NodupKeys) ∧ Pairwise (fun a b => a.keys.Disjoint b.keys) L
state_after: α : Type u
β : α → Type v
l l₁ l₂ : List (Sigma β)
L : List (List (Sigma β))
⊢ Pairwise (fun l₁ l₂ => ∀ x ∈ l₁, ∀ y ∈ l₂, x.fst ≠ y.fst) L ↔ Pairwise (fun a b => a.keys.Disjoint b.keys) L
tactic: refine and_congr (forall₂_congr fun l _ => by simp [nodupKeys_iff_pairwise]) ?_
state_before: α : Type u
β : α → Type v
l l₁ l₂ : List (Sigma β)
L : List (List (Sigma β))
⊢ Pairwise (fun l₁ l₂ => ∀ x ∈ l₁, ∀ y ∈ l₂, x.fst ≠ y.fst) L ↔ Pairwise (fun a b => a.keys.Disjoint b.keys) L
state_after: case a
α : Type u
β : α → Type v
l l₁ l₂ : List (Sigma β)
L : List (List (Sigma β))
⊢ Pairwise (fun l₁ l₂ => ∀ x ∈ l₁, ∀ y ∈ l₂, x.fst ≠ y.fst) L = Pairwise (fun a b => a.keys.Disjoint b.keys) L
tactic: apply iff_of_eq
state_before: case a
α : Type u
β : α → Type v
l l₁ l₂ : List (Sigma β)
L : List (List (Sigma β))
⊢ Pairwise (fun l₁ l₂ => ∀ x ∈ l₁, ∀ y ∈ l₂, x.fst ≠ y.fst) L = Pairwise (fun a b => a.keys.Disjoint b.keys) L
state_after: case a.e_R.h.h.a
α : Type u
β : α → Type v
l l₁✝ l₂✝ : List (Sigma β)
L : List (List (Sigma β))
l₁ l₂ : List (Sigma β)
⊢ (∀ x ∈ l₁, ∀ y ∈ l₂, x.fst ≠ y.fst) ↔ l₁.keys.Disjoint l₂.keys
tactic: congr with (l₁ l₂)
state_before: case a.e_R.h.h.a
α : Type u
β : α → Type v
l l₁✝ l₂✝ : List (Sigma β)
L : List (List (Sigma β))
l₁ l₂ : List (Sigma β)
⊢ (∀ x ∈ l₁, ∀ y ∈ l₂, x.fst ≠ y.fst) ↔ l₁.keys.Disjoint l₂.keys
state_after: no goals
tactic: simp [keys, disjoint_iff_ne]
Theorem: List.continuous_insertNth
File: Mathlib/Topology/List.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
n : ℕ
x✝ : α × List α
a : α
l : List α
⊢ ContinuousAt (fun p => insertNth n p.1 p.2) (a, l)
state_after: α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
n : ℕ
x✝ : α × List α
a : α
l : List α
⊢ Tendsto (fun p => insertNth n p.1 p.2) (𝓝 a ×ˢ 𝓝 l) (𝓝 (insertNth n (a, l).1 (a, l).2))
tactic: rw [ContinuousAt, nhds_prod_eq]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
n : ℕ
x✝ : α × List α
a : α
l : List α
⊢ Tendsto (fun p => insertNth n p.1 p.2) (𝓝 a ×ˢ 𝓝 l) (𝓝 (insertNth n (a, l).1 (a, l).2))
state_after: no goals
tactic: exact tendsto_insertNth'
Theorem: Turing.PartrecToTM2.clear_ok
File: Mathlib/Computability/TMToPartrec.lean

Proof steps:
state_before: p : Γ' → Bool
k : K'
q : Λ'
s : Option Γ'
L₁ : List Γ'
o : Option Γ'
L₂ : List Γ'
S : K' → List Γ'
e : splitAtPred p (S k) = (L₁, o, L₂)
⊢ Reaches₁ (TM2.step tr) { l := some (Λ'.clear p k q), var := s, stk := S }
    { l := some q, var := o, stk := update S k L₂ }
state_after: case nil
p : Γ' → Bool
k : K'
q : Λ'
o : Option Γ'
L₂ : List Γ'
s : Option Γ'
S : K' → List Γ'
e : splitAtPred p (S k) = ([], o, L₂)
⊢ Reaches₁ (TM2.step tr) { l := some (Λ'.clear p k q), var := s, stk := S }
    { l := some q, var := o, stk := update S k L₂ }

case cons
p : Γ' → Bool
k : K'
q : Λ'
o : Option Γ'
L₂ : List Γ'
a : Γ'
L₁ : List Γ'
IH :
  ∀ {s : Option Γ'} {S : K' → List Γ'},
    splitAtPred p (S k) = (L₁, o, L₂) →
      Reaches₁ (TM2.step tr) { l := some (Λ'.clear p k q), var := s, stk := S }
        { l := some q, var := o, stk := update S k L₂ }
s : Option Γ'
S : K' → List Γ'
e : splitAtPred p (S k) = (a :: L₁, o, L₂)
⊢ Reaches₁ (TM2.step tr) { l := some (Λ'.clear p k q), var := s, stk := S }
    { l := some q, var := o, stk := update S k L₂ }
tactic: induction' L₁ with a L₁ IH generalizing S s
Theorem: Ring.choose_succ_succ
File: Mathlib/RingTheory/Binomial.lean

Proof steps:
state_before: R : Type u_1
inst✝³ : NonAssocRing R
inst✝² : Pow R ℕ
inst✝¹ : BinomialRing R
inst✝ : NatPowAssoc R
r : R
k : ℕ
⊢ choose (r + 1) (k + 1) = choose r k + choose r (k + 1)
state_after: R : Type u_1
inst✝³ : NonAssocRing R
inst✝² : Pow R ℕ
inst✝¹ : BinomialRing R
inst✝ : NatPowAssoc R
r : R
k : ℕ
⊢ (fun x => (k + 1).factorial • x) (choose (r + 1) (k + 1)) =
    (fun x => (k + 1).factorial • x) (choose r k + choose r (k + 1))
tactic: refine nsmul_right_injective (Nat.factorial (k + 1)) (Nat.factorial_ne_zero (k + 1)) ?_
state_before: R : Type u_1
inst✝³ : NonAssocRing R
inst✝² : Pow R ℕ
inst✝¹ : BinomialRing R
inst✝ : NatPowAssoc R
r : R
k : ℕ
⊢ (fun x => (k + 1).factorial • x) (choose (r + 1) (k + 1)) =
    (fun x => (k + 1).factorial • x) (choose r k + choose r (k + 1))
state_after: R : Type u_1
inst✝³ : NonAssocRing R
inst✝² : Pow R ℕ
inst✝¹ : BinomialRing R
inst✝ : NatPowAssoc R
r : R
k : ℕ
⊢ (descPochhammer ℤ (k + 1)).smeval (r + 1) = (k + 1).factorial • choose r k + (descPochhammer ℤ (k + 1)).smeval r
tactic: simp only [smul_add, ← descPochhammer_eq_factorial_smul_choose]
state_before: R : Type u_1
inst✝³ : NonAssocRing R
inst✝² : Pow R ℕ
inst✝¹ : BinomialRing R
inst✝ : NatPowAssoc R
r : R
k : ℕ
⊢ (descPochhammer ℤ (k + 1)).smeval (r + 1) = (k + 1).factorial • choose r k + (descPochhammer ℤ (k + 1)).smeval r
state_after: no goals
tactic: rw [Nat.factorial_succ, mul_smul,
    ← descPochhammer_eq_factorial_smul_choose r, descPochhammer_succ_succ_smeval r k]
Theorem: AlgebraicGeometry.Scheme.OpenCover.gluedCover_U
File: Mathlib/AlgebraicGeometry/Gluing.lean

Proof steps:
state_before: X : Scheme
𝒰 : X.OpenCover
x : 𝒰.J
⊢ (fun x y => (pullbackSymmetry (𝒰.map x) (𝒰.map y)).hom) x x =
    𝟙
      ((fun x =>
          match x with
          | (x, y) => pullback (𝒰.map x) (𝒰.map y))
        (x, x))
state_after: no goals
tactic: simp
state_before: X : Scheme
𝒰 : X.OpenCover
x y z : 𝒰.J
⊢ (fun x y z => 𝒰.gluedCoverT' x y z) x y z ≫
      pullback.snd ((fun x y => pullback.fst (𝒰.map x) (𝒰.map y)) y z)
        ((fun x y => pullback.fst (𝒰.map x) (𝒰.map y)) y x) =
    pullback.fst ((fun x y => pullback.fst (𝒰.map x) (𝒰.map y)) x y)
        ((fun x y => pullback.fst (𝒰.map x) (𝒰.map y)) x z) ≫
      (fun x y => (pullbackSymmetry (𝒰.map x) (𝒰.map y)).hom) x y
state_after: no goals
tactic: apply pullback.hom_ext <;> simp
Theorem: Polynomial.monomial_mul_X
File: Mathlib/Algebra/Polynomial/Basic.lean

Proof steps:
state_before: R : Type u
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
n : ℕ
r : R
⊢ (monomial n) r * X = (monomial (n + 1)) r
state_after: no goals
tactic: erw [monomial_mul_monomial, mul_one]
Theorem: Real.log_lt_log
File: Mathlib/Analysis/SpecialFunctions/Log/Basic.lean

Proof steps:
state_before: x y : ℝ
hx : 0 < x
h : x < y
⊢ log x < log y
state_after: no goals
tactic: rwa [← exp_lt_exp, exp_log hx, exp_log (lt_trans hx h)]
Theorem: Real.Wallis.W_eq_integral_sin_pow_div_integral_sin_pow
File: Mathlib/Data/Real/Pi/Wallis.lean

Proof steps:
state_before: k : ℕ
⊢ (π / 2)⁻¹ * W k = (∫ (x : ℝ) in 0 ..π, sin x ^ (2 * k + 1)) / ∫ (x : ℝ) in 0 ..π, sin x ^ (2 * k)
state_after: k : ℕ
⊢ 2 / π * W k = 2 / π * ∏ x ∈ range k, (2 * ↑x + 2) / (2 * ↑x + 3) / ((2 * ↑x + 1) / (2 * ↑x + 2))
tactic: rw [integral_sin_pow_even, integral_sin_pow_odd, mul_div_mul_comm, ← prod_div_distrib, inv_div]
state_before: k : ℕ
⊢ 2 / π * W k = 2 / π * ∏ x ∈ range k, (2 * ↑x + 2) / (2 * ↑x + 3) / ((2 * ↑x + 1) / (2 * ↑x + 2))
state_after: k : ℕ
⊢ 2 / π * W k = 2 / π * ∏ x ∈ range k, (2 * ↑x + 2) / (2 * ↑x + 1) * ((2 * ↑x + 2) / (2 * ↑x + 3))
tactic: simp_rw [div_div_div_comm, div_div_eq_mul_div, mul_div_assoc]
state_before: k : ℕ
⊢ 2 / π * W k = 2 / π * ∏ x ∈ range k, (2 * ↑x + 2) / (2 * ↑x + 1) * ((2 * ↑x + 2) / (2 * ↑x + 3))
state_after: no goals
tactic: rfl
Theorem: KaehlerDifferential.submodule_span_range_eq_ideal
File: Mathlib/RingTheory/Kaehler/Basic.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝⁶ : CommRing R
inst✝⁵ : CommRing S
inst✝⁴ : Algebra R S
M : Type u_1
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : Module S M
inst✝ : IsScalarTower R S M
⊢ Submodule.span S (Set.range fun s => 1 ⊗ₜ[R] s - s ⊗ₜ[R] 1) = Submodule.restrictScalars S (ideal R S)
state_after: case a
R : Type u
S : Type v
inst✝⁶ : CommRing R
inst✝⁵ : CommRing S
inst✝⁴ : Algebra R S
M : Type u_1
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : Module S M
inst✝ : IsScalarTower R S M
⊢ Submodule.span S (Set.range fun s => 1 ⊗ₜ[R] s - s ⊗ₜ[R] 1) ≤ Submodule.restrictScalars S (ideal R S)

case a
R : Type u
S : Type v
inst✝⁶ : CommRing R
inst✝⁵ : CommRing S
inst✝⁴ : Algebra R S
M : Type u_1
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : Module S M
inst✝ : IsScalarTower R S M
⊢ Submodule.restrictScalars S (ideal R S) ≤ Submodule.span S (Set.range fun s => 1 ⊗ₜ[R] s - s ⊗ₜ[R] 1)
tactic: apply le_antisymm
Theorem: List.Ico.filter_le_of_top_le
File: Mathlib/Data/List/Intervals.lean

Proof steps:
state_before: n m l : ℕ
hml : m ≤ l
k : ℕ
hk : k ∈ Ico n m
⊢ ¬decide (l ≤ k) = true
state_after: n m l : ℕ
hml : m ≤ l
k : ℕ
hk : k ∈ Ico n m
⊢ ¬l ≤ k
tactic: rw [decide_eq_true_eq]
state_before: n m l : ℕ
hml : m ≤ l
k : ℕ
hk : k ∈ Ico n m
⊢ ¬l ≤ k
state_after: no goals
tactic: exact not_le_of_gt (lt_of_lt_of_le (mem.1 hk).2 hml)
Theorem: intervalIntegral.integral_comp_div_add
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

Proof steps:
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
a b c d✝ : ℝ
f : ℝ → E
hc : c ≠ 0
d : ℝ
⊢ ∫ (x : ℝ) in a..b, f (x / c + d) = c • ∫ (x : ℝ) in a / c + d..b / c + d, f x
state_after: no goals
tactic: simpa only [div_eq_inv_mul, inv_inv] using integral_comp_mul_add f (inv_ne_zero hc) d
Theorem: CategoryTheory.ShortComplex.SnakeInput.functorP_map
File: Mathlib/Algebra/Homology/ShortComplex/SnakeLemma.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{?u.129012, u_1} C
inst✝ : Abelian C
S S₁ S₂ S₃ x✝ : SnakeInput C
⊢ { obj := fun S => S.P,
          map := fun {X Y} f => pullback.map X.L₁.g X.v₀₁.τ₃ Y.L₁.g Y.v₀₁.τ₃ f.f₁.τ₂ f.f₀.τ₃ f.f₁.τ₃ ⋯ ⋯ }.map
      (𝟙 x✝) =
    𝟙
      ({ obj := fun S => S.P,
            map := fun {X Y} f => pullback.map X.L₁.g X.v₀₁.τ₃ Y.L₁.g Y.v₀₁.τ₃ f.f₁.τ₂ f.f₀.τ₃ f.f₁.τ₃ ⋯ ⋯ }.obj
        x✝)
state_after: C : Type u_1
inst✝¹ : Category.{?u.129012, u_1} C
inst✝ : Abelian C
S S₁ S₂ S₃ x✝ : SnakeInput C
⊢ pullback.map x✝.L₁.g x✝.v₀₁.τ₃ x✝.L₁.g x✝.v₀₁.τ₃ (𝟙 x✝.L₁.X₂) (𝟙 x✝.L₀.X₃) (𝟙 x✝.L₁.X₃) ⋯ ⋯ =
    𝟙 (pullback x✝.L₁.g x✝.v₀₁.τ₃)
tactic: dsimp [P]
state_before: C : Type u_1
inst✝¹ : Category.{?u.129012, u_1} C
inst✝ : Abelian C
S S₁ S₂ S₃ x✝ : SnakeInput C
⊢ pullback.map x✝.L₁.g x✝.v₀₁.τ₃ x✝.L₁.g x✝.v₀₁.τ₃ (𝟙 x✝.L₁.X₂) (𝟙 x✝.L₀.X₃) (𝟙 x✝.L₁.X₃) ⋯ ⋯ =
    𝟙 (pullback x✝.L₁.g x✝.v₀₁.τ₃)
state_after: no goals
tactic: aesop_cat
state_before: C : Type u_1
inst✝¹ : Category.{?u.129012, u_1} C
inst✝ : Abelian C
S S₁ S₂ S₃ X✝ Y✝ Z✝ : SnakeInput C
x✝¹ : X✝ ⟶ Y✝
x✝ : Y✝ ⟶ Z✝
⊢ { obj := fun S => S.P,
          map := fun {X Y} f => pullback.map X.L₁.g X.v₀₁.τ₃ Y.L₁.g Y.v₀₁.τ₃ f.f₁.τ₂ f.f₀.τ₃ f.f₁.τ₃ ⋯ ⋯ }.map
      (x✝¹ ≫ x✝) =
    { obj := fun S => S.P,
            map := fun {X Y} f => pullback.map X.L₁.g X.v₀₁.τ₃ Y.L₁.g Y.v₀₁.τ₃ f.f₁.τ₂ f.f₀.τ₃ f.f₁.τ₃ ⋯ ⋯ }.map
        x✝¹ ≫
      { obj := fun S => S.P,
            map := fun {X Y} f => pullback.map X.L₁.g X.v₀₁.τ₃ Y.L₁.g Y.v₀₁.τ₃ f.f₁.τ₂ f.f₀.τ₃ f.f₁.τ₃ ⋯ ⋯ }.map
        x✝
state_after: C : Type u_1
inst✝¹ : Category.{?u.129012, u_1} C
inst✝ : Abelian C
S S₁ S₂ S₃ X✝ Y✝ Z✝ : SnakeInput C
x✝¹ : X✝ ⟶ Y✝
x✝ : Y✝ ⟶ Z✝
⊢ pullback.map X✝.L₁.g X✝.v₀₁.τ₃ Z✝.L₁.g Z✝.v₀₁.τ₃ (x✝¹.f₁.τ₂ ≫ x✝.f₁.τ₂) (x✝¹.f₀.τ₃ ≫ x✝.f₀.τ₃) (x✝¹.f₁.τ₃ ≫ x✝.f₁.τ₃)
      ⋯ ⋯ =
    pullback.map X✝.L₁.g X✝.v₀₁.τ₃ Y✝.L₁.g Y✝.v₀₁.τ₃ x✝¹.f₁.τ₂ x✝¹.f₀.τ₃ x✝¹.f₁.τ₃ ⋯ ⋯ ≫
      pullback.map Y✝.L₁.g Y✝.v₀₁.τ₃ Z✝.L₁.g Z✝.v₀₁.τ₃ x✝.f₁.τ₂ x✝.f₀.τ₃ x✝.f₁.τ₃ ⋯ ⋯
tactic: dsimp [P]
state_before: C : Type u_1
inst✝¹ : Category.{?u.129012, u_1} C
inst✝ : Abelian C
S S₁ S₂ S₃ X✝ Y✝ Z✝ : SnakeInput C
x✝¹ : X✝ ⟶ Y✝
x✝ : Y✝ ⟶ Z✝
⊢ pullback.map X✝.L₁.g X✝.v₀₁.τ₃ Z✝.L₁.g Z✝.v₀₁.τ₃ (x✝¹.f₁.τ₂ ≫ x✝.f₁.τ₂) (x✝¹.f₀.τ₃ ≫ x✝.f₀.τ₃) (x✝¹.f₁.τ₃ ≫ x✝.f₁.τ₃)
      ⋯ ⋯ =
    pullback.map X✝.L₁.g X✝.v₀₁.τ₃ Y✝.L₁.g Y✝.v₀₁.τ₃ x✝¹.f₁.τ₂ x✝¹.f₀.τ₃ x✝¹.f₁.τ₃ ⋯ ⋯ ≫
      pullback.map Y✝.L₁.g Y✝.v₀₁.τ₃ Z✝.L₁.g Z✝.v₀₁.τ₃ x✝.f₁.τ₂ x✝.f₀.τ₃ x✝.f₁.τ₃ ⋯ ⋯
state_after: no goals
tactic: aesop_cat