ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: abs_lt
File: Mathlib/Algebra/Order/Group/Unbundled/Abs.lean

Proof steps:
state_before: α : Type u_1
inst✝³ : Group α
inst✝² : LinearOrder α
a✝ b✝ : α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c : α
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
⊢ a⁻¹ < b ∧ a < b ↔ b⁻¹ < a ∧ a < b
state_after: no goals
tactic: rw [inv_lt']
Theorem: DualNumber.lift_op_smul
File: Mathlib/Algebra/DualNumber.lean

Proof steps:
state_before: R : Type u_1
A✝ : Type u_2
B : Type u_3
A : Type u_4
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Semiring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
fe : { fe // fe.2 * fe.2 = 0 ∧ ∀ (a : A), Commute fe.2 (fe.1 a) }
a : A
ad : A[ε]
⊢ (lift fe) (MulOpposite.op a • ad) = (lift fe) ad * (↑fe).1 a
state_after: no goals
tactic: rw [← mul_inl_eq_op_smul, map_mul, lift_apply_inl]
Theorem: dist_vadd_vadd_le
File: Mathlib/Analysis/Normed/Group/AddTorsor.lean

Proof steps:
state_before: α : Type u_1
V : Type u_2
P : Type u_3
W : Type u_4
Q : Type u_5
inst✝⁵ : SeminormedAddCommGroup V
inst✝⁴ : PseudoMetricSpace P
inst✝³ : NormedAddTorsor V P
inst✝² : NormedAddCommGroup W
inst✝¹ : MetricSpace Q
inst✝ : NormedAddTorsor W Q
v v' : V
p p' : P
⊢ dist (v +ᵥ p) (v' +ᵥ p') ≤ dist v v' + dist p p'
state_after: no goals
tactic: simpa using dist_triangle (v +ᵥ p) (v' +ᵥ p) (v' +ᵥ p')
Theorem: SimpleGraph.edge_adj
File: Mathlib/Combinatorics/SimpleGraph/Operations.lean

Proof steps:
state_before: V : Type u_1
inst✝ : DecidableEq V
G : SimpleGraph V
s t v w : V
⊢ (edge s t).Adj v w ↔ (v = s ∧ w = t ∨ v = t ∧ w = s) ∧ v ≠ w
state_after: no goals
tactic: rw [edge, fromEdgeSet_adj, Set.mem_singleton_iff, Sym2.eq_iff]
Theorem: dvd_mul_of_dvd_right
File: Mathlib/Algebra/Divisibility/Basic.lean

Proof steps:
state_before: α : Type u_1
inst✝ : CommSemigroup α
a b c✝ : α
h : a ∣ b
c : α
⊢ a ∣ c * b
state_after: α : Type u_1
inst✝ : CommSemigroup α
a b c✝ : α
h : a ∣ b
c : α
⊢ a ∣ b * c
tactic: rw [mul_comm]
state_before: α : Type u_1
inst✝ : CommSemigroup α
a b c✝ : α
h : a ∣ b
c : α
⊢ a ∣ b * c
state_after: no goals
tactic: exact h.mul_right _
Theorem: squarefree_iff_no_irreducibles
File: Mathlib/Algebra/Squarefree/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝¹ : CommMonoidWithZero R
inst✝ : WfDvdMonoid R
x : R
hx₀ : x ≠ 0
⊢ Squarefree x ↔ ∀ (p : R), Irreducible p → ¬p * p ∣ x
state_after: R : Type u_1
inst✝¹ : CommMonoidWithZero R
inst✝ : WfDvdMonoid R
x : R
hx₀ : x ≠ 0
h : ∀ (p : R), Irreducible p → ¬p * p ∣ x
d : R
hd : d * d ∣ x
hdu : ¬IsUnit d
⊢ False
tactic: refine ⟨fun h p hp hp' ↦ hp.not_unit (h p hp'), fun h d hd ↦ by_contra fun hdu ↦ ?_⟩
state_before: R : Type u_1
inst✝¹ : CommMonoidWithZero R
inst✝ : WfDvdMonoid R
x : R
hx₀ : x ≠ 0
h : ∀ (p : R), Irreducible p → ¬p * p ∣ x
d : R
hd : d * d ∣ x
hdu : ¬IsUnit d
⊢ False
state_after: R : Type u_1
inst✝¹ : CommMonoidWithZero R
inst✝ : WfDvdMonoid R
x : R
hx₀ : x ≠ 0
h : ∀ (p : R), Irreducible p → ¬p * p ∣ x
d : R
hd : d * d ∣ x
hdu : ¬IsUnit d
hd₀ : d ≠ 0
⊢ False
tactic: have hd₀ : d ≠ 0 := ne_zero_of_dvd_ne_zero (ne_zero_of_dvd_ne_zero hx₀ hd) (dvd_mul_left d d)
state_before: R : Type u_1
inst✝¹ : CommMonoidWithZero R
inst✝ : WfDvdMonoid R
x : R
hx₀ : x ≠ 0
h : ∀ (p : R), Irreducible p → ¬p * p ∣ x
d : R
hd : d * d ∣ x
hdu : ¬IsUnit d
hd₀ : d ≠ 0
⊢ False
state_after: case intro.intro
R : Type u_1
inst✝¹ : CommMonoidWithZero R
inst✝ : WfDvdMonoid R
x : R
hx₀ : x ≠ 0
h : ∀ (p : R), Irreducible p → ¬p * p ∣ x
d : R
hd : d * d ∣ x
hdu : ¬IsUnit d
hd₀ : d ≠ 0
p : R
irr : Irreducible p
dvd : p ∣ d
⊢ False
tactic: obtain ⟨p, irr, dvd⟩ := WfDvdMonoid.exists_irreducible_factor hdu hd₀
state_before: case intro.intro
R : Type u_1
inst✝¹ : CommMonoidWithZero R
inst✝ : WfDvdMonoid R
x : R
hx₀ : x ≠ 0
h : ∀ (p : R), Irreducible p → ¬p * p ∣ x
d : R
hd : d * d ∣ x
hdu : ¬IsUnit d
hd₀ : d ≠ 0
p : R
irr : Irreducible p
dvd : p ∣ d
⊢ False
state_after: no goals
tactic: exact h p irr ((mul_dvd_mul dvd dvd).trans hd)
Theorem: ZMod.val_natCast
File: Mathlib/Data/ZMod/Basic.lean

Proof steps:
state_before: n a : ℕ
⊢ (↑a).val = a % n
state_after: case zero
a : ℕ
⊢ (↑a).val = a % 0

case succ
a n✝ : ℕ
⊢ (↑a).val = a % (n✝ + 1)
tactic: cases n
Theorem: Real.BohrMollerup.f_add_nat_eq
File: Mathlib/Analysis/SpecialFunctions/Gamma/BohrMollerup.lean

Proof steps:
state_before: f : ℝ → ℝ
x : ℝ
n✝ : ℕ
hf_feq : ∀ {y : ℝ}, 0 < y → f (y + 1) = f y + log y
hx : 0 < x
n : ℕ
⊢ f (x + ↑n) = f x + ∑ m ∈ Finset.range n, log (x + ↑m)
state_after: case zero
f : ℝ → ℝ
x : ℝ
n : ℕ
hf_feq : ∀ {y : ℝ}, 0 < y → f (y + 1) = f y + log y
hx : 0 < x
⊢ f (x + ↑0) = f x + ∑ m ∈ Finset.range 0, log (x + ↑m)

case succ
f : ℝ → ℝ
x : ℝ
n✝ : ℕ
hf_feq : ∀ {y : ℝ}, 0 < y → f (y + 1) = f y + log y
hx : 0 < x
n : ℕ
hn : f (x + ↑n) = f x + ∑ m ∈ Finset.range n, log (x + ↑m)
⊢ f (x + ↑(n + 1)) = f x + ∑ m ∈ Finset.range (n + 1), log (x + ↑m)
tactic: induction' n with n hn
Theorem: ProbabilityTheory.variance_mul
File: Mathlib/Probability/Variance.lean

Proof steps:
state_before: Ω : Type u_1
m : MeasurableSpace Ω
X✝ : Ω → ℝ
μ✝ : Measure Ω
c : ℝ
X : Ω → ℝ
μ : Measure Ω
⊢ variance (fun ω => c * X ω) μ = c ^ 2 * variance X μ
state_after: Ω : Type u_1
m : MeasurableSpace Ω
X✝ : Ω → ℝ
μ✝ : Measure Ω
c : ℝ
X : Ω → ℝ
μ : Measure Ω
⊢ c ^ 2 * (evariance X μ).toReal = c ^ 2 * variance X μ
tactic: rw [variance, evariance_mul, ENNReal.toReal_mul, ENNReal.toReal_ofReal (sq_nonneg _)]
state_before: Ω : Type u_1
m : MeasurableSpace Ω
X✝ : Ω → ℝ
μ✝ : Measure Ω
c : ℝ
X : Ω → ℝ
μ : Measure Ω
⊢ c ^ 2 * (evariance X μ).toReal = c ^ 2 * variance X μ
state_after: no goals
tactic: rfl
Theorem: CategoryTheory.Localization.LeftBousfield.W_iff_isIso
File: Mathlib/CategoryTheory/Localization/Bousfield.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝¹ : Category.{u_3, u_1} C
inst✝ : Category.{?u.3920, u_2} D
P : C → Prop
X Y : C
f : X ⟶ Y
hX : P X
hY : P Y
⊢ W P f ↔ IsIso f
state_after: case mp
C : Type u_1
D : Type u_2
inst✝¹ : Category.{u_3, u_1} C
inst✝ : Category.{?u.3920, u_2} D
P : C → Prop
X Y : C
f : X ⟶ Y
hX : P X
hY : P Y
⊢ W P f → IsIso f

case mpr
C : Type u_1
D : Type u_2
inst✝¹ : Category.{u_3, u_1} C
inst✝ : Category.{?u.3920, u_2} D
P : C → Prop
X Y : C
f : X ⟶ Y
hX : P X
hY : P Y
⊢ IsIso f → W P f
tactic: constructor
Theorem: Hindman.FS_iter_tail_sub_FS
File: Mathlib/Combinatorics/Hindman.lean

Proof steps:
state_before: M : Type u_1
inst✝ : Semigroup M
a : Stream' M
n : ℕ
⊢ FP (Stream'.drop n a) ⊆ FP a
state_after: case zero
M : Type u_1
inst✝ : Semigroup M
a : Stream' M
⊢ FP (Stream'.drop 0 a) ⊆ FP a

case succ
M : Type u_1
inst✝ : Semigroup M
a : Stream' M
n : ℕ
ih : FP (Stream'.drop n a) ⊆ FP a
⊢ FP (Stream'.drop (n + 1) a) ⊆ FP a
tactic: induction' n with n ih
state_before: case succ
M : Type u_1
inst✝ : Semigroup M
a : Stream' M
n : ℕ
ih : FP (Stream'.drop n a) ⊆ FP a
⊢ FP (Stream'.drop (n + 1) a) ⊆ FP a
state_after: case succ
M : Type u_1
inst✝ : Semigroup M
a : Stream' M
n : ℕ
ih : FP (Stream'.drop n a) ⊆ FP a
⊢ FP (Stream'.drop 1 (Stream'.drop n a)) ⊆ FP a
tactic: rw [Nat.add_comm, ← Stream'.drop_drop]
state_before: case succ
M : Type u_1
inst✝ : Semigroup M
a : Stream' M
n : ℕ
ih : FP (Stream'.drop n a) ⊆ FP a
⊢ FP (Stream'.drop 1 (Stream'.drop n a)) ⊆ FP a
state_after: no goals
tactic: exact _root_.trans (FP.tail _) ih
Theorem: Cardinal.sInf_eq_zero_iff
File: Mathlib/SetTheory/Cardinal/Basic.lean

Proof steps:
state_before: α β : Type u
s : Set Cardinal.{u_1}
⊢ sInf s = 0 ↔ s = ∅ ∨ ∃ a ∈ s, a = 0
state_after: case refine_1
α β : Type u
s : Set Cardinal.{u_1}
h : sInf s = 0
⊢ s = ∅ ∨ ∃ a ∈ s, a = 0

case refine_2
α β : Type u
s : Set Cardinal.{u_1}
h : s = ∅ ∨ ∃ a ∈ s, a = 0
⊢ sInf s = 0
tactic: refine ⟨fun h ↦ ?_, fun h ↦ ?_⟩
Theorem: IsConformalMap.ne_zero
File: Mathlib/Analysis/NormedSpace/ConformalLinearMap.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
N : Type u_3
G : Type u_4
M' : Type u_5
inst✝⁹ : NormedField R
inst✝⁸ : SeminormedAddCommGroup M
inst✝⁷ : SeminormedAddCommGroup N
inst✝⁶ : SeminormedAddCommGroup G
inst✝⁵ : NormedSpace R M
inst✝⁴ : NormedSpace R N
inst✝³ : NormedSpace R G
inst✝² : NormedAddCommGroup M'
inst✝¹ : NormedSpace R M'
f : M →L[R] N
g : N →L[R] G
c : R
inst✝ : Nontrivial M'
f' : M' →L[R] N
hf' : IsConformalMap f'
⊢ f' ≠ 0
state_after: R : Type u_1
M : Type u_2
N : Type u_3
G : Type u_4
M' : Type u_5
inst✝⁹ : NormedField R
inst✝⁸ : SeminormedAddCommGroup M
inst✝⁷ : SeminormedAddCommGroup N
inst✝⁶ : SeminormedAddCommGroup G
inst✝⁵ : NormedSpace R M
inst✝⁴ : NormedSpace R N
inst✝³ : NormedSpace R G
inst✝² : NormedAddCommGroup M'
inst✝¹ : NormedSpace R M'
f : M →L[R] N
g : N →L[R] G
c : R
inst✝ : Nontrivial M'
hf' : IsConformalMap 0
⊢ False
tactic: rintro rfl
state_before: R : Type u_1
M : Type u_2
N : Type u_3
G : Type u_4
M' : Type u_5
inst✝⁹ : NormedField R
inst✝⁸ : SeminormedAddCommGroup M
inst✝⁷ : SeminormedAddCommGroup N
inst✝⁶ : SeminormedAddCommGroup G
inst✝⁵ : NormedSpace R M
inst✝⁴ : NormedSpace R N
inst✝³ : NormedSpace R G
inst✝² : NormedAddCommGroup M'
inst✝¹ : NormedSpace R M'
f : M →L[R] N
g : N →L[R] G
c : R
inst✝ : Nontrivial M'
hf' : IsConformalMap 0
⊢ False
state_after: case intro
R : Type u_1
M : Type u_2
N : Type u_3
G : Type u_4
M' : Type u_5
inst✝⁹ : NormedField R
inst✝⁸ : SeminormedAddCommGroup M
inst✝⁷ : SeminormedAddCommGroup N
inst✝⁶ : SeminormedAddCommGroup G
inst✝⁵ : NormedSpace R M
inst✝⁴ : NormedSpace R N
inst✝³ : NormedSpace R G
inst✝² : NormedAddCommGroup M'
inst✝¹ : NormedSpace R M'
f : M →L[R] N
g : N →L[R] G
c : R
inst✝ : Nontrivial M'
hf' : IsConformalMap 0
a : M'
ha : a ≠ 0
⊢ False
tactic: rcases exists_ne (0 : M') with ⟨a, ha⟩
state_before: case intro
R : Type u_1
M : Type u_2
N : Type u_3
G : Type u_4
M' : Type u_5
inst✝⁹ : NormedField R
inst✝⁸ : SeminormedAddCommGroup M
inst✝⁷ : SeminormedAddCommGroup N
inst✝⁶ : SeminormedAddCommGroup G
inst✝⁵ : NormedSpace R M
inst✝⁴ : NormedSpace R N
inst✝³ : NormedSpace R G
inst✝² : NormedAddCommGroup M'
inst✝¹ : NormedSpace R M'
f : M →L[R] N
g : N →L[R] G
c : R
inst✝ : Nontrivial M'
hf' : IsConformalMap 0
a : M'
ha : a ≠ 0
⊢ False
state_after: no goals
tactic: exact ha (hf'.injective rfl)
Theorem: addOrderOf_dvd_iff_zsmul_eq_zero
File: Mathlib/GroupTheory/OrderOfElement.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Group G
x y : G
i : ℤ
⊢ ↑(orderOf x) ∣ i ↔ x ^ i = 1
state_after: case intro.inl
G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Group G
x y : G
i : ℕ
⊢ ↑(orderOf x) ∣ ↑i ↔ x ^ ↑i = 1

case intro.inr
G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Group G
x y : G
i : ℕ
⊢ ↑(orderOf x) ∣ -↑i ↔ x ^ (-↑i) = 1
tactic: rcases Int.eq_nat_or_neg i with ⟨i, rfl | rfl⟩
Theorem: CategoryTheory.ComposableArrows.isoMk₃_hom
File: Mathlib/CategoryTheory/ComposableArrows.lean

Proof steps:
state_before: C : Type u_1
inst✝ : Category.{?u.256266, u_1} C
n m : ℕ
F G : ComposableArrows C n
f g : ComposableArrows C 3
app₀ : f.obj' 0 ⋯ ≅ g.obj' 0 ⋯
app₁ : f.obj' 1 ⋯ ≅ g.obj' 1 ⋯
app₂ : f.obj' 2 ⋯ ≅ g.obj' 2 ⋯
app₃ : f.obj' 3 ⋯ ≅ g.obj' 3 ⋯
w₀ : f.map' 0 1 ⋯ ⋯ ≫ app₁.hom = app₀.hom ≫ g.map' 0 1 ⋯ ⋯
w₁ : f.map' 1 2 ⋯ ⋯ ≫ app₂.hom = app₁.hom ≫ g.map' 1 2 ⋯ ⋯
w₂ : f.map' 2 3 ⋯ ⋯ ≫ app₃.hom = app₂.hom ≫ g.map' 2 3 ⋯ ⋯
⊢ g.map' 0 1 ⋯ ⋯ ≫ app₁.inv = app₀.inv ≫ f.map' 0 1 ⋯ ⋯
state_after: no goals
tactic: rw [← cancel_epi app₀.hom, ← reassoc_of% w₀, app₁.hom_inv_id,
      comp_id, app₀.hom_inv_id_assoc]
state_before: C : Type u_1
inst✝ : Category.{?u.256266, u_1} C
n m : ℕ
F G : ComposableArrows C n
f g : ComposableArrows C 3
app₀ : f.obj' 0 ⋯ ≅ g.obj' 0 ⋯
app₁ : f.obj' 1 ⋯ ≅ g.obj' 1 ⋯
app₂ : f.obj' 2 ⋯ ≅ g.obj' 2 ⋯
app₃ : f.obj' 3 ⋯ ≅ g.obj' 3 ⋯
w₀ : f.map' 0 1 ⋯ ⋯ ≫ app₁.hom = app₀.hom ≫ g.map' 0 1 ⋯ ⋯
w₁ : f.map' 1 2 ⋯ ⋯ ≫ app₂.hom = app₁.hom ≫ g.map' 1 2 ⋯ ⋯
w₂ : f.map' 2 3 ⋯ ⋯ ≫ app₃.hom = app₂.hom ≫ g.map' 2 3 ⋯ ⋯
⊢ g.map' 1 2 ⋯ ⋯ ≫ app₂.inv = app₁.inv ≫ f.map' 1 2 ⋯ ⋯
state_after: no goals
tactic: rw [← cancel_epi app₁.hom, ← reassoc_of% w₁, app₂.hom_inv_id,
      comp_id, app₁.hom_inv_id_assoc]
state_before: C : Type u_1
inst✝ : Category.{?u.256266, u_1} C
n m : ℕ
F G : ComposableArrows C n
f g : ComposableArrows C 3
app₀ : f.obj' 0 ⋯ ≅ g.obj' 0 ⋯
app₁ : f.obj' 1 ⋯ ≅ g.obj' 1 ⋯
app₂ : f.obj' 2 ⋯ ≅ g.obj' 2 ⋯
app₃ : f.obj' 3 ⋯ ≅ g.obj' 3 ⋯
w₀ : f.map' 0 1 ⋯ ⋯ ≫ app₁.hom = app₀.hom ≫ g.map' 0 1 ⋯ ⋯
w₁ : f.map' 1 2 ⋯ ⋯ ≫ app₂.hom = app₁.hom ≫ g.map' 1 2 ⋯ ⋯
w₂ : f.map' 2 3 ⋯ ⋯ ≫ app₃.hom = app₂.hom ≫ g.map' 2 3 ⋯ ⋯
⊢ g.map' 2 3 ⋯ ⋯ ≫ app₃.inv = app₂.inv ≫ f.map' 2 3 ⋯ ⋯
state_after: no goals
tactic: rw [← cancel_epi app₂.hom, ← reassoc_of% w₂, app₃.hom_inv_id,
      comp_id, app₂.hom_inv_id_assoc]
Theorem: PNat.Coprime.gcd_mul_left_cancel_right
File: Mathlib/Data/PNat/Prime.lean

Proof steps:
state_before: m n k : ℕ+
⊢ k.Coprime m → m.gcd (k * n) = m.gcd n
state_after: m n k : ℕ+
h : k.Coprime m
⊢ m.gcd (k * n) = m.gcd n
tactic: intro h
state_before: m n k : ℕ+
h : k.Coprime m
⊢ m.gcd (k * n) = m.gcd n
state_after: m n k : ℕ+
h : k.Coprime m
⊢ (k * n).gcd m = n.gcd m
tactic: iterate 2 rw [gcd_comm]; symm
state_before: m n k : ℕ+
h : k.Coprime m
⊢ (k * n).gcd m = n.gcd m
state_after: no goals
tactic: apply Coprime.gcd_mul_left_cancel _ h
Theorem: Surreal.dyadic_aux
File: Mathlib/SetTheory/Surreal/Dyadic.lean

Proof steps:
state_before: m₁ m₂ : ℤ
y₁ y₂ : ℕ
h₂ : m₁ * 2 ^ y₁ = m₂ * 2 ^ y₂
⊢ ↑m₁ * powHalf y₂ = ↑m₂ * powHalf y₁
state_after: y₁ y₂ : ℕ
⊢ ∀ {m₁ m₂ : ℤ}, m₁ * 2 ^ y₁ = m₂ * 2 ^ y₂ → ↑m₁ * powHalf y₂ = ↑m₂ * powHalf y₁
tactic: revert m₁ m₂
state_before: y₁ y₂ : ℕ
⊢ ∀ {m₁ m₂ : ℤ}, m₁ * 2 ^ y₁ = m₂ * 2 ^ y₂ → ↑m₁ * powHalf y₂ = ↑m₂ * powHalf y₁
state_after: case inr
y₁ y₂ : ℕ
this : ∀ {y₁ y₂ : ℕ}, y₁ ≤ y₂ → ∀ {m₁ m₂ : ℤ}, m₁ * 2 ^ y₁ = m₂ * 2 ^ y₂ → ↑m₁ * powHalf y₂ = ↑m₂ * powHalf y₁
h : ¬y₁ ≤ y₂
⊢ ∀ {m₁ m₂ : ℤ}, m₁ * 2 ^ y₁ = m₂ * 2 ^ y₂ → ↑m₁ * powHalf y₂ = ↑m₂ * powHalf y₁

y₁ y₂ : ℕ
h : y₁ ≤ y₂
⊢ ∀ {m₁ m₂ : ℤ}, m₁ * 2 ^ y₁ = m₂ * 2 ^ y₂ → ↑m₁ * powHalf y₂ = ↑m₂ * powHalf y₁
tactic: wlog h : y₁ ≤ y₂
state_before: y₁ y₂ : ℕ
h : y₁ ≤ y₂
⊢ ∀ {m₁ m₂ : ℤ}, m₁ * 2 ^ y₁ = m₂ * 2 ^ y₂ → ↑m₁ * powHalf y₂ = ↑m₂ * powHalf y₁
state_after: y₁ y₂ : ℕ
h : y₁ ≤ y₂
m₁ m₂ : ℤ
h₂ : m₁ * 2 ^ y₁ = m₂ * 2 ^ y₂
⊢ ↑m₁ * powHalf y₂ = ↑m₂ * powHalf y₁
tactic: intro m₁ m₂ h₂
state_before: y₁ y₂ : ℕ
h : y₁ ≤ y₂
m₁ m₂ : ℤ
h₂ : m₁ * 2 ^ y₁ = m₂ * 2 ^ y₂
⊢ ↑m₁ * powHalf y₂ = ↑m₂ * powHalf y₁
state_after: case intro
y₁ : ℕ
m₁ m₂ : ℤ
c : ℕ
h : y₁ ≤ y₁ + c
h₂ : m₁ * 2 ^ y₁ = m₂ * 2 ^ (y₁ + c)
⊢ ↑m₁ * powHalf (y₁ + c) = ↑m₂ * powHalf y₁
tactic: obtain ⟨c, rfl⟩ := le_iff_exists_add.mp h
state_before: case intro
y₁ : ℕ
m₁ m₂ : ℤ
c : ℕ
h : y₁ ≤ y₁ + c
h₂ : m₁ * 2 ^ y₁ = m₂ * 2 ^ (y₁ + c)
⊢ ↑m₁ * powHalf (y₁ + c) = ↑m₂ * powHalf y₁
state_after: case intro
y₁ : ℕ
m₁ m₂ : ℤ
c : ℕ
h : y₁ ≤ y₁ + c
h₂ : m₁ = m₂ * 2 ^ c ∨ 2 ^ y₁ = 0
⊢ ↑m₁ * powHalf (y₁ + c) = ↑m₂ * powHalf y₁
tactic: rw [add_comm, pow_add, ← mul_assoc, mul_eq_mul_right_iff] at h₂
state_before: case intro
y₁ : ℕ
m₁ m₂ : ℤ
c : ℕ
h : y₁ ≤ y₁ + c
h₂ : m₁ = m₂ * 2 ^ c ∨ 2 ^ y₁ = 0
⊢ ↑m₁ * powHalf (y₁ + c) = ↑m₂ * powHalf y₁
state_after: case intro.inl
y₁ : ℕ
m₁ m₂ : ℤ
c : ℕ
h : y₁ ≤ y₁ + c
h₂ : m₁ = m₂ * 2 ^ c
⊢ ↑m₁ * powHalf (y₁ + c) = ↑m₂ * powHalf y₁

case intro.inr
y₁ : ℕ
m₁ m₂ : ℤ
c : ℕ
h : y₁ ≤ y₁ + c
h₂ : 2 ^ y₁ = 0
⊢ ↑m₁ * powHalf (y₁ + c) = ↑m₂ * powHalf y₁
tactic: cases' h₂ with h₂ h₂
Theorem: IsClosed.exists_nat_bool_injection_of_not_countable
File: Mathlib/Topology/MetricSpace/Perfect.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : TopologicalSpace α
inst✝ : PolishSpace α
C : Set α
hC : IsClosed C
hunc : ¬C.Countable
⊢ ∃ f, range f ⊆ C ∧ Continuous f ∧ Function.Injective f
state_after: α : Type u_1
inst✝¹ : TopologicalSpace α
inst✝ : PolishSpace α
C : Set α
hC : IsClosed C
hunc : ¬C.Countable
this : UpgradedPolishSpace α := upgradePolishSpace α
⊢ ∃ f, range f ⊆ C ∧ Continuous f ∧ Function.Injective f
tactic: letI := upgradePolishSpace α
state_before: α : Type u_1
inst✝¹ : TopologicalSpace α
inst✝ : PolishSpace α
C : Set α
hC : IsClosed C
hunc : ¬C.Countable
this : UpgradedPolishSpace α := upgradePolishSpace α
⊢ ∃ f, range f ⊆ C ∧ Continuous f ∧ Function.Injective f
state_after: case intro.intro.intro
α : Type u_1
inst✝¹ : TopologicalSpace α
inst✝ : PolishSpace α
C : Set α
hC : IsClosed C
hunc : ¬C.Countable
this : UpgradedPolishSpace α := upgradePolishSpace α
D : Set α
hD : Perfect D
Dnonempty : D.Nonempty
hDC : D ⊆ C
⊢ ∃ f, range f ⊆ C ∧ Continuous f ∧ Function.Injective f
tactic: obtain ⟨D, hD, Dnonempty, hDC⟩ := exists_perfect_nonempty_of_isClosed_of_not_countable hC hunc
state_before: case intro.intro.intro
α : Type u_1
inst✝¹ : TopologicalSpace α
inst✝ : PolishSpace α
C : Set α
hC : IsClosed C
hunc : ¬C.Countable
this : UpgradedPolishSpace α := upgradePolishSpace α
D : Set α
hD : Perfect D
Dnonempty : D.Nonempty
hDC : D ⊆ C
⊢ ∃ f, range f ⊆ C ∧ Continuous f ∧ Function.Injective f
state_after: case intro.intro.intro.intro.intro
α : Type u_1
inst✝¹ : TopologicalSpace α
inst✝ : PolishSpace α
C : Set α
hC : IsClosed C
hunc : ¬C.Countable
this : UpgradedPolishSpace α := upgradePolishSpace α
D : Set α
hD : Perfect D
Dnonempty : D.Nonempty
hDC : D ⊆ C
f : (ℕ → Bool) → α
hfD : range f ⊆ D
hf : Continuous f ∧ Function.Injective f
⊢ ∃ f, range f ⊆ C ∧ Continuous f ∧ Function.Injective f
tactic: obtain ⟨f, hfD, hf⟩ := hD.exists_nat_bool_injection Dnonempty
state_before: case intro.intro.intro.intro.intro
α : Type u_1
inst✝¹ : TopologicalSpace α
inst✝ : PolishSpace α
C : Set α
hC : IsClosed C
hunc : ¬C.Countable
this : UpgradedPolishSpace α := upgradePolishSpace α
D : Set α
hD : Perfect D
Dnonempty : D.Nonempty
hDC : D ⊆ C
f : (ℕ → Bool) → α
hfD : range f ⊆ D
hf : Continuous f ∧ Function.Injective f
⊢ ∃ f, range f ⊆ C ∧ Continuous f ∧ Function.Injective f
state_after: no goals
tactic: exact ⟨f, hfD.trans hDC, hf⟩
Theorem: List.eraseIdx_append_of_length_le
File: .lake/packages/batteries/Batteries/Data/List/EraseIdx.lean

Proof steps:
state_before: α : Type u
β : Type v
l : List α
k : Nat
hk : l.length ≤ k
l' : List α
⊢ (l ++ l').eraseIdx k = l ++ l'.eraseIdx (k - l.length)
state_after: α : Type u
β : Type v
l : List α
k : Nat
hk : l.length ≤ k
l' : List α
⊢ l ++ (take (k - l.length) l' ++ drop (k + 1 - l.length) l') =
    l ++ (take (k - l.length) l' ++ drop (k - l.length + 1) l')
tactic: rw [eraseIdx_eq_take_drop_succ, eraseIdx_eq_take_drop_succ,
    take_append_eq_append_take, drop_append_eq_append_drop,
    take_all_of_le hk, drop_eq_nil_of_le (by omega), nil_append, append_assoc]
state_before: α : Type u
β : Type v
l : List α
k : Nat
hk : l.length ≤ k
l' : List α
⊢ l ++ (take (k - l.length) l' ++ drop (k + 1 - l.length) l') =
    l ++ (take (k - l.length) l' ++ drop (k - l.length + 1) l')
state_after: case e_a.e_a.e_a
α : Type u
β : Type v
l : List α
k : Nat
hk : l.length ≤ k
l' : List α
⊢ k + 1 - l.length = k - l.length + 1
tactic: congr
state_before: case e_a.e_a.e_a
α : Type u
β : Type v
l : List α
k : Nat
hk : l.length ≤ k
l' : List α
⊢ k + 1 - l.length = k - l.length + 1
state_after: no goals
tactic: omega
Theorem: lipschitzOnWith_restrict
File: Mathlib/Topology/EMetricSpace/Lipschitz.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
K : ℝ≥0
s t✝ : Set α
f : α → β
t : Set ↑s
⊢ LipschitzOnWith K (s.restrict f) t ↔ LipschitzOnWith K f (s ∩ Subtype.val '' t)
state_after: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
K : ℝ≥0
s t✝ : Set α
f : α → β
t : Set ↑s
⊢ (∀ (a : α) (b : a ∈ s),
      ⟨a, b⟩ ∈ t → ∀ (a_2 : α) (b : a_2 ∈ s), ⟨a_2, b⟩ ∈ t → edist (f a) (f a_2) ≤ ↑K * edist a a_2) ↔
    ∀ ⦃x : α⦄, x ∈ s ∩ Subtype.val '' t → ∀ ⦃y : α⦄, y ∈ s ∩ Subtype.val '' t → edist (f x) (f y) ≤ ↑K * edist x y
tactic: simp only [LipschitzOnWith, LipschitzWith, Subtype.forall, restrict, Subtype.edist_eq]
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
K : ℝ≥0
s t✝ : Set α
f : α → β
t : Set ↑s
⊢ (∀ (a : α) (b : a ∈ s),
      ⟨a, b⟩ ∈ t → ∀ (a_2 : α) (b : a_2 ∈ s), ⟨a_2, b⟩ ∈ t → edist (f a) (f a_2) ≤ ↑K * edist a a_2) ↔
    ∀ ⦃x : α⦄, x ∈ s ∩ Subtype.val '' t → ∀ ⦃y : α⦄, y ∈ s ∩ Subtype.val '' t → edist (f x) (f y) ≤ ↑K * edist x y
state_after: no goals
tactic: aesop
Theorem: CategoryTheory.topologyOfClosureOperator_close
File: Mathlib/CategoryTheory/Sites/Closed.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
J₁ J₂ : GrothendieckTopology C
c : (X : C) → ClosureOperator (Sieve X)
pb : ∀ ⦃X Y : C⦄ (f : Y ⟶ X) (S : Sieve X), (c Y) (Sieve.pullback f S) = Sieve.pullback f ((c X) S)
X : C
S : Sieve X
⊢ (topologyOfClosureOperator c pb).close S = (c X) S
state_after: case h
C : Type u
inst✝ : Category.{v, u} C
J₁ J₂ : GrothendieckTopology C
c : (X : C) → ClosureOperator (Sieve X)
pb : ∀ ⦃X Y : C⦄ (f : Y ⟶ X) (S : Sieve X), (c Y) (Sieve.pullback f S) = Sieve.pullback f ((c X) S)
X : C
S : Sieve X
Y : C
f : Y ⟶ X
⊢ ((topologyOfClosureOperator c pb).close S).arrows f ↔ ((c X) S).arrows f
tactic: ext Y f
state_before: case h
C : Type u
inst✝ : Category.{v, u} C
J₁ J₂ : GrothendieckTopology C
c : (X : C) → ClosureOperator (Sieve X)
pb : ∀ ⦃X Y : C⦄ (f : Y ⟶ X) (S : Sieve X), (c Y) (Sieve.pullback f S) = Sieve.pullback f ((c X) S)
X : C
S : Sieve X
Y : C
f : Y ⟶ X
⊢ ((topologyOfClosureOperator c pb).close S).arrows f ↔ ((c X) S).arrows f
state_after: case h
C : Type u
inst✝ : Category.{v, u} C
J₁ J₂ : GrothendieckTopology C
c : (X : C) → ClosureOperator (Sieve X)
pb : ∀ ⦃X Y : C⦄ (f : Y ⟶ X) (S : Sieve X), (c Y) (Sieve.pullback f S) = Sieve.pullback f ((c X) S)
X : C
S : Sieve X
Y : C
f : Y ⟶ X
⊢ (c Y) (Sieve.pullback f S) = ⊤ ↔ ((c X) S).arrows f
tactic: change c _ (Sieve.pullback f S) = ⊤ ↔ c _ S f
state_before: case h
C : Type u
inst✝ : Category.{v, u} C
J₁ J₂ : GrothendieckTopology C
c : (X : C) → ClosureOperator (Sieve X)
pb : ∀ ⦃X Y : C⦄ (f : Y ⟶ X) (S : Sieve X), (c Y) (Sieve.pullback f S) = Sieve.pullback f ((c X) S)
X : C
S : Sieve X
Y : C
f : Y ⟶ X
⊢ (c Y) (Sieve.pullback f S) = ⊤ ↔ ((c X) S).arrows f
state_after: no goals
tactic: rw [pb, Sieve.pullback_eq_top_iff_mem]
Theorem: ContinuousMultilinearMap.unit_le_opNorm
File: Mathlib/Analysis/NormedSpace/Multilinear/Basic.lean

Proof steps:
state_before: 𝕜 : Type u
ι : Type v
ι' : Type v'
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
G : Type wG
G' : Type wG'
inst✝¹² : Fintype ι
inst✝¹¹ : Fintype ι'
inst✝¹⁰ : NontriviallyNormedField 𝕜
inst✝⁹ : (i : ι) → SeminormedAddCommGroup (E i)
inst✝⁸ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝⁷ : (i : ι) → SeminormedAddCommGroup (E₁ i)
inst✝⁶ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁵ : (i : ι') → SeminormedAddCommGroup (E' i)
inst✝⁴ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝³ : SeminormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : SeminormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
c : 𝕜
f g : ContinuousMultilinearMap 𝕜 E G
m : (i : ι) → E i
h : ‖m‖ ≤ 1
⊢ ‖f‖ * 1 ^ Fintype.card ι ≤ ‖f‖
state_after: no goals
tactic: simp
Theorem: CategoryTheory.id_of_comp_left_id
File: Mathlib/CategoryTheory/Category/Basic.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y Z : C
f : X ⟶ X
w : ∀ {Y : C} (g : X ⟶ Y), f ≫ g = g
⊢ f = 𝟙 X
state_after: case h.e'_2
C : Type u
inst✝ : Category.{v, u} C
X Y Z : C
f : X ⟶ X
w : ∀ {Y : C} (g : X ⟶ Y), f ≫ g = g
⊢ f = f ≫ 𝟙 X
tactic: convert w (𝟙 X)
state_before: case h.e'_2
C : Type u
inst✝ : Category.{v, u} C
X Y Z : C
f : X ⟶ X
w : ∀ {Y : C} (g : X ⟶ Y), f ≫ g = g
⊢ f = f ≫ 𝟙 X
state_after: no goals
tactic: simp
Theorem: inv_antitoneOn_Iio
File: Mathlib/Algebra/Order/Field/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
⊢ AntitoneOn (fun x => x⁻¹) (Set.Iio 0)
state_after: case h.e'_5.h.h.e'_3
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
x✝ : α
⊢ x✝ = x✝ - 0
tactic: convert sub_inv_antitoneOn_Iio
state_before: case h.e'_5.h.h.e'_3
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
x✝ : α
⊢ x✝ = x✝ - 0
state_after: no goals
tactic: exact (sub_zero _).symm