ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: HurwitzZeta.hurwitzZetaEven_one_sub
File: Mathlib/NumberTheory/LSeries/HurwitzZetaEven.lean

Proof steps:
state_before: a : UnitAddCircle
s : ℂ
hs : ∀ (n : ℕ), s ≠ -↑n
hs' : a ≠ 0 ∨ s ≠ 1
⊢ hurwitzZetaEven a (1 - s) = 2 * (2 * ↑π) ^ (-s) * Complex.Gamma s * Complex.cos (↑π * s / 2) * cosZeta a s
state_after: a : UnitAddCircle
s : ℂ
hs : ∀ (n : ℕ), s ≠ -↑n
hs' : a ≠ 0 ∨ s ≠ 1
this : hurwitzZetaEven a (1 - s) = completedHurwitzZetaEven a (1 - s) * (1 - s).Gammaℝ⁻¹
⊢ hurwitzZetaEven a (1 - s) = 2 * (2 * ↑π) ^ (-s) * Complex.Gamma s * Complex.cos (↑π * s / 2) * cosZeta a s
tactic: have : hurwitzZetaEven a (1 - s) = completedHurwitzZetaEven a (1 - s) * (Gammaℝ (1 - s))⁻¹ := by
    rw [hurwitzZetaEven_def_of_ne_or_ne, div_eq_mul_inv]
    simpa [sub_eq_zero, eq_comm (a := s)] using hs'
state_before: a : UnitAddCircle
s : ℂ
hs : ∀ (n : ℕ), s ≠ -↑n
hs' : a ≠ 0 ∨ s ≠ 1
this : hurwitzZetaEven a (1 - s) = completedHurwitzZetaEven a (1 - s) * (1 - s).Gammaℝ⁻¹
⊢ hurwitzZetaEven a (1 - s) = 2 * (2 * ↑π) ^ (-s) * Complex.Gamma s * Complex.cos (↑π * s / 2) * cosZeta a s
state_after: a : UnitAddCircle
s : ℂ
hs : ∀ (n : ℕ), s ≠ -↑n
hs' : a ≠ 0 ∨ s ≠ 1
this : hurwitzZetaEven a (1 - s) = completedHurwitzZetaEven a (1 - s) * (1 - s).Gammaℝ⁻¹
⊢ completedCosZeta a s * (s.Gammaℂ * Complex.cos (↑π * s / 2) * s.Gammaℝ⁻¹) =
    s.Gammaℂ * Complex.cos (↑π * s / 2) * (completedCosZeta a s / s.Gammaℝ)
tactic: rw [this, completedHurwitzZetaEven_one_sub, inv_Gammaℝ_one_sub hs, cosZeta,
    Function.update_noteq (by simpa using hs 0), ← Gammaℂ]
state_before: a : UnitAddCircle
s : ℂ
hs : ∀ (n : ℕ), s ≠ -↑n
hs' : a ≠ 0 ∨ s ≠ 1
this : hurwitzZetaEven a (1 - s) = completedHurwitzZetaEven a (1 - s) * (1 - s).Gammaℝ⁻¹
⊢ completedCosZeta a s * (s.Gammaℂ * Complex.cos (↑π * s / 2) * s.Gammaℝ⁻¹) =
    s.Gammaℂ * Complex.cos (↑π * s / 2) * (completedCosZeta a s / s.Gammaℝ)
state_after: a : UnitAddCircle
s : ℂ
hs : ∀ (n : ℕ), s ≠ -↑n
hs' : a ≠ 0 ∨ s ≠ 1
this : hurwitzZetaEven a (1 - s) = completedHurwitzZetaEven a (1 - s) * (1 - s).Gammaℝ⁻¹
A : ℂ
⊢ completedCosZeta a s * (A * s.Gammaℝ⁻¹) = A * (completedCosZeta a s / s.Gammaℝ)
tactic: generalize Gammaℂ s * cos (π * s / 2) = A
state_before: a : UnitAddCircle
s : ℂ
hs : ∀ (n : ℕ), s ≠ -↑n
hs' : a ≠ 0 ∨ s ≠ 1
this : hurwitzZetaEven a (1 - s) = completedHurwitzZetaEven a (1 - s) * (1 - s).Gammaℝ⁻¹
A : ℂ
⊢ completedCosZeta a s * (A * s.Gammaℝ⁻¹) = A * (completedCosZeta a s / s.Gammaℝ)
state_after: no goals
tactic: ring_nf
Theorem: Valuation.comap_onQuot_eq
File: Mathlib/RingTheory/Valuation/Quotient.lean

