ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Finset.sup_image₂_left
File: Mathlib/Data/Finset/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
inst✝⁹ : DecidableEq α'
inst✝⁸ : DecidableEq β'
inst✝⁷ : DecidableEq γ
inst✝⁶ : DecidableEq γ'
inst✝⁵ : DecidableEq δ
inst✝⁴ : DecidableEq δ'
inst✝³ : DecidableEq ε
inst✝² : DecidableEq ε'
f f' : α → β → γ
g✝ g' : α → β → γ → δ
s s' : Finset α
t t' : Finset β
u u' : Finset γ
a a' : α
b b' : β
c : γ
inst✝¹ : SemilatticeSup δ
inst✝ : OrderBot δ
g : γ → δ
⊢ (image₂ f s t).sup g = s.sup fun x => t.sup fun x_1 => g (f x x_1)
state_after: α : 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
inst✝⁹ : DecidableEq α'
inst✝⁸ : DecidableEq β'
inst✝⁷ : DecidableEq γ
inst✝⁶ : DecidableEq γ'
inst✝⁵ : DecidableEq δ
inst✝⁴ : DecidableEq δ'
inst✝³ : DecidableEq ε
inst✝² : DecidableEq ε'
f f' : α → β → γ
g✝ g' : α → β → γ → δ
s s' : Finset α
t t' : Finset β
u u' : Finset γ
a a' : α
b b' : β
c : γ
inst✝¹ : SemilatticeSup δ
inst✝ : OrderBot δ
g : γ → δ
⊢ (s.sup fun i => t.sup fun i' => (g ∘ uncurry f) (i, i')) = s.sup fun x => t.sup fun x_1 => g (f x x_1)
tactic: simp only [image₂, sup_image, sup_product_left]
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
inst✝⁹ : DecidableEq α'
inst✝⁸ : DecidableEq β'
inst✝⁷ : DecidableEq γ
inst✝⁶ : DecidableEq γ'
inst✝⁵ : DecidableEq δ
inst✝⁴ : DecidableEq δ'
inst✝³ : DecidableEq ε
inst✝² : DecidableEq ε'
f f' : α → β → γ
g✝ g' : α → β → γ → δ
s s' : Finset α
t t' : Finset β
u u' : Finset γ
a a' : α
b b' : β
c : γ
inst✝¹ : SemilatticeSup δ
inst✝ : OrderBot δ
g : γ → δ
⊢ (s.sup fun i => t.sup fun i' => (g ∘ uncurry f) (i, i')) = s.sup fun x => t.sup fun x_1 => g (f x x_1)
state_after: no goals
tactic: rfl
Theorem: Complex.abs_le_abs_of_mapsTo_ball_self
File: Mathlib/Analysis/Complex/Schwarz.lean

Proof steps:
state_before: f : ℂ → ℂ
c z : ℂ
R R₁ R₂ : ℝ
hd : DifferentiableOn ℂ f (ball 0 R)
h_maps : MapsTo f (ball 0 R) (ball 0 R)
h₀ : f 0 = 0
hz : abs z < R
⊢ abs (f z) ≤ abs z
state_after: f : ℂ → ℂ
c z : ℂ
R R₁ R₂ : ℝ
hd : DifferentiableOn ℂ f (ball 0 R)
h_maps : MapsTo f (ball 0 R) (ball 0 R)
h₀ : f 0 = 0
hz : z ∈ ball 0 R
⊢ abs (f z) ≤ abs z
tactic: replace hz : z ∈ ball (0 : ℂ) R := mem_ball_zero_iff.2 hz
state_before: f : ℂ → ℂ
c z : ℂ
R R₁ R₂ : ℝ
hd : DifferentiableOn ℂ f (ball 0 R)
h_maps : MapsTo f (ball 0 R) (ball 0 R)
h₀ : f 0 = 0
hz : z ∈ ball 0 R
⊢ abs (f z) ≤ abs z
state_after: no goals
tactic: simpa only [dist_zero_right] using dist_le_dist_of_mapsTo_ball_self hd h_maps h₀ hz
Theorem: ZMod.exists_sq_eq_two_iff
File: Mathlib/NumberTheory/LegendreSymbol/QuadraticReciprocity.lean