Proof steps:
state_before: R : Type u_1
Γ₀ : Type u_2
inst✝¹ : CommRing R
inst✝ : LinearOrderedCommMonoidWithZero Γ₀
v✝ : Valuation R Γ₀
J : Ideal R
v : Valuation (R ⧸ J) Γ₀
⊢ ∀ (r : R ⧸ J), ((comap (Ideal.Quotient.mk J) v).onQuot ⋯) r = v r
state_after: case mk
R : Type u_1
Γ₀ : Type u_2
inst✝¹ : CommRing R
inst✝ : LinearOrderedCommMonoidWithZero Γ₀
v✝ : Valuation R Γ₀
J : Ideal R
v : Valuation (R ⧸ J) Γ₀
r✝ : R ⧸ J
x : R
⊢ ((comap (Ideal.Quotient.mk J) v).onQuot ⋯) (Quot.mk Setoid.r x) = v (Quot.mk Setoid.r x)
tactic: rintro ⟨x⟩
state_before: case mk
R : Type u_1
Γ₀ : Type u_2
inst✝¹ : CommRing R
inst✝ : LinearOrderedCommMonoidWithZero Γ₀
v✝ : Valuation R Γ₀
J : Ideal R
v : Valuation (R ⧸ J) Γ₀
r✝ : R ⧸ J
x : R
⊢ ((comap (Ideal.Quotient.mk J) v).onQuot ⋯) (Quot.mk Setoid.r x) = v (Quot.mk Setoid.r x)
state_after: no goals
tactic: rfl
Theorem: le_map_mul_map_div
File: Mathlib/Algebra/Order/Hom/Basic.lean

Proof steps:
state_before: ι : Type u_1
F : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
inst✝⁴ : FunLike F α β
inst✝³ : Group α
inst✝² : CommSemigroup β
inst✝¹ : LE β
inst✝ : SubmultiplicativeHomClass F α β
f : F
a b : α
⊢ f a ≤ f b * f (a / b)
state_after: no goals
tactic: simpa only [mul_comm, div_mul_cancel] using map_mul_le_mul f (a / b) b
Theorem: IsLprojection.mul_compl_self
File: Mathlib/Analysis/NormedSpace/MStructure.lean

Proof steps:
state_before: X : Type u_1
inst✝² : NormedAddCommGroup X
M : Type u_2
inst✝¹ : Ring M
inst✝ : Module M X
P : { P // IsLprojection X P }
⊢ ↑P * ↑Pᶜ = 0
state_after: no goals
tactic: rw [coe_compl, mul_sub, mul_one, P.prop.proj.eq, sub_self]
Theorem: FormalMultilinearSeries.leftInv_coeff_one
File: Mathlib/Analysis/Analytic/Inverse.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
p : FormalMultilinearSeries 𝕜 E F
i : E ≃L[𝕜] F
⊢ p.leftInv i 1 = (continuousMultilinearCurryFin1 𝕜 F E).symm ↑i.symm
state_after: no goals
tactic: rw [leftInv]
Theorem: Fin.cycleType_cycleRange
File: Mathlib/GroupTheory/Perm/Fin.lean

Proof steps:
state_before: n : ℕ
i : Fin (n + 1)
h0 : i ≠ 0
⊢ i.cycleRange.cycleType = {↑i + 1}
state_after: case mk
n i : ℕ
hi : i < n + 1
h0 : ⟨i, hi⟩ ≠ 0
⊢ ⟨i, hi⟩.cycleRange.cycleType = {↑⟨i, hi⟩ + 1}
tactic: cases' i with i hi
state_before: case mk
n i : ℕ
hi : i < n + 1
h0 : ⟨i, hi⟩ ≠ 0
⊢ ⟨i, hi⟩.cycleRange.cycleType = {↑⟨i, hi⟩ + 1}
state_after: case mk.zero
n : ℕ
hi : 0 < n + 1
h0 : ⟨0, hi⟩ ≠ 0
⊢ ⟨0, hi⟩.cycleRange.cycleType = {↑⟨0, hi⟩ + 1}

case mk.succ
n n✝ : ℕ
hi : n✝ + 1 < n + 1
h0 : ⟨n✝ + 1, hi⟩ ≠ 0
⊢ ⟨n✝ + 1, hi⟩.cycleRange.cycleType = {↑⟨n✝ + 1, hi⟩ + 1}
tactic: cases i
state_before: case mk.succ
n n✝ : ℕ
hi : n✝ + 1 < n + 1
h0 : ⟨n✝ + 1, hi⟩ ≠ 0
⊢ ⟨n✝ + 1, hi⟩.cycleRange.cycleType = {↑⟨n✝ + 1, hi⟩ + 1}
state_after: case mk.succ
n n✝ : ℕ
hi : n✝ + 1 < n + 1
h0 : ⟨n✝ + 1, hi⟩ ≠ 0
⊢ (finRotate (↑⟨n✝ + 1, hi⟩ + 1)).cycleType = {↑⟨n✝ + 1, hi⟩ + 1}
tactic: rw [cycleRange, cycleType_extendDomain]
state_before: case mk.succ
n n✝ : ℕ
hi : n✝ + 1 < n + 1
h0 : ⟨n✝ + 1, hi⟩ ≠ 0
⊢ (finRotate (↑⟨n✝ + 1, hi⟩ + 1)).cycleType = {↑⟨n✝ + 1, hi⟩ + 1}
state_after: no goals
tactic: exact cycleType_finRotate
Theorem: Polynomial.map_cyclotomic_int
File: Mathlib/RingTheory/Polynomial/Cyclotomic/Basic.lean

Proof steps:
state_before: n : ℕ
R : Type u_1
inst✝ : Ring R
⊢ map (Int.castRingHom R) (cyclotomic n ℤ) = cyclotomic n R
state_after: case pos
n : ℕ
R : Type u_1
inst✝ : Ring R
hzero : n = 0
⊢ map (Int.castRingHom R) (cyclotomic n ℤ) = cyclotomic n R

case neg
n : ℕ
R : Type u_1
inst✝ : Ring R
hzero : ¬n = 0
⊢ map (Int.castRingHom R) (cyclotomic n ℤ) = cyclotomic n R
tactic: by_cases hzero : n = 0
state_before: case neg
n : ℕ
R : Type u_1
inst✝ : Ring R
hzero : ¬n = 0
⊢ map (Int.castRingHom R) (cyclotomic n ℤ) = cyclotomic n R
state_after: no goals
tactic: simp [cyclotomic, hzero]
Theorem: EuclideanGeometry.angle_eq_angle_of_dist_eq
File: Mathlib/Geometry/Euclidean/Triangle.lean

Proof steps:
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p1 p2 p3 : P
h : dist p1 p2 = dist p1 p3
⊢ ∠ p1 p2 p3 = ∠ p1 p3 p2
state_after: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p1 p2 p3 : P
h : ‖p1 -ᵥ p2‖ = ‖p1 -ᵥ p3‖
⊢ ∠ p1 p2 p3 = ∠ p1 p3 p2
tactic: rw [dist_eq_norm_vsub V p1 p2, dist_eq_norm_vsub V p1 p3] at h
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p1 p2 p3 : P
h : ‖p1 -ᵥ p2‖ = ‖p1 -ᵥ p3‖
⊢ ∠ p1 p2 p3 = ∠ p1 p3 p2
state_after: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p1 p2 p3 : P
h : ‖p1 -ᵥ p2‖ = ‖p1 -ᵥ p3‖
⊢ InnerProductGeometry.angle (p1 -ᵥ p2) (p3 -ᵥ p2) = InnerProductGeometry.angle (p1 -ᵥ p3) (p2 -ᵥ p3)
tactic: unfold angle
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p1 p2 p3 : P
h : ‖p1 -ᵥ p2‖ = ‖p1 -ᵥ p3‖
⊢ InnerProductGeometry.angle (p1 -ᵥ p2) (p3 -ᵥ p2) = InnerProductGeometry.angle (p1 -ᵥ p3) (p2 -ᵥ p3)
state_after: case h.e'_2.h.e'_5
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p1 p2 p3 : P
h : ‖p1 -ᵥ p2‖ = ‖p1 -ᵥ p3‖
⊢ p3 -ᵥ p2 = p1 -ᵥ p2 - (p1 -ᵥ p3)

case h.e'_3.h.e'_5
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p1 p2 p3 : P
h : ‖p1 -ᵥ p2‖ = ‖p1 -ᵥ p3‖
⊢ p2 -ᵥ p3 = p1 -ᵥ p3 - (p1 -ᵥ p2)
tactic: convert angle_sub_eq_angle_sub_rev_of_norm_eq h
Theorem: Finset.Icc_eq_singleton_iff
File: Mathlib/Order/Interval/Finset/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : PartialOrder α
inst✝ : LocallyFiniteOrder α
a b c : α
⊢ Icc a b = {c} ↔ a = c ∧ b = c
state_after: no goals
tactic: rw [← coe_eq_singleton, coe_Icc, Set.Icc_eq_singleton_iff]
Theorem: IntervalIntegrable.comp_add_left
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✝ : NormedRing A
f g : ℝ → E
a b : ℝ
μ : Measure ℝ
hf : IntervalIntegrable f volume a b
c : ℝ
⊢ IntervalIntegrable (fun x => f (c + x)) volume (a - c) (b - c)
state_after: no goals
tactic: simpa only [add_comm] using IntervalIntegrable.comp_add_right hf c
Theorem: dirSupClosed_iff_forall_sSup
File: Mathlib/Topology/Order/ScottTopology.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : CompleteLattice α
s t : Set α
⊢ DirSupClosed s ↔ ∀ ⦃d : Set α⦄, d.Nonempty → DirectedOn (fun x x_1 => x ≤ x_1) d → d ⊆ s → sSup d ∈ s
state_after: no goals
tactic: simp [DirSupClosed, isLUB_iff_sSup_eq]
Theorem: isConnected_setOf_sameRay_and_ne_zero
File: Mathlib/Analysis/Convex/Normed.lean

Proof steps:
state_before: ι : Type u_1
E : Type u_2
P : Type u_3
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : PseudoMetricSpace P
inst✝ : NormedAddTorsor E P
s t : Set E
x : E
hx : x ≠ 0
⊢ IsConnected {y | SameRay ℝ x y ∧ y ≠ 0}
state_after: ι : Type u_1
E : Type u_2
P : Type u_3
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : PseudoMetricSpace P
inst✝ : NormedAddTorsor E P
s t : Set E
x : E
hx : x ≠ 0
⊢ IsConnected {y | ∃ r, 0 < r ∧ r • x = y}
tactic: simp_rw [← exists_pos_left_iff_sameRay_and_ne_zero hx]
state_before: ι : Type u_1
E : Type u_2
P : Type u_3
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : PseudoMetricSpace P
inst✝ : NormedAddTorsor E P
s t : Set E
x : E
hx : x ≠ 0
⊢ IsConnected {y | ∃ r, 0 < r ∧ r • x = y}
state_after: no goals
tactic: exact isConnected_Ioi.image _ (continuous_id.smul continuous_const).continuousOn
Theorem: Cycle.subsingleton_reverse_iff
File: Mathlib/Data/List/Cycle.lean

Proof steps:
state_before: α : Type u_1
s : Cycle α
⊢ s.reverse.Subsingleton ↔ s.Subsingleton
state_after: no goals
tactic: simp [length_subsingleton_iff]
Theorem: principal_exterior
File: Mathlib/Topology/AlexandrovDiscrete.lean

Proof steps:
state_before: ι : Sort u_1
κ : ι → Sort u_2
α : Type u_3
β : Type u_4
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
s✝ t : Set α
a x y : α
inst✝¹ : AlexandrovDiscrete α
inst✝ : AlexandrovDiscrete β
s : Set α
⊢ 𝓟 (exterior s) = 𝓝ˢ s
state_after: no goals
tactic: rw [← nhdsSet_exterior, isOpen_exterior.nhdsSet_eq]
Theorem: List.TProd.elim_self
File: Mathlib/Data/Prod/TProd.lean

Proof steps:
state_before: ι : Type u
α : ι → Type v
i j : ι
l : List ι
f : (i : ι) → α i
inst✝ : DecidableEq ι
v : TProd α (i :: l)
⊢ v.elim ⋯ = v.1
state_after: no goals
tactic: simp [TProd.elim]
Theorem: matPolyEquiv_diagonal_X
File: Mathlib/RingTheory/PolynomialAlgebra.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
⊢ matPolyEquiv (diagonal fun x => X) = X
state_after: no goals
tactic: rw [← matPolyEquiv_symm_X, AlgEquiv.apply_symm_apply]
Theorem: EuclideanDomain.eq_div_of_mul_eq_right
File: Mathlib/Algebra/EuclideanDomain/Basic.lean

Proof steps:
state_before: R : Type u
inst✝ : EuclideanDomain R
a b c : R
ha : a ≠ 0
h : a * b = c
⊢ b = c / a
state_after: no goals
tactic: rw [← h, mul_div_cancel_left₀ _ ha]
Theorem: Set.image_preimage_eq_range_inter
File: Mathlib/Data/Set/Image.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : ι → α
s t✝ : Set α
f : α → β
t : Set β
x : β
x✝ : x ∈ range f ∩ t
y : α
h_eq : f y = x
hx : x ∈ t
⊢ y ∈ f ⁻¹' t
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : ι → α
s t✝ : Set α
f : α → β
t : Set β
x : β
x✝ : x ∈ range f ∩ t
y : α
h_eq : f y = x
hx : x ∈ t
⊢ x ∈ t
tactic: rw [preimage, mem_setOf, h_eq]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : ι → α
s t✝ : Set α
f : α → β
t : Set β
x : β
x✝ : x ∈ range f ∩ t
y : α
h_eq : f y = x
hx : x ∈ t
⊢ x ∈ t
state_after: no goals
tactic: exact hx
Theorem: SchwartzMap.integrable
File: Mathlib/Analysis/Distribution/SchwartzSpace.lean

Proof steps:
state_before: 𝕜 : Type u_1
𝕜' : Type u_2
D : Type u_3
E : Type u_4
F : Type u_5
G : Type u_6
V : Type u_7
inst✝¹² : NormedAddCommGroup E
inst✝¹¹ : NormedSpace ℝ E
inst✝¹⁰ : NormedAddCommGroup F
inst✝⁹ : NormedSpace ℝ F
inst✝⁸ : _root_.RCLike 𝕜
inst✝⁷ : NormedAddCommGroup D
inst✝⁶ : NormedSpace ℝ D
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : NormedSpace ℝ V
inst✝³ : NormedSpace 𝕜 V
inst✝² : MeasurableSpace D
inst✝¹ : BorelSpace D
inst✝ : SecondCountableTopology D
μ : Measure D
hμ : μ.HasTemperateGrowth
f : 𝓢(D, V)
x✝ : D
⊢ ‖f x✝‖ ≤ ‖‖x✝‖ ^ 0 * ‖f x✝‖‖
state_after: no goals
tactic: simp
Theorem: Matrix.updateColumn_conjTranspose
File: Mathlib/Data/Matrix/RowCol.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
α : Type v
β : Type w
ι : Type u_6
M : Matrix m n α
i : m
j : n
b : n → α
c : m → α
inst✝¹ : DecidableEq m
inst✝ : Star α
⊢ Mᴴ.updateColumn i (star b) = (M.updateRow i b)ᴴ
state_after: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
α : Type v
β : Type w
ι : Type u_6
M : Matrix m n α
i : m
j : n
b : n → α
c : m → α
inst✝¹ : DecidableEq m
inst✝ : Star α
⊢ ((M.map star).updateRow i (star b))ᵀ = ((M.map star).updateRow i (star ∘ b))ᵀ
tactic: rw [conjTranspose, conjTranspose, transpose_map, transpose_map, updateColumn_transpose,
    map_updateRow]
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
α : Type v
β : Type w
ι : Type u_6
M : Matrix m n α
i : m
j : n
b : n → α
c : m → α
inst✝¹ : DecidableEq m
inst✝ : Star α
⊢ ((M.map star).updateRow i (star b))ᵀ = ((M.map star).updateRow i (star ∘ b))ᵀ
state_after: no goals
tactic: rfl
Theorem: Ordinal.lt_nmul_iff₃
File: Mathlib/SetTheory/Ordinal/NaturalOps.lean

Proof steps:
state_before: a b c d : Ordinal.{u}
⊢ d < a ⨳ b ⨳ c ↔
    ∃ a' < a,
      ∃ b' < b,
        ∃ c' < c, d ♯ a' ⨳ b' ⨳ c ♯ a' ⨳ b ⨳ c' ♯ a ⨳ b' ⨳ c' ≤ a' ⨳ b ⨳ c ♯ a ⨳ b' ⨳ c ♯ a ⨳ b ⨳ c' ♯ a' ⨳ b' ⨳ c'
state_after: case refine_1
a b c d : Ordinal.{u}
h : d < a ⨳ b ⨳ c
⊢ ∃ a' < a,
    ∃ b' < b,
      ∃ c' < c, d ♯ a' ⨳ b' ⨳ c ♯ a' ⨳ b ⨳ c' ♯ a ⨳ b' ⨳ c' ≤ a' ⨳ b ⨳ c ♯ a ⨳ b' ⨳ c ♯ a ⨳ b ⨳ c' ♯ a' ⨳ b' ⨳ c'

case refine_2
a b c d : Ordinal.{u}
⊢ (∃ a' < a,
      ∃ b' < b,
        ∃ c' < c, d ♯ a' ⨳ b' ⨳ c ♯ a' ⨳ b ⨳ c' ♯ a ⨳ b' ⨳ c' ≤ a' ⨳ b ⨳ c ♯ a ⨳ b' ⨳ c ♯ a ⨳ b ⨳ c' ♯ a' ⨳ b' ⨳ c') →
    d < a ⨳ b ⨳ c
tactic: refine ⟨fun h => ?_, ?_⟩
Theorem: Matroid.Base.insert_dep
File: Mathlib/Data/Matroid/Basic.lean

Proof steps:
state_before: α : Type u_1
M : Matroid α
B B' I J D X : Set α
e f : α
hB : M.Base B
h : e ∈ M.E \ B
⊢ M.Dep (insert e B)
state_after: α : Type u_1
M : Matroid α
B B' I J D X : Set α
e f : α
hB : M.Base B
h : e ∈ M.E \ B
⊢ ¬M.Indep (insert e B)
tactic: rw [← not_indep_iff (insert_subset h.1 hB.subset_ground)]
state_before: α : Type u_1
M : Matroid α
B B' I J D X : Set α
e f : α
hB : M.Base B
h : e ∈ M.E \ B
⊢ ¬M.Indep (insert e B)
state_after: no goals
tactic: exact h.2 ∘ (fun hi ↦ insert_eq_self.mp (hB.eq_of_subset_indep hi (subset_insert e B)).symm)
Theorem: Cardinal.mul_eq_max
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

Proof steps:
state_before: a b : Cardinal.{u_1}
ha : ℵ₀ ≤ a
hb : ℵ₀ ≤ b
⊢ a ≤ a * b
state_after: no goals
tactic: simpa only [mul_one] using mul_le_mul_left' (one_le_aleph0.trans hb) a
state_before: a b : Cardinal.{u_1}
ha : ℵ₀ ≤ a
hb : ℵ₀ ≤ b
⊢ b ≤ a * b
state_after: no goals
tactic: simpa only [one_mul] using mul_le_mul_right' (one_le_aleph0.trans ha) b
Theorem: MulChar.ringHomComp_inv
File: Mathlib/NumberTheory/MulChar/Basic.lean

Proof steps:
state_before: R✝ : Type u_1
inst✝³ : CommMonoid R✝
R' : Type u_2
inst✝² : CommRing R'
R'' : Type u_3
inst✝¹ : CommRing R''
R : Type u_4
inst✝ : CommRing R
χ : MulChar R R'
f : R' →+* R''
⊢ (χ.ringHomComp f)⁻¹ = χ⁻¹.ringHomComp f
state_after: case h
R✝ : Type u_1
inst✝³ : CommMonoid R✝
R' : Type u_2
inst✝² : CommRing R'
R'' : Type u_3
inst✝¹ : CommRing R''
R : Type u_4
inst✝ : CommRing R
χ : MulChar R R'
f : R' →+* R''
a✝ : Rˣ
⊢ (χ.ringHomComp f)⁻¹ ↑a✝ = (χ⁻¹.ringHomComp f) ↑a✝
tactic: ext1
state_before: case h
R✝ : Type u_1
inst✝³ : CommMonoid R✝
R' : Type u_2
inst✝² : CommRing R'
R'' : Type u_3
inst✝¹ : CommRing R''
R : Type u_4
inst✝ : CommRing R
χ : MulChar R R'
f : R' →+* R''
a✝ : Rˣ
⊢ (χ.ringHomComp f)⁻¹ ↑a✝ = (χ⁻¹.ringHomComp f) ↑a✝
state_after: no goals
tactic: simp only [inv_apply, Ring.inverse_unit, ringHomComp_apply]
Theorem: TensorAlgebra.ι_leftInverse
File: Mathlib/LinearAlgebra/TensorAlgebra/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝² : CommSemiring R
M : Type u_2
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
x : M
⊢ ιInv ((ι R) x) = x
state_after: no goals
tactic: simp [ιInv]
Theorem: Behrend.sum_eq
File: Mathlib/Combinatorics/Additive/AP/Three/Behrend.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
⊢ ∑ i : Fin n, d * (2 * d + 1) ^ ↑i = ((2 * d + 1) ^ n - 1) / 2
state_after: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
⊢ (2 * d + 1) ^ n - 1 = (∑ i : Fin n, d * (2 * d + 1) ^ ↑i) * 2
tactic: refine (Nat.div_eq_of_eq_mul_left zero_lt_two ?_).symm
state_before: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
⊢ (2 * d + 1) ^ n - 1 = (∑ i : Fin n, d * (2 * d + 1) ^ ↑i) * 2
state_after: no goals
tactic: rw [← sum_range fun i => d * (2 * d + 1) ^ (i : ℕ), ← mul_sum, mul_right_comm, mul_comm d, ←
    geom_sum_mul_add, add_tsub_cancel_right, mul_comm]
Theorem: IsUnit.div
File: Mathlib/Algebra/Group/Units.lean

Proof steps:
state_before: α : Type u
M : Type u_1
N : Type u_2
inst✝ : DivisionMonoid α
a b c : α
ha : IsUnit a
hb : IsUnit b
⊢ IsUnit (a / b)
state_after: α : Type u
M : Type u_1
N : Type u_2
inst✝ : DivisionMonoid α
a b c : α
ha : IsUnit a
hb : IsUnit b
⊢ IsUnit (a * b⁻¹)
tactic: rw [div_eq_mul_inv]
state_before: α : Type u
M : Type u_1
N : Type u_2
inst✝ : DivisionMonoid α
a b c : α
ha : IsUnit a
hb : IsUnit b
⊢ IsUnit (a * b⁻¹)
state_after: no goals
tactic: exact ha.mul hb.inv
Theorem: StieltjesFunction.ext
File: Mathlib/MeasureTheory/Measure/Stieltjes.lean

Proof steps:
state_before: f g : StieltjesFunction
h : ∀ (x : ℝ), ↑f x = ↑g x
⊢ f = g
state_after: no goals
tactic: exact (StieltjesFunction.mk.injEq ..).mpr (funext h)
Theorem: Mathlib.Vector.insertNth_comm
File: Mathlib/Data/Vector/Basic.lean

Proof steps:
state_before: n : ℕ
α : Type u_1
β : Type u_2
γ : Type u_3
a✝ a b : α
i j : Fin (n + 1)
h : i ≤ j
l : List α
hl : l.length = n
⊢ insertNth b j.succ (insertNth a i ⟨l, hl⟩) = insertNth a i.castSucc (insertNth b j ⟨l, hl⟩)
state_after: n : ℕ
α : Type u_1
β : Type u_2
γ : Type u_3
a✝ a b : α
i j : Fin (n + 1)
h : i ≤ j
l : List α
hl : l.length = n
⊢ ↑(insertNth b j.succ (insertNth a i ⟨l, hl⟩)) = ↑(insertNth a i.castSucc (insertNth b j ⟨l, hl⟩))
tactic: refine Subtype.eq ?_
state_before: n : ℕ
α : Type u_1
β : Type u_2
γ : Type u_3
a✝ a b : α
i j : Fin (n + 1)
h : i ≤ j
l : List α
hl : l.length = n
⊢ ↑(insertNth b j.succ (insertNth a i ⟨l, hl⟩)) = ↑(insertNth a i.castSucc (insertNth b j ⟨l, hl⟩))
state_after: n : ℕ
α : Type u_1
β : Type u_2
γ : Type u_3
a✝ a b : α
i j : Fin (n + 1)
h : i ≤ j
l : List α
hl : l.length = n
⊢ List.insertNth (↑j + 1) b (List.insertNth (↑i) a l) = List.insertNth (↑i) a (List.insertNth (↑j) b l)
tactic: simp only [insertNth_val, Fin.val_succ, Fin.castSucc, Fin.coe_castAdd]
state_before: n : ℕ
α : Type u_1
β : Type u_2
γ : Type u_3
a✝ a b : α
i j : Fin (n + 1)
h : i ≤ j
l : List α
hl : l.length = n
⊢ List.insertNth (↑j + 1) b (List.insertNth (↑i) a l) = List.insertNth (↑i) a (List.insertNth (↑j) b l)
state_after: case x
n : ℕ
α : Type u_1
β : Type u_2
γ : Type u_3
a✝ a b : α
i j : Fin (n + 1)
h : i ≤ j
l : List α
hl : l.length = n
⊢ ↑i ≤ ↑j

case x
n : ℕ
α : Type u_1
β : Type u_2
γ : Type u_3
a✝ a b : α
i j : Fin (n + 1)
h : i ≤ j
l : List α
hl : l.length = n
⊢ ↑j ≤ l.length
tactic: apply List.insertNth_comm
Theorem: Polynomial.rootSet_X_pow
File: Mathlib/Algebra/Polynomial/FieldDivision.lean

Proof steps:
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n✝ : ℕ
inst✝³ : Field R
p q : R[X]
inst✝² : CommRing S
inst✝¹ : IsDomain S
inst✝ : Algebra R S
n : ℕ
hn : n ≠ 0
⊢ (X ^ n).rootSet S = {0}
state_after: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n✝ : ℕ
inst✝³ : Field R
p q : R[X]
inst✝² : CommRing S
inst✝¹ : IsDomain S
inst✝ : Algebra R S
n : ℕ
hn : n ≠ 0
⊢ 1 ≠ 0
tactic: rw [← one_mul (X ^ n : R[X]), ← C_1, rootSet_C_mul_X_pow hn]
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n✝ : ℕ
inst✝³ : Field R
p q : R[X]
inst✝² : CommRing S
inst✝¹ : IsDomain S
inst✝ : Algebra R S
n : ℕ
hn : n ≠ 0
⊢ 1 ≠ 0
state_after: no goals
tactic: exact one_ne_zero
Theorem: CategoryTheory.Limits.pushoutIsoUnopPullback_inv_fst
File: Mathlib/CategoryTheory/Limits/Opposites.lean

Proof steps:
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
J : Type u₂
inst✝² : Category.{v₂, u₂} J
X✝ : Type v₂
X Y Z : C
f : X ⟶ Z
g : X ⟶ Y
inst✝¹ : HasPushout f g
inst✝ : HasPullback f.op g.op
⊢ (pushoutIsoUnopPullback f g).inv.op ≫ pullback.fst f.op g.op = (pushout.inl f g).op
state_after: case a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
J : Type u₂
inst✝² : Category.{v₂, u₂} J
X✝ : Type v₂
X Y Z : C
f : X ⟶ Z
g : X ⟶ Y
inst✝¹ : HasPushout f g
inst✝ : HasPullback f.op g.op
⊢ ((pushoutIsoUnopPullback f g).inv.op ≫ pullback.fst f.op g.op).unop = (pushout.inl f g).op.unop
tactic: apply Quiver.Hom.unop_inj
state_before: case a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
J : Type u₂
inst✝² : Category.{v₂, u₂} J
X✝ : Type v₂
X Y Z : C
f : X ⟶ Z
g : X ⟶ Y
inst✝¹ : HasPushout f g
inst✝ : HasPullback f.op g.op
⊢ ((pushoutIsoUnopPullback f g).inv.op ≫ pullback.fst f.op g.op).unop = (pushout.inl f g).op.unop
state_after: case a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
J : Type u₂
inst✝² : Category.{v₂, u₂} J
X✝ : Type v₂
X Y Z : C
f : X ⟶ Z
g : X ⟶ Y
inst✝¹ : HasPushout f g
inst✝ : HasPullback f.op g.op
⊢ (pullback.fst f.op g.op).unop ≫ (pushoutIsoUnopPullback f g).inv = pushout.inl f g
tactic: dsimp
state_before: case a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
J : Type u₂
inst✝² : Category.{v₂, u₂} J
X✝ : Type v₂
X Y Z : C
f : X ⟶ Z
g : X ⟶ Y
inst✝¹ : HasPushout f g
inst✝ : HasPullback f.op g.op
⊢ (pullback.fst f.op g.op).unop ≫ (pushoutIsoUnopPullback f g).inv = pushout.inl f g
state_after: no goals
tactic: rw [← pushoutIsoUnopPullback_inl_hom, Category.assoc, Iso.hom_inv_id, Category.comp_id]
Theorem: Cardinal.aleph0_lt_aleph_one
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

Proof steps:
state_before: ⊢ ℵ₀ < aleph 1
state_after: ⊢ ℵ₀ < succ ℵ₀
tactic: rw [← succ_aleph0]
state_before: ⊢ ℵ₀ < succ ℵ₀
state_after: no goals
tactic: apply lt_succ
Theorem: HNNExtension.of_mul_inv_t
File: Mathlib/GroupTheory/HNNExtension.lean

Proof steps:
state_before: G : Type u_1
inst✝² : Group G
A B : Subgroup G
φ : ↥A ≃* ↥B
H : Type u_2
inst✝¹ : Group H
M : Type u_3
inst✝ : Monoid M
a : ↥A
⊢ of ↑a * t⁻¹ = t⁻¹ * of ↑(φ a)
state_after: G : Type u_1
inst✝² : Group G
A B : Subgroup G
φ : ↥A ≃* ↥B
H : Type u_2
inst✝¹ : Group H
M : Type u_3
inst✝ : Monoid M
a : ↥A
⊢ of ↑a * t⁻¹ = t⁻¹ * (t * of ↑a * t⁻¹)
tactic: rw [equiv_eq_conj]
state_before: G : Type u_1
inst✝² : Group G
A B : Subgroup G
φ : ↥A ≃* ↥B
H : Type u_2
inst✝¹ : Group H
M : Type u_3
inst✝ : Monoid M
a : ↥A
⊢ of ↑a * t⁻¹ = t⁻¹ * (t * of ↑a * t⁻¹)
state_after: no goals
tactic: simp [mul_assoc]