Proof steps:
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
hp : p ≠ 2
⊢ IsSquare 2 ↔ p % 8 = 1 ∨ p % 8 = 7
state_after: p : ℕ
inst✝ : Fact (Nat.Prime p)
hp : p ≠ 2
⊢ p % 8 ≠ 3 ∧ p % 8 ≠ 5 ↔ p % 8 = 1 ∨ p % 8 = 7
tactic: rw [FiniteField.isSquare_two_iff, card p]
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
hp : p ≠ 2
⊢ p % 8 ≠ 3 ∧ p % 8 ≠ 5 ↔ p % 8 = 1 ∨ p % 8 = 7
state_after: p : ℕ
inst✝ : Fact (Nat.Prime p)
hp : p ≠ 2
h₁ : p % 2 = 1
⊢ p % 8 ≠ 3 ∧ p % 8 ≠ 5 ↔ p % 8 = 1 ∨ p % 8 = 7
tactic: have h₁ := Prime.mod_two_eq_one_iff_ne_two.mpr hp
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
hp : p ≠ 2
h₁ : p % 2 = 1
⊢ p % 8 ≠ 3 ∧ p % 8 ≠ 5 ↔ p % 8 = 1 ∨ p % 8 = 7
state_after: p : ℕ
inst✝ : Fact (Nat.Prime p)
hp : p ≠ 2
h₁ : p % 8 % 2 = 1
⊢ p % 8 ≠ 3 ∧ p % 8 ≠ 5 ↔ p % 8 = 1 ∨ p % 8 = 7
tactic: rw [← mod_mod_of_dvd p (by decide : 2 ∣ 8)] at h₁
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
hp : p ≠ 2
h₁ : p % 8 % 2 = 1
⊢ p % 8 ≠ 3 ∧ p % 8 ≠ 5 ↔ p % 8 = 1 ∨ p % 8 = 7
state_after: p : ℕ
inst✝ : Fact (Nat.Prime p)
hp : p ≠ 2
h₁ : p % 8 % 2 = 1
h₂ : p % 8 < 8
⊢ p % 8 ≠ 3 ∧ p % 8 ≠ 5 ↔ p % 8 = 1 ∨ p % 8 = 7
tactic: have h₂ := mod_lt p (by norm_num : 0 < 8)
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
hp : p ≠ 2
h₁ : p % 8 % 2 = 1
h₂ : p % 8 < 8
⊢ p % 8 ≠ 3 ∧ p % 8 ≠ 5 ↔ p % 8 = 1 ∨ p % 8 = 7
state_after: p : ℕ
inst✝ : Fact (Nat.Prime p)
hp : p ≠ 2
⊢ p % 8 % 2 = 1 → p % 8 < 8 → (p % 8 ≠ 3 ∧ p % 8 ≠ 5 ↔ p % 8 = 1 ∨ p % 8 = 7)
tactic: revert h₂ h₁
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
hp : p ≠ 2
⊢ p % 8 % 2 = 1 → p % 8 < 8 → (p % 8 ≠ 3 ∧ p % 8 ≠ 5 ↔ p % 8 = 1 ∨ p % 8 = 7)
state_after: p : ℕ
inst✝ : Fact (Nat.Prime p)
hp : p ≠ 2
m : ℕ
⊢ m % 2 = 1 → m < 8 → (m ≠ 3 ∧ m ≠ 5 ↔ m = 1 ∨ m = 7)
tactic: generalize p % 8 = m
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
hp : p ≠ 2
m : ℕ
⊢ m % 2 = 1 → m < 8 → (m ≠ 3 ∧ m ≠ 5 ↔ m = 1 ∨ m = 7)
state_after: m : ℕ
⊢ m % 2 = 1 → m < 8 → (m ≠ 3 ∧ m ≠ 5 ↔ m = 1 ∨ m = 7)
tactic: clear! p
state_before: m : ℕ
⊢ m % 2 = 1 → m < 8 → (m ≠ 3 ∧ m ≠ 5 ↔ m = 1 ∨ m = 7)
state_after: m : ℕ
h₁✝ : m % 2 = 1
h₂✝ : m < 8
⊢ m ≠ 3 ∧ m ≠ 5 ↔ m = 1 ∨ m = 7
tactic: intros
state_before: m : ℕ
h₁✝ : m % 2 = 1
h₂✝ : m < 8
⊢ m ≠ 3 ∧ m ≠ 5 ↔ m = 1 ∨ m = 7
state_after: no goals
tactic: interval_cases m <;> simp_all
Theorem: Filter.ext_iff
File: Mathlib/Order/Filter/Basic.lean

Proof steps:
state_before: α : Type u
f g : Filter α
s t : Set α
⊢ f = g → ∀ (s : Set α), s ∈ f ↔ s ∈ g
state_after: α : Type u
f : Filter α
s✝ t s : Set α
⊢ s ∈ f ↔ s ∈ f
tactic: rintro rfl s
state_before: α : Type u
f : Filter α
s✝ t s : Set α
⊢ s ∈ f ↔ s ∈ f
state_after: no goals
tactic: rfl
Theorem: Real.exists_rat_eq_convergent'
File: Mathlib/NumberTheory/DiophantineApproximation.lean

Proof steps:
state_before: ξ : ℝ
u v✝ : ℤ
hv : 2 ≤ v✝
h : ContfracLegendre.Ass ξ u v✝
v : ℕ
h' : ContfracLegendre.Ass ξ u ↑v
⊢ ∃ n, ↑u / ↑v = ξ.convergent n
state_after: ξ : ℝ
u v✝ : ℤ
hv : 2 ≤ v✝
v : ℕ
h' : ContfracLegendre.Ass ξ u ↑v
⊢ ∃ n, ↑u / ↑v = ξ.convergent n
tactic: clear h
state_before: ξ : ℝ
u v✝ : ℤ
hv : 2 ≤ v✝
v : ℕ
h' : ContfracLegendre.Ass ξ u ↑v
⊢ ∃ n, ↑u / ↑v = ξ.convergent n
state_after: ξ : ℝ
u v✝ : ℤ
hv : 2 ≤ v✝
v : ℕ
h' h : ContfracLegendre.Ass ξ u ↑v
⊢ ∃ n, ↑u / ↑v = ξ.convergent n
tactic: have h := h'
state_before: ξ : ℝ
u v✝ : ℤ
hv : 2 ≤ v✝
v : ℕ
h' h : ContfracLegendre.Ass ξ u ↑v
⊢ ∃ n, ↑u / ↑v = ξ.convergent n
state_after: ξ : ℝ
u v✝ : ℤ
hv : 2 ≤ v✝
v : ℕ
h : ContfracLegendre.Ass ξ u ↑v
⊢ ∃ n, ↑u / ↑v = ξ.convergent n
tactic: clear h'
state_before: ξ : ℝ
u v✝ : ℤ
hv : 2 ≤ v✝
v : ℕ
h : ContfracLegendre.Ass ξ u ↑v
⊢ ∃ n, ↑u / ↑v = ξ.convergent n
state_after: case h
v✝ : ℤ
hv : 2 ≤ v✝
v : ℕ
ih : ∀ m < v, ∀ {ξ : ℝ} {u : ℤ}, ContfracLegendre.Ass ξ u ↑m → ∃ n, ↑u / ↑m = ξ.convergent n
ξ : ℝ
u : ℤ
h : ContfracLegendre.Ass ξ u ↑v
⊢ ∃ n, ↑u / ↑v = ξ.convergent n
tactic: induction v using Nat.strong_induction_on generalizing ξ u with | h v ih => ?_
state_before: case h
v✝ : ℤ
hv : 2 ≤ v✝
v : ℕ
ih : ∀ m < v, ∀ {ξ : ℝ} {u : ℤ}, ContfracLegendre.Ass ξ u ↑m → ∃ n, ↑u / ↑m = ξ.convergent n
ξ : ℝ
u : ℤ
h : ContfracLegendre.Ass ξ u ↑v
⊢ ∃ n, ↑u / ↑v = ξ.convergent n
state_after: case h.inl
v✝ : ℤ
hv : 2 ≤ v✝
v : ℕ
ih : ∀ m < v, ∀ {ξ : ℝ} {u : ℤ}, ContfracLegendre.Ass ξ u ↑m → ∃ n, ↑u / ↑m = ξ.convergent n
ξ : ℝ
u : ℤ
h : ContfracLegendre.Ass ξ u ↑v
ht : v < 1
⊢ ∃ n, ↑u / ↑v = ξ.convergent n

case h.inr.inl
v : ℤ
hv : 2 ≤ v
ξ : ℝ
u : ℤ
ih : ∀ m < 1, ∀ {ξ : ℝ} {u : ℤ}, ContfracLegendre.Ass ξ u ↑m → ∃ n, ↑u / ↑m = ξ.convergent n
h : ContfracLegendre.Ass ξ u ↑1
⊢ ∃ n, ↑u / ↑1 = ξ.convergent n

case h.inr.inr
v✝ : ℤ
hv : 2 ≤ v✝
v : ℕ
ih : ∀ m < v, ∀ {ξ : ℝ} {u : ℤ}, ContfracLegendre.Ass ξ u ↑m → ∃ n, ↑u / ↑m = ξ.convergent n
ξ : ℝ
u : ℤ
h : ContfracLegendre.Ass ξ u ↑v
ht : 1 < v
⊢ ∃ n, ↑u / ↑v = ξ.convergent n
tactic: rcases lt_trichotomy v 1 with (ht | rfl | ht)
Theorem: FirstOrder.Language.Equiv.comp_right_injective
File: Mathlib/ModelTheory/Basic.lean

Proof steps:
state_before: L : Language
L' : Language
M : Type w
N : Type w'
inst✝³ : L.Structure M
inst✝² : L.Structure N
P : Type u_1
inst✝¹ : L.Structure P
Q : Type u_2
inst✝ : L.Structure Q
h : M ≃[L] N
⊢ Function.Injective fun f => f.comp h
state_after: L : Language
L' : Language
M : Type w
N : Type w'
inst✝³ : L.Structure M
inst✝² : L.Structure N
P : Type u_1
inst✝¹ : L.Structure P
Q : Type u_2
inst✝ : L.Structure Q
h : M ≃[L] N
f g : N ≃[L] P
hfg : (fun f => f.comp h) f = (fun f => f.comp h) g
⊢ f = g
tactic: intro f g hfg
state_before: L : Language
L' : Language
M : Type w
N : Type w'
inst✝³ : L.Structure M
inst✝² : L.Structure N
P : Type u_1
inst✝¹ : L.Structure P
Q : Type u_2
inst✝ : L.Structure Q
h : M ≃[L] N
f g : N ≃[L] P
hfg : (fun f => f.comp h) f = (fun f => f.comp h) g
⊢ f = g
state_after: no goals
tactic: convert (congr_arg (fun r : (M ≃[L] P) ↦ r.comp h.symm) hfg) <;>
    rw [comp_assoc, self_comp_symm, comp_refl]
Theorem: MeasureTheory.IntegrableAtFilter.inf_ae_iff
File: Mathlib/MeasureTheory/Integral/IntegrableOn.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : MeasurableSpace α
inst✝ : NormedAddCommGroup E
f g : α → E
s t : Set α
μ ν : Measure α
l✝ l' l : Filter α
⊢ IntegrableAtFilter f (l ⊓ ae μ) μ ↔ IntegrableAtFilter f l μ
state_after: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : MeasurableSpace α
inst✝ : NormedAddCommGroup E
f g : α → E
s t : Set α
μ ν : Measure α
l✝ l' l : Filter α
⊢ IntegrableAtFilter f (l ⊓ ae μ) μ → IntegrableAtFilter f l μ
tactic: refine ⟨?_, fun h ↦ h.filter_mono inf_le_left⟩
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : MeasurableSpace α
inst✝ : NormedAddCommGroup E
f g : α → E
s t : Set α
μ ν : Measure α
l✝ l' l : Filter α
⊢ IntegrableAtFilter f (l ⊓ ae μ) μ → IntegrableAtFilter f l μ
state_after: case intro.intro.intro.intro.intro.intro
α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : MeasurableSpace α
inst✝ : NormedAddCommGroup E
f g : α → E
s t✝ : Set α
μ ν : Measure α
l✝ l' l : Filter α
t : Set α
ht : t ∈ l
u : Set α
hu : u ∈ ae μ
hf : IntegrableOn f (t ∩ u) μ
⊢ IntegrableAtFilter f l μ
tactic: rintro ⟨s, ⟨t, ht, u, hu, rfl⟩, hf⟩
state_before: case intro.intro.intro.intro.intro.intro
α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : MeasurableSpace α
inst✝ : NormedAddCommGroup E
f g : α → E
s t✝ : Set α
μ ν : Measure α
l✝ l' l : Filter α
t : Set α
ht : t ∈ l
u : Set α
hu : u ∈ ae μ
hf : IntegrableOn f (t ∩ u) μ
⊢ IntegrableAtFilter f l μ
state_after: case intro.intro.intro.intro.intro.intro
α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : MeasurableSpace α
inst✝ : NormedAddCommGroup E
f g : α → E
s t✝ : Set α
μ ν : Measure α
l✝ l' l : Filter α
t : Set α
ht : t ∈ l
u : Set α
hu : u ∈ ae μ
hf : IntegrableOn f (t ∩ u) μ
⊢ ∀ᵐ (x : α) ∂μ, x ∈ t ↔ x ∈ t ∩ u
tactic: refine ⟨t, ht, hf.congr_set_ae <| eventuallyEq_set.2 ?_⟩
state_before: case intro.intro.intro.intro.intro.intro
α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : MeasurableSpace α
inst✝ : NormedAddCommGroup E
f g : α → E
s t✝ : Set α
μ ν : Measure α
l✝ l' l : Filter α
t : Set α
ht : t ∈ l
u : Set α
hu : u ∈ ae μ
hf : IntegrableOn f (t ∩ u) μ
⊢ ∀ᵐ (x : α) ∂μ, x ∈ t ↔ x ∈ t ∩ u
state_after: no goals
tactic: filter_upwards [hu] with x hx using (and_iff_left hx).symm
Theorem: Subgroup.transferTransversal_apply'
File: Mathlib/GroupTheory/Complement.lean

Proof steps:
state_before: G : Type u
inst✝ : Group G
H : Subgroup G
g : G
q : orbitRel.Quotient (↥(zpowers g)) (G ⧸ H)
k : ZMod (minimalPeriod (fun x => g • x) (Quotient.out' q))
⊢ ↑((toEquiv ⋯) (g ^ k.cast • Quotient.out' q)) = g ^ k.cast * Quotient.out' (Quotient.out' q)
state_after: no goals
tactic: rw [transferTransversal_apply, transferFunction_apply, ← quotientEquivSigmaZMod_symm_apply,
    apply_symm_apply]
Theorem: Int.units_inv_eq_self
File: Mathlib/Data/Int/Order/Units.lean

Proof steps:
state_before: u : ℤˣ
⊢ u⁻¹ = u
state_after: no goals
tactic: rw [inv_eq_iff_mul_eq_one, units_mul_self]
Theorem: CategoryTheory.Subgroupoid.mem_full_objs_iff
File: Mathlib/CategoryTheory/Groupoid/Subgroupoid.lean

Proof steps:
state_before: C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
D : Set C
c : C
⊢ c ∈ (full D).objs ↔ c ∈ D
state_after: no goals
tactic: rw [full_objs]
Theorem: Real.inv_sqrt_one_add_tan_sq
File: Mathlib/Data/Complex/Exponential.lean

Proof steps:
state_before: x✝ y x : ℝ
hx : 0 < cos x
⊢ (√(1 + tan x ^ 2))⁻¹ = cos x
state_after: no goals
tactic: rw [← sqrt_sq hx.le, ← sqrt_inv, inv_one_add_tan_sq hx.ne']
Theorem: List.findIdx?_replicate
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: n : Nat
α✝ : Type u_1
a : α✝
p : α✝ → Bool
⊢ findIdx? p (replicate n a) = if 0 < n ∧ p a = true then some 0 else none
state_after: no goals
tactic: induction n with
  | zero => simp
  | succ n ih =>
    simp only [replicate, findIdx?_cons, Nat.zero_add, findIdx?_succ, Nat.zero_lt_succ, true_and]
    split <;> simp_all
Theorem: IsOpen.sub_left
File: Mathlib/Topology/Algebra/Group/Basic.lean

Proof steps:
state_before: G : Type w
H : Type x
α : Type u
β : Type v
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : TopologicalGroup G
s t : Set G
ht : IsOpen t
⊢ IsOpen (s / t)
state_after: G : Type w
H : Type x
α : Type u
β : Type v
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : TopologicalGroup G
s t : Set G
ht : IsOpen t
⊢ IsOpen (⋃ a ∈ s, (fun x => a / x) '' t)
tactic: rw [← iUnion_div_left_image]
state_before: G : Type w
H : Type x
α : Type u
β : Type v
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : TopologicalGroup G
s t : Set G
ht : IsOpen t
⊢ IsOpen (⋃ a ∈ s, (fun x => a / x) '' t)
state_after: no goals
tactic: exact isOpen_biUnion fun a _ => isOpenMap_div_left a t ht
Theorem: Polynomial.isUnit_iff_degree_eq_zero
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]
h : p.degree = 0
⊢ p.degree ≤ 0
state_after: no goals
tactic: simp [*, le_refl]
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]
h : p.degree = 0
this : p.degree ≤ 0
hc : p.coeff 0 = 0
⊢ False
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]
h : (C 0).degree = 0
this : p.degree ≤ 0
hc : p.coeff 0 = 0
⊢ False
tactic: rw [eq_C_of_degree_le_zero this, hc] at h
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]
h : (C 0).degree = 0
this : p.degree ≤ 0
hc : p.coeff 0 = 0
⊢ False
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]
this : p.degree ≤ 0
hc : p.coeff 0 = 0
h : degree 0 = 0
⊢ False
tactic: simp only [map_zero] at h
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]
this : p.degree ≤ 0
hc : p.coeff 0 = 0
h : degree 0 = 0
⊢ False
state_after: no goals
tactic: contradiction
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]
h : p.degree = 0
this : p.degree ≤ 0
hc : p.coeff 0 ≠ 0
⊢ 1 = p * C (p.coeff 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]
h : p.degree = 0
this : p.degree ≤ 0
hc : p.coeff 0 ≠ 0
⊢ 1 = C (p.coeff 0) * C (p.coeff 0)⁻¹
tactic: conv in p => rw [eq_C_of_degree_le_zero this]
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]
h : p.degree = 0
this : p.degree ≤ 0
hc : p.coeff 0 ≠ 0
⊢ 1 = C (p.coeff 0) * C (p.coeff 0)⁻¹
state_after: no goals
tactic: rw [← C_mul, _root_.mul_inv_cancel hc, C_1]
Theorem: isComplete_iff_ultrafilter'
File: Mathlib/Topology/UniformSpace/Cauchy.lean

Proof steps:
state_before: α : Type u
β : Type v
uniformSpace : UniformSpace α
s : Set α
⊢ (∀ (l : Ultrafilter α), Cauchy ↑l → ↑l ≤ 𝓟 s → ∃ x ∈ s, ↑l ≤ 𝓝 x) ↔
    ∀ (l : Ultrafilter α), Cauchy ↑l → s ∈ l → ∃ x ∈ s, ↑l ≤ 𝓝 x
state_after: no goals
tactic: simp only [le_principal_iff, Ultrafilter.mem_coe]
Theorem: CategoryTheory.Idempotents.Karoubi.decompId
File: Mathlib/CategoryTheory/Idempotents/Karoubi.lean

Proof steps:
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
P : Karoubi C
⊢ 𝟙 P = P.decompId_i ≫ P.decompId_p
state_after: case h
C : Type u_1
inst✝ : Category.{u_2, u_1} C
P : Karoubi C
⊢ (𝟙 P).f = (P.decompId_i ≫ P.decompId_p).f
tactic: ext
state_before: case h
C : Type u_1
inst✝ : Category.{u_2, u_1} C
P : Karoubi C
⊢ (𝟙 P).f = (P.decompId_i ≫ P.decompId_p).f
state_after: no goals
tactic: simp only [comp_f, id_f, P.idem, decompId_i, decompId_p]
Theorem: ProbabilityTheory.measure_eq_zero_or_one_of_indepSet_self
File: Mathlib/Probability/Independence/ZeroOne.lean

Proof steps:
state_before: α : Type u_1
Ω : Type u_2
ι : Type u_3
_mα : MeasurableSpace α
s : ι → MeasurableSpace Ω
m m0 : MeasurableSpace Ω
κ : Kernel α Ω
μα : Measure α
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
t : Set Ω
h_indep : IndepSet t t μ
⊢ μ t = 0 ∨ μ t = 1
state_after: no goals
tactic: simpa only [ae_dirac_eq, Filter.eventually_pure]
    using Kernel.measure_eq_zero_or_one_of_indepSet_self h_indep
Theorem: Ordinal.opow_mul_add_lt_opow_succ
File: Mathlib/SetTheory/Ordinal/Exponential.lean

Proof steps:
state_before: b u v w : Ordinal.{u_1}
hvb : v < b
hw : w < b ^ u
⊢ b ^ u * v + w < b ^ succ u
state_after: case h.e'_4
b u v w : Ordinal.{u_1}
hvb : v < b
hw : w < b ^ u
⊢ b ^ succ u = b ^ u * b
tactic: convert (opow_mul_add_lt_opow_mul_succ v hw).trans_le (mul_le_mul_left' (succ_le_of_lt hvb) _)
    using 1
state_before: case h.e'_4
b u v w : Ordinal.{u_1}
hvb : v < b
hw : w < b ^ u
⊢ b ^ succ u = b ^ u * b
state_after: no goals
tactic: exact opow_succ b u
Theorem: Function.Injective.invFun_restrict
File: Mathlib/Data/Fintype/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : Fintype α
inst✝¹ : DecidableEq β
f : α → β
hf : Injective f
inst✝ : Nonempty α
⊢ (Set.range f).restrict (invFun f) = hf.invOfMemRange
state_after: case h.mk
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : Fintype α
inst✝¹ : DecidableEq β
f : α → β
hf : Injective f
inst✝ : Nonempty α
b : β
h : b ∈ Set.range f
⊢ (Set.range f).restrict (invFun f) ⟨b, h⟩ = hf.invOfMemRange ⟨b, h⟩
tactic: ext ⟨b, h⟩
state_before: case h.mk
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : Fintype α
inst✝¹ : DecidableEq β
f : α → β
hf : Injective f
inst✝ : Nonempty α
b : β
h : b ∈ Set.range f
⊢ (Set.range f).restrict (invFun f) ⟨b, h⟩ = hf.invOfMemRange ⟨b, h⟩
state_after: case h.mk.a
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : Fintype α
inst✝¹ : DecidableEq β
f : α → β
hf : Injective f
inst✝ : Nonempty α
b : β
h : b ∈ Set.range f
⊢ f ((Set.range f).restrict (invFun f) ⟨b, h⟩) = f (hf.invOfMemRange ⟨b, h⟩)
tactic: apply hf
state_before: case h.mk.a
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : Fintype α
inst✝¹ : DecidableEq β
f : α → β
hf : Injective f
inst✝ : Nonempty α
b : β
h : b ∈ Set.range f
⊢ f ((Set.range f).restrict (invFun f) ⟨b, h⟩) = f (hf.invOfMemRange ⟨b, h⟩)
state_after: no goals
tactic: simp [hf.left_inv_of_invOfMemRange, @invFun_eq _ _ _ f b (Set.mem_range.mp h)]
Theorem: Turing.TM1.stmts₁_supportsStmt_mono
File: Mathlib/Computability/TuringMachine.lean

Proof steps:
state_before: Γ : Type u_1
inst✝ : Inhabited Γ
Λ : Type u_2
σ : Type u_3
S : Finset Λ
q₁ q₂ : Stmt₁
h : q₁ ∈ stmts₁ q₂
hs : SupportsStmt S q₂
⊢ SupportsStmt S q₁
state_after: no goals
tactic: induction q₂ with
    simp only [stmts₁, SupportsStmt, Finset.mem_insert, Finset.mem_union, Finset.mem_singleton]
      at h hs
  | branch p q₁ q₂ IH₁ IH₂ => rcases h with (rfl | h | h); exacts [hs, IH₁ h hs.1, IH₂ h hs.2]
  | goto l => subst h; exact hs
  | halt => subst h; trivial
  | _ _ q IH => rcases h with (rfl | h) <;> [exact hs; exact IH h hs]
Theorem: totallyBounded_biUnion
File: Mathlib/Topology/UniformSpace/Cauchy.lean

Proof steps:
state_before: α : Type u
β : Type v
uniformSpace : UniformSpace α
ι : Type u_1
I : Set ι
hI : I.Finite
s : ι → Set α
⊢ TotallyBounded (⋃ i ∈ I, s i) ↔ ∀ i ∈ I, TotallyBounded (s i)
state_after: α : Type u
β : Type v
uniformSpace : UniformSpace α
ι : Type u_1
I : Set ι
hI : I.Finite
s : ι → Set α
this : Finite ↑I
⊢ TotallyBounded (⋃ i ∈ I, s i) ↔ ∀ i ∈ I, TotallyBounded (s i)
tactic: have := hI.to_subtype
state_before: α : Type u
β : Type v
uniformSpace : UniformSpace α
ι : Type u_1
I : Set ι
hI : I.Finite
s : ι → Set α
this : Finite ↑I
⊢ TotallyBounded (⋃ i ∈ I, s i) ↔ ∀ i ∈ I, TotallyBounded (s i)
state_after: no goals
tactic: rw [biUnion_eq_iUnion, totallyBounded_iUnion, Subtype.forall]
Theorem: AdjoinRoot.algEquivOfAssociated_toAlgHom
File: Mathlib/FieldTheory/Adjoin.lean

Proof steps:
state_before: K : Type ?u.613136
L : Type ?u.613139
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Algebra K L
p q : K[X]
hp : p ≠ 0
hpq : Associated p q
⊢ (aeval (root q)) p = 0
state_after: no goals
tactic: simp only [aeval_eq, mk_eq_zero, hpq.symm.dvd]
Theorem: Equiv.subLeft_symm_apply
File: Mathlib/Algebra/Group/Units/Equiv.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
A : Type u_4
B : Type u_5
M : Type u_6
N : Type u_7
P : Type u_8
Q : Type u_9
G : Type u_10
H : Type u_11
inst✝ : Group G
a b : G
⊢ (fun b => b⁻¹ * a) ((fun b => a / b) b) = b
state_after: no goals
tactic: simp [div_eq_mul_inv]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
A : Type u_4
B : Type u_5
M : Type u_6
N : Type u_7
P : Type u_8
Q : Type u_9
G : Type u_10
H : Type u_11
inst✝ : Group G
a b : G
⊢ (fun b => a / b) ((fun b => b⁻¹ * a) b) = b
state_after: no goals
tactic: simp [div_eq_mul_inv]
Theorem: RingHom.map_dotProduct
File: Mathlib/Data/Matrix/Basic.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝⁴ : Fintype n
inst✝³ : NonAssocSemiring α
inst✝² : NonAssocSemiring β
inst✝¹ : NonAssocSemiring R
inst✝ : NonAssocSemiring S
f : R →+* S
v w : n → R
⊢ f (v ⬝ᵥ w) = ⇑f ∘ v ⬝ᵥ ⇑f ∘ w
state_after: no goals
tactic: simp only [Matrix.dotProduct, map_sum f, f.map_mul, Function.comp]
Theorem: Fin.succAbove_last
File: Mathlib/Data/Fin/Basic.lean

Proof steps:
state_before: n m : ℕ
p : Fin (n + 1)
i j : Fin n
⊢ (last n).succAbove = castSucc
state_after: case h.h
n m : ℕ
p : Fin (n + 1)
i j x✝ : Fin n
⊢ ↑((last n).succAbove x✝) = ↑x✝.castSucc
tactic: ext
state_before: case h.h
n m : ℕ
p : Fin (n + 1)
i j x✝ : Fin n
⊢ ↑((last n).succAbove x✝) = ↑x✝.castSucc
state_after: no goals
tactic: simp only [succAbove_of_castSucc_lt, castSucc_lt_last]
Theorem: List.erase_eq_eraseP
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : BEq α
inst✝ : LawfulBEq α
a b : α
l : List α
⊢ (b :: l).erase a = eraseP (fun x => a == x) (b :: l)
state_after: no goals
tactic: if h : a = b then simp [h] else simp [h, Ne.symm h, erase_eq_eraseP a l]
Theorem: List.scanl_cons
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : β → α → β
b : β
a : α
l : List α
⊢ scanl f b (a :: l) = [b] ++ scanl f (f b a) l
state_after: no goals
tactic: simp only [scanl, eq_self_iff_true, singleton_append, and_self_iff]
Theorem: bddAbove_range_prod
File: Mathlib/Order/Bounds/Basic.lean

Proof steps:
state_before: α✝ : Type u
β✝ : Type v
γ : Type w
ι : Sort x
α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : Preorder β
F : ι → α × β
⊢ BddAbove (range F) ↔ BddAbove (range (Prod.fst ∘ F)) ∧ BddAbove (range (Prod.snd ∘ F))
state_after: no goals
tactic: simp only [bddAbove_prod, ← range_comp]
Theorem: Nat.three_dvd_iff
File: Mathlib/Data/Nat/Digits.lean

Proof steps:
state_before: n✝ n : ℕ
⊢ 10 % 3 = 1
state_after: no goals
tactic: norm_num
Theorem: Int.modEq_iff_add_fac
File: Mathlib/Data/Int/ModEq.lean

Proof steps:
state_before: m n✝ a✝ b✝ c d a b n : ℤ
⊢ a ≡ b [ZMOD n] ↔ ∃ t, b = a + n * t
state_after: m n✝ a✝ b✝ c d a b n : ℤ
⊢ n ∣ b - a ↔ ∃ t, b = a + n * t
tactic: rw [modEq_iff_dvd]
state_before: m n✝ a✝ b✝ c d a b n : ℤ
⊢ n ∣ b - a ↔ ∃ t, b = a + n * t
state_after: no goals
tactic: exact exists_congr fun t => sub_eq_iff_eq_add'