ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Prod.wcovBy_iff
File: Mathlib/Order/Cover.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
a a₁ a₂ : α
b b₁ b₂ : β
x y : α × β
⊢ x ⩿ y ↔ x.1 ⩿ y.1 ∧ x.2 = y.2 ∨ x.2 ⩿ y.2 ∧ x.1 = y.1
state_after: case mk
α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
a a₁ a₂ : α
b b₁ b₂ : β
y : α × β
fst✝ : α
snd✝ : β
⊢ (fst✝, snd✝) ⩿ y ↔ (fst✝, snd✝).1 ⩿ y.1 ∧ (fst✝, snd✝).2 = y.2 ∨ (fst✝, snd✝).2 ⩿ y.2 ∧ (fst✝, snd✝).1 = y.1
tactic: cases x
state_before: case mk
α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
a a₁ a₂ : α
b b₁ b₂ : β
y : α × β
fst✝ : α
snd✝ : β
⊢ (fst✝, snd✝) ⩿ y ↔ (fst✝, snd✝).1 ⩿ y.1 ∧ (fst✝, snd✝).2 = y.2 ∨ (fst✝, snd✝).2 ⩿ y.2 ∧ (fst✝, snd✝).1 = y.1
state_after: case mk.mk
α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
a a₁ a₂ : α
b b₁ b₂ : β
fst✝¹ : α
snd✝¹ : β
fst✝ : α
snd✝ : β
⊢ (fst✝¹, snd✝¹) ⩿ (fst✝, snd✝) ↔
    (fst✝¹, snd✝¹).1 ⩿ (fst✝, snd✝).1 ∧ (fst✝¹, snd✝¹).2 = (fst✝, snd✝).2 ∨
      (fst✝¹, snd✝¹).2 ⩿ (fst✝, snd✝).2 ∧ (fst✝¹, snd✝¹).1 = (fst✝, snd✝).1
tactic: cases y
state_before: case mk.mk
α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
a a₁ a₂ : α
b b₁ b₂ : β
fst✝¹ : α
snd✝¹ : β
fst✝ : α
snd✝ : β
⊢ (fst✝¹, snd✝¹) ⩿ (fst✝, snd✝) ↔
    (fst✝¹, snd✝¹).1 ⩿ (fst✝, snd✝).1 ∧ (fst✝¹, snd✝¹).2 = (fst✝, snd✝).2 ∨
      (fst✝¹, snd✝¹).2 ⩿ (fst✝, snd✝).2 ∧ (fst✝¹, snd✝¹).1 = (fst✝, snd✝).1
state_after: no goals
tactic: exact mk_wcovBy_mk_iff
Theorem: pow_mem
File: Mathlib/Algebra/Group/Submonoid/Basic.lean

Proof steps:
state_before: M✝ : Type u_1
N : Type u_2
A✝ : Type u_3
inst✝⁴ : MulOneClass M✝
s : Set M✝
inst✝³ : AddZeroClass A✝
t : Set A✝
M : Type u_4
A : Type u_5
inst✝² : Monoid M
inst✝¹ : SetLike A M
inst✝ : SubmonoidClass A M
S : A
x : M
hx : x ∈ S
⊢ x ^ 0 ∈ S
state_after: M✝ : Type u_1
N : Type u_2
A✝ : Type u_3
inst✝⁴ : MulOneClass M✝
s : Set M✝
inst✝³ : AddZeroClass A✝
t : Set A✝
M : Type u_4
A : Type u_5
inst✝² : Monoid M
inst✝¹ : SetLike A M
inst✝ : SubmonoidClass A M
S : A
x : M
hx : x ∈ S
⊢ 1 ∈ S
tactic: rw [pow_zero]
state_before: M✝ : Type u_1
N : Type u_2
A✝ : Type u_3
inst✝⁴ : MulOneClass M✝
s : Set M✝
inst✝³ : AddZeroClass A✝
t : Set A✝
M : Type u_4
A : Type u_5
inst✝² : Monoid M
inst✝¹ : SetLike A M
inst✝ : SubmonoidClass A M
S : A
x : M
hx : x ∈ S
⊢ 1 ∈ S
state_after: no goals
tactic: exact OneMemClass.one_mem S
state_before: M✝ : Type u_1
N : Type u_2
A✝ : Type u_3
inst✝⁴ : MulOneClass M✝
s : Set M✝
inst✝³ : AddZeroClass A✝
t : Set A✝
M : Type u_4
A : Type u_5
inst✝² : Monoid M
inst✝¹ : SetLike A M
inst✝ : SubmonoidClass A M
S : A
x : M
hx : x ∈ S
n : ℕ
⊢ x ^ (n + 1) ∈ S
state_after: M✝ : Type u_1
N : Type u_2
A✝ : Type u_3
inst✝⁴ : MulOneClass M✝
s : Set M✝
inst✝³ : AddZeroClass A✝
t : Set A✝
M : Type u_4
A : Type u_5
inst✝² : Monoid M
inst✝¹ : SetLike A M
inst✝ : SubmonoidClass A M
S : A
x : M
hx : x ∈ S
n : ℕ
⊢ x ^ n * x ∈ S
tactic: rw [pow_succ]
state_before: M✝ : Type u_1
N : Type u_2
A✝ : Type u_3
inst✝⁴ : MulOneClass M✝
s : Set M✝
inst✝³ : AddZeroClass A✝
t : Set A✝
M : Type u_4
A : Type u_5
inst✝² : Monoid M
inst✝¹ : SetLike A M
inst✝ : SubmonoidClass A M
S : A
x : M
hx : x ∈ S
n : ℕ
⊢ x ^ n * x ∈ S
state_after: no goals
tactic: exact mul_mem (pow_mem hx n) hx
Theorem: AdjoinRoot.root_isInv
File: Mathlib/RingTheory/AdjoinRoot.lean

Proof steps:
state_before: R : Type u
S : Type v
K : Type w
inst✝² : CommRing R
f : R[X]
inst✝¹ : CommRing S
i : R →+* S
a : S
h : eval₂ i a f = 0
inst✝ : Algebra R S
hfx : (aeval a) f = 0
r : R
⊢ (of (C r * X - 1)) r * root (C r * X - 1) = 1
state_after: no goals
tactic: convert sub_eq_zero.1 ((eval₂_sub _).symm.trans <| eval₂_root <| C r * X - 1) <;>
    simp only [eval₂_mul, eval₂_C, eval₂_X, eval₂_one]
Theorem: Finset.exists_subsuperset_card_eq
File: Mathlib/Data/Finset/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
R : Type u_3
s t u : Finset α
f : α → β
n : ℕ
hst : s ⊆ t
hsn : s.card ≤ n
hnt : n ≤ t.card
⊢ ∃ u, s ⊆ u ∧ u ⊆ t ∧ u.card = n
state_after: no goals
tactic: classical
  refine Nat.decreasingInduction' ?_ hnt ⟨t, by simp [hst]⟩
  intro k _ hnk ⟨u, hu₁, hu₂, hu₃⟩
  obtain ⟨a, ha⟩ : (u \ s).Nonempty := by rw [← card_pos, card_sdiff hu₁]; omega
  simp only [mem_sdiff] at ha
  exact ⟨u.erase a, by simp [subset_erase, erase_subset_iff_of_mem (hu₂ _), *]⟩
Theorem: Function.support_curry
File: Mathlib/Algebra/Group/Support.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
A : Type u_3
B : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
inst✝² : One M
inst✝¹ : One N
inst✝ : One P
f : α × β → M
⊢ mulSupport (curry f) = Prod.fst '' mulSupport f
state_after: no goals
tactic: simp [mulSupport, funext_iff, image]
Theorem: MonoidAlgebra.lift_apply
File: Mathlib/Algebra/MonoidAlgebra/Basic.lean

Proof steps:
state_before: k : Type u₁
G : Type u₂
H : Type u_1
R : Type u_2
inst✝⁶ : CommSemiring k
inst✝⁵ : Monoid G
inst✝⁴ : Monoid H
A : Type u₃
inst✝³ : Semiring A
inst✝² : Algebra k A
B : Type u_3
inst✝¹ : Semiring B
inst✝ : Algebra k B
F : G →* A
f : MonoidAlgebra k G
⊢ ((lift k G A) F) f = sum f fun a b => b • F a
state_after: no goals
tactic: simp only [lift_apply', Algebra.smul_def]
Theorem: padicNormE.nonarchimedean
File: Mathlib/NumberTheory/Padics/PadicNumbers.lean

Proof steps:
state_before: p : ℕ
hp : Fact (Nat.Prime p)
q r : ℚ_[p]
⊢ ‖q + r‖ ≤ max ‖q‖ ‖r‖
state_after: p : ℕ
hp : Fact (Nat.Prime p)
q r : ℚ_[p]
⊢ ↑(padicNormE (q + r)) ≤ max ↑(padicNormE q) ↑(padicNormE r)
tactic: dsimp [norm]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
q r : ℚ_[p]
⊢ ↑(padicNormE (q + r)) ≤ max ↑(padicNormE q) ↑(padicNormE r)
state_after: no goals
tactic: exact mod_cast nonarchimedean' _ _
Theorem: AddGroup.toSubNegAddMonoid_injective
File: Mathlib/Algebra/Group/Ext.lean

Proof steps:
state_before: G : Type u_1
⊢ Injective (@toDivInvMonoid G)
state_after: case mk.mk.refl
G : Type u_1
toDivInvMonoid✝ : DivInvMonoid G
mul_left_inv✝¹ mul_left_inv✝ : ∀ (a : G), a⁻¹ * a = 1
⊢ mk mul_left_inv✝¹ = mk mul_left_inv✝
tactic: rintro ⟨⟩ ⟨⟩ ⟨⟩
state_before: case mk.mk.refl
G : Type u_1
toDivInvMonoid✝ : DivInvMonoid G
mul_left_inv✝¹ mul_left_inv✝ : ∀ (a : G), a⁻¹ * a = 1
⊢ mk mul_left_inv✝¹ = mk mul_left_inv✝
state_after: no goals
tactic: rfl
Theorem: set_has_minimal_iff_artinian
File: Mathlib/RingTheory/Artinian.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
⊢ (∀ (a : Set (Submodule R M)), a.Nonempty → ∃ M' ∈ a, ∀ I ∈ a, ¬I < M') ↔ IsArtinian R M
state_after: no goals
tactic: rw [isArtinian_iff_wellFounded, WellFounded.wellFounded_iff_has_min]
Theorem: MeasureTheory.Memℒp.sub
File: Mathlib/MeasureTheory/Function/LpSeminorm/TriangleInequality.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
m : MeasurableSpace α
inst✝ : NormedAddCommGroup E
p : ℝ≥0∞
q : ℝ
μ : Measure α
f✝ g✝ f g : α → E
hf : Memℒp f p μ
hg : Memℒp g p μ
⊢ Memℒp (f - g) p μ
state_after: α : Type u_1
E : Type u_2
m : MeasurableSpace α
inst✝ : NormedAddCommGroup E
p : ℝ≥0∞
q : ℝ
μ : Measure α
f✝ g✝ f g : α → E
hf : Memℒp f p μ
hg : Memℒp g p μ
⊢ Memℒp (f + -g) p μ
tactic: rw [sub_eq_add_neg]
state_before: α : Type u_1
E : Type u_2
m : MeasurableSpace α
inst✝ : NormedAddCommGroup E
p : ℝ≥0∞
q : ℝ
μ : Measure α
f✝ g✝ f g : α → E
hf : Memℒp f p μ
hg : Memℒp g p μ
⊢ Memℒp (f + -g) p μ
state_after: no goals
tactic: exact hf.add hg.neg
Theorem: Int.cast_pos
File: Mathlib/Algebra/Order/Ring/Cast.lean

Proof steps:
state_before: R : Type u_1
inst✝⁵ : AddCommGroupWithOne R
inst✝⁴ : PartialOrder R
inst✝³ : CovariantClass R R (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝² : ZeroLEOneClass R
inst✝¹ : NeZero 1
inst✝ : Nontrivial R
m n : ℤ
⊢ 0 < ↑n ↔ 0 < n
state_after: no goals
tactic: rw [← cast_zero, cast_lt]
Theorem: TruncatedWittVector.truncateFun_out
File: Mathlib/RingTheory/WittVector/Truncated.lean

Proof steps:
state_before: p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
R : Type u_1
inst✝ : CommRing R
x : TruncatedWittVector p n R
⊢ WittVector.truncateFun n x.out = x
state_after: no goals
tactic: simp only [WittVector.truncateFun, coeff_out, mk_coeff]
Theorem: Real.Angle.cos_toReal
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

Proof steps:
state_before: θ : Angle
⊢ Real.cos θ.toReal = θ.cos
state_after: no goals
tactic: conv_rhs => rw [← coe_toReal θ, cos_coe]
Theorem: AddCircle.scaled_exp_map_periodic
File: Mathlib/Analysis/SpecialFunctions/Complex/Circle.lean

Proof steps:
state_before: T : ℝ
⊢ Periodic (fun x => expMapCircle (2 * π / T * x)) T
state_after: case inl

⊢ Periodic (fun x => expMapCircle (2 * π / 0 * x)) 0

case inr
T : ℝ
hT : T ≠ 0
⊢ Periodic (fun x => expMapCircle (2 * π / T * x)) T
tactic: rcases eq_or_ne T 0 with (rfl | hT)
Theorem: dvd_sub_right
File: Mathlib/Algebra/Ring/Divisibility/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : NonUnitalRing α
a b c : α
h : a ∣ b
⊢ a ∣ b - c ↔ a ∣ c
state_after: no goals
tactic: rw [sub_eq_add_neg, dvd_add_right h, dvd_neg (α := α)]
Theorem: left_div_gcd_ne_zero
File: Mathlib/RingTheory/EuclideanDomain.lean

Proof steps:
state_before: R : Type u_1
inst✝¹ : EuclideanDomain R
inst✝ : GCDMonoid R
p✝ q✝ p q : R
hp : p ≠ 0
⊢ p / GCDMonoid.gcd p q ≠ 0
state_after: case intro
R : Type u_1
inst✝¹ : EuclideanDomain R
inst✝ : GCDMonoid R
p✝ q✝ p q : R
hp : p ≠ 0
r : R
hr : p = GCDMonoid.gcd p q * r
⊢ p / GCDMonoid.gcd p q ≠ 0
tactic: obtain ⟨r, hr⟩ := GCDMonoid.gcd_dvd_left p q
state_before: case intro
R : Type u_1
inst✝¹ : EuclideanDomain R
inst✝ : GCDMonoid R
p✝ q✝ p q : R
hp : p ≠ 0
r : R
hr : p = GCDMonoid.gcd p q * r
⊢ p / GCDMonoid.gcd p q ≠ 0
state_after: case intro.intro
R : Type u_1
inst✝¹ : EuclideanDomain R
inst✝ : GCDMonoid R
p✝ q✝ p q : R
hp : p ≠ 0
r : R
hr : p = GCDMonoid.gcd p q * r
pq0 : GCDMonoid.gcd p q ≠ 0
r0 : r ≠ 0
⊢ p / GCDMonoid.gcd p q ≠ 0
tactic: obtain ⟨pq0, r0⟩ : GCDMonoid.gcd p q ≠ 0 ∧ r ≠ 0 := mul_ne_zero_iff.mp (hr ▸ hp)
state_before: case intro.intro
R : Type u_1
inst✝¹ : EuclideanDomain R
inst✝ : GCDMonoid R
p✝ q✝ p q : R
hp : p ≠ 0
r : R
hr : p = GCDMonoid.gcd p q * r
pq0 : GCDMonoid.gcd p q ≠ 0
r0 : r ≠ 0
⊢ p / GCDMonoid.gcd p q ≠ 0
state_after: case intro.intro
R : Type u_1
inst✝¹ : EuclideanDomain R
inst✝ : GCDMonoid R
p✝ q✝ p q : R
hp : p ≠ 0
r : R
hr : p = GCDMonoid.gcd p q * r
pq0 : GCDMonoid.gcd p q ≠ 0
r0 : r ≠ 0
⊢ GCDMonoid.gcd p q * r / GCDMonoid.gcd p q ≠ 0
tactic: nth_rw 1 [hr]
state_before: case intro.intro
R : Type u_1
inst✝¹ : EuclideanDomain R
inst✝ : GCDMonoid R
p✝ q✝ p q : R
hp : p ≠ 0
r : R
hr : p = GCDMonoid.gcd p q * r
pq0 : GCDMonoid.gcd p q ≠ 0
r0 : r ≠ 0
⊢ GCDMonoid.gcd p q * r / GCDMonoid.gcd p q ≠ 0
state_after: case intro.intro
R : Type u_1
inst✝¹ : EuclideanDomain R
inst✝ : GCDMonoid R
p✝ q✝ p q : R
hp : p ≠ 0
r : R
hr : p = GCDMonoid.gcd p q * r
pq0 : GCDMonoid.gcd p q ≠ 0
r0 : r ≠ 0
⊢ r ≠ 0
tactic: rw [mul_comm, mul_div_cancel_right₀ _ pq0]
state_before: case intro.intro
R : Type u_1
inst✝¹ : EuclideanDomain R
inst✝ : GCDMonoid R
p✝ q✝ p q : R
hp : p ≠ 0
r : R
hr : p = GCDMonoid.gcd p q * r
pq0 : GCDMonoid.gcd p q ≠ 0
r0 : r ≠ 0
⊢ r ≠ 0
state_after: no goals
tactic: exact r0
Theorem: ContinuousMultilinearMap.apply_zero_curry0
File: Mathlib/Analysis/NormedSpace/Multilinear/Curry.lean

Proof steps:
state_before: 𝕜 : Type u
ι : Type v
ι' : Type v'
n : ℕ
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
Ei : Fin n.succ → Type wEi
G : Type wG
G' : Type wG'
inst✝¹⁴ : Fintype ι
inst✝¹³ : Fintype ι'
inst✝¹² : NontriviallyNormedField 𝕜
inst✝¹¹ : (i : ι) → NormedAddCommGroup (E i)
inst✝¹⁰ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝⁹ : (i : ι) → NormedAddCommGroup (E₁ i)
inst✝⁸ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁷ : (i : ι') → NormedAddCommGroup (E' i)
inst✝⁶ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝⁵ : (i : Fin n.succ) → NormedAddCommGroup (Ei i)
inst✝⁴ : (i : Fin n.succ) → NormedSpace 𝕜 (Ei i)
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f : ContinuousMultilinearMap 𝕜 (fun i => G) G'
x : Fin 0 → G
⊢ curry0 𝕜 G (f x) = f
state_after: case H
𝕜 : Type u
ι : Type v
ι' : Type v'
n : ℕ
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
Ei : Fin n.succ → Type wEi
G : Type wG
G' : Type wG'
inst✝¹⁴ : Fintype ι
inst✝¹³ : Fintype ι'
inst✝¹² : NontriviallyNormedField 𝕜
inst✝¹¹ : (i : ι) → NormedAddCommGroup (E i)
inst✝¹⁰ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝⁹ : (i : ι) → NormedAddCommGroup (E₁ i)
inst✝⁸ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁷ : (i : ι') → NormedAddCommGroup (E' i)
inst✝⁶ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝⁵ : (i : Fin n.succ) → NormedAddCommGroup (Ei i)
inst✝⁴ : (i : Fin n.succ) → NormedSpace 𝕜 (Ei i)
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f : ContinuousMultilinearMap 𝕜 (fun i => G) G'
x m : Fin 0 → G
⊢ (curry0 𝕜 G (f x)) m = f m
tactic: ext m
state_before: case H
𝕜 : Type u
ι : Type v
ι' : Type v'
n : ℕ
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
Ei : Fin n.succ → Type wEi
G : Type wG
G' : Type wG'
inst✝¹⁴ : Fintype ι
inst✝¹³ : Fintype ι'
inst✝¹² : NontriviallyNormedField 𝕜
inst✝¹¹ : (i : ι) → NormedAddCommGroup (E i)
inst✝¹⁰ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝⁹ : (i : ι) → NormedAddCommGroup (E₁ i)
inst✝⁸ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁷ : (i : ι') → NormedAddCommGroup (E' i)
inst✝⁶ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝⁵ : (i : Fin n.succ) → NormedAddCommGroup (Ei i)
inst✝⁴ : (i : Fin n.succ) → NormedSpace 𝕜 (Ei i)
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f : ContinuousMultilinearMap 𝕜 (fun i => G) G'
x m : Fin 0 → G
⊢ (curry0 𝕜 G (f x)) m = f m
state_after: no goals
tactic: simp [Subsingleton.elim x m]
Theorem: Pell.pell_eq
File: Mathlib/NumberTheory/PellMatiyasevic.lean

Proof steps:
state_before: a : ℕ
a1 : 1 < a
n : ℕ
pn : xz a1 n * xz a1 n - ↑(Pell.d a1) * yz a1 n * yz a1 n = 1 := pell_eqz a1 n
⊢ ↑(xn a1 n * xn a1 n) - ↑(Pell.d a1 * yn a1 n * yn a1 n) = 1
state_after: no goals
tactic: repeat' rw [Int.ofNat_mul]; exact pn
state_before: a : ℕ
a1 : 1 < a
n : ℕ
pn : xz a1 n * xz a1 n - ↑(Pell.d a1) * yz a1 n * yz a1 n = 1 := pell_eqz a1 n
h : ↑(xn a1 n * xn a1 n) - ↑(Pell.d a1 * yn a1 n * yn a1 n) = 1
hl : Pell.d a1 * yn a1 n * yn a1 n ≤ xn a1 n * xn a1 n
⊢ ↑(xn a1 n * xn a1 n - Pell.d a1 * yn a1 n * yn a1 n) = ↑1
state_after: a : ℕ
a1 : 1 < a
n : ℕ
pn : xz a1 n * xz a1 n - ↑(Pell.d a1) * yz a1 n * yz a1 n = 1 := pell_eqz a1 n
h : ↑(xn a1 n * xn a1 n) - ↑(Pell.d a1 * yn a1 n * yn a1 n) = 1
hl : Pell.d a1 * yn a1 n * yn a1 n ≤ xn a1 n * xn a1 n
⊢ ↑(xn a1 n * xn a1 n) - ↑(Pell.d a1 * yn a1 n * yn a1 n) = ↑1
tactic: rw [Int.ofNat_sub hl]
state_before: a : ℕ
a1 : 1 < a
n : ℕ
pn : xz a1 n * xz a1 n - ↑(Pell.d a1) * yz a1 n * yz a1 n = 1 := pell_eqz a1 n
h : ↑(xn a1 n * xn a1 n) - ↑(Pell.d a1 * yn a1 n * yn a1 n) = 1
hl : Pell.d a1 * yn a1 n * yn a1 n ≤ xn a1 n * xn a1 n
⊢ ↑(xn a1 n * xn a1 n) - ↑(Pell.d a1 * yn a1 n * yn a1 n) = ↑1
state_after: no goals
tactic: exact h
Theorem: CategoryTheory.Subgroupoid.disconnect_le
File: Mathlib/CategoryTheory/Groupoid/Subgroupoid.lean

Proof steps:
state_before: C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
⊢ S.disconnect ≤ S
state_after: C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
⊢ ∀ {c d : C}, S.disconnect.arrows c d ⊆ S.arrows c d
tactic: rw [le_iff]
state_before: C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
⊢ ∀ {c d : C}, S.disconnect.arrows c d ⊆ S.arrows c d
state_after: case intro
C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
c✝ d✝ : C
a✝ : c✝ ⟶ d✝
left✝ : c✝ = d✝
right✝ : a✝ ∈ S.arrows c✝ d✝
⊢ a✝ ∈ S.arrows c✝ d✝
tactic: rintro _ _ _ ⟨⟩
state_before: case intro
C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
c✝ d✝ : C
a✝ : c✝ ⟶ d✝
left✝ : c✝ = d✝
right✝ : a✝ ∈ S.arrows c✝ d✝
⊢ a✝ ∈ S.arrows c✝ d✝
state_after: no goals
tactic: assumption
Theorem: CompleteSpace.snd_of_prod
File: Mathlib/Topology/UniformSpace/Cauchy.lean

Proof steps:
state_before: α : Type u
β : Type v
uniformSpace : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : CompleteSpace (α × β)
h : Nonempty α
f✝ : Filter β
hf : Cauchy f✝
x a : α
b : β
hab : pure x ×ˢ f✝ ≤ 𝓝 (a, b)
⊢ f✝ ≤ 𝓝 b
state_after: no goals
tactic: simpa only [map_snd_prod, nhds_prod_eq] using map_mono (m := Prod.snd) hab
Theorem: div_self_mul_self'
File: Mathlib/Algebra/GroupWithZero/Basic.lean

Proof steps:
state_before: α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝ : GroupWithZero G₀
a✝ b c a : G₀
⊢ a / (a * a) = a⁻¹⁻¹ * a⁻¹ * a⁻¹
state_after: no goals
tactic: simp [mul_inv_rev]
Theorem: Localization.sub_mk
File: Mathlib/RingTheory/Localization/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝³ : CommRing R
M : Submonoid R
S : Type u_2
inst✝² : CommRing S
inst✝¹ : Algebra R S
P : Type u_3
inst✝ : CommRing P
a c : R
b d : ↥M
⊢ mk a b - mk c d = mk (↑d * a - ↑b * c) (b * d)
state_after: no goals
tactic: rw [sub_eq_add_neg, neg_mk, add_mk, add_comm, mul_neg, ← sub_eq_add_neg]
Theorem: Irrational.of_zpow
File: Mathlib/Data/Real/Irrational.lean

Proof steps:
state_before: q : ℚ
x y : ℝ
n : ℕ
h : Irrational (x ^ ↑n)
⊢ Irrational x
state_after: q : ℚ
x y : ℝ
n : ℕ
h : Irrational (x ^ n)
⊢ Irrational x
tactic: rw [zpow_natCast] at h
state_before: q : ℚ
x y : ℝ
n : ℕ
h : Irrational (x ^ n)
⊢ Irrational x
state_after: no goals
tactic: exact h.of_pow _
state_before: q : ℚ
x y : ℝ
n : ℕ
h : Irrational (x ^ -[n+1])
⊢ Irrational x
state_after: q : ℚ
x y : ℝ
n : ℕ
h : Irrational (x ^ (n + 1))⁻¹
⊢ Irrational x
tactic: rw [zpow_negSucc] at h
state_before: q : ℚ
x y : ℝ
n : ℕ
h : Irrational (x ^ (n + 1))⁻¹
⊢ Irrational x
state_after: no goals
tactic: exact h.of_inv.of_pow _
Theorem: MeasureTheory.Measure.condKernel_apply
File: Mathlib/Probability/Kernel/Disintegration/StandardBorel.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
Ω : Type u_4
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
inst✝⁵ : CountablyGenerated γ
inst✝⁴ : MeasurableSpace Ω
inst✝³ : StandardBorelSpace Ω
inst✝² : Nonempty Ω
ρ✝ : Measure (α × Ω)
inst✝¹ : IsFiniteMeasure ρ✝
ρ : Measure (α × Ω)
inst✝ : IsFiniteMeasure ρ
a : α
⊢ ρ.condKernel a = (const Unit ρ).condKernelUnitBorel ((), a)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
Ω : Type u_4
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
inst✝⁵ : CountablyGenerated γ
inst✝⁴ : MeasurableSpace Ω
inst✝³ : StandardBorelSpace Ω
inst✝² : Nonempty Ω
ρ✝ : Measure (α × Ω)
inst✝¹ : IsFiniteMeasure ρ✝
ρ : Measure (α × Ω)
inst✝ : IsFiniteMeasure ρ
a : α
⊢ ((const Unit ρ).condKernelUnitBorel.comap (fun a => ((), a)) ⋯) a = (const Unit ρ).condKernelUnitBorel ((), a)
tactic: rw [Measure.condKernel]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
Ω : Type u_4
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
inst✝⁵ : CountablyGenerated γ
inst✝⁴ : MeasurableSpace Ω
inst✝³ : StandardBorelSpace Ω
inst✝² : Nonempty Ω
ρ✝ : Measure (α × Ω)
inst✝¹ : IsFiniteMeasure ρ✝
ρ : Measure (α × Ω)
inst✝ : IsFiniteMeasure ρ
a : α
⊢ ((const Unit ρ).condKernelUnitBorel.comap (fun a => ((), a)) ⋯) a = (const Unit ρ).condKernelUnitBorel ((), a)
state_after: no goals
tactic: rfl
Theorem: Finset.not_mem_sigmaLift_of_ne_left
File: Mathlib/Data/Finset/Sigma.lean

Proof steps:
state_before: ι : Type u_1
α : ι → Type u_2
β : ι → Type u_3
γ : ι → Type u_4
inst✝ : DecidableEq ι
f : ⦃i : ι⦄ → α i → β i → Finset (γ i)
a : Sigma α
b : Sigma β
x : Sigma γ
h : a.fst ≠ x.fst
⊢ x ∉ sigmaLift f a b
state_after: ι : Type u_1
α : ι → Type u_2
β : ι → Type u_3
γ : ι → Type u_4
inst✝ : DecidableEq ι
f : ⦃i : ι⦄ → α i → β i → Finset (γ i)
a : Sigma α
b : Sigma β
x : Sigma γ
h : a.fst ≠ x.fst
⊢ ¬∃ (ha : a.fst = x.fst) (hb : b.fst = x.fst), x.snd ∈ f (ha ▸ a.snd) (hb ▸ b.snd)
tactic: rw [mem_sigmaLift]
state_before: ι : Type u_1
α : ι → Type u_2
β : ι → Type u_3
γ : ι → Type u_4
inst✝ : DecidableEq ι
f : ⦃i : ι⦄ → α i → β i → Finset (γ i)
a : Sigma α
b : Sigma β
x : Sigma γ
h : a.fst ≠ x.fst
⊢ ¬∃ (ha : a.fst = x.fst) (hb : b.fst = x.fst), x.snd ∈ f (ha ▸ a.snd) (hb ▸ b.snd)
state_after: no goals
tactic: exact fun H => h H.fst
Theorem: Finset.biUnion_nonempty
File: Mathlib/Data/Finset/Union.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s s₁ s₂ : Finset α
t t₁ t₂ : α → Finset β
inst✝ : DecidableEq β
⊢ (s.biUnion t).Nonempty ↔ ∃ x ∈ s, (t x).Nonempty
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
s s₁ s₂ : Finset α
t t₁ t₂ : α → Finset β
inst✝ : DecidableEq β
⊢ (∃ x, ∃ a ∈ s, x ∈ t a) ↔ ∃ x ∈ s, ∃ x_1, x_1 ∈ t x
tactic: simp only [Finset.Nonempty, mem_biUnion]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s s₁ s₂ : Finset α
t t₁ t₂ : α → Finset β
inst✝ : DecidableEq β
⊢ (∃ x, ∃ a ∈ s, x ∈ t a) ↔ ∃ x ∈ s, ∃ x_1, x_1 ∈ t x
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
s s₁ s₂ : Finset α
t t₁ t₂ : α → Finset β
inst✝ : DecidableEq β
⊢ (∃ y x, y ∈ s ∧ x ∈ t y) ↔ ∃ x ∈ s, ∃ x_1, x_1 ∈ t x
tactic: rw [exists_swap]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s s₁ s₂ : Finset α
t t₁ t₂ : α → Finset β
inst✝ : DecidableEq β
⊢ (∃ y x, y ∈ s ∧ x ∈ t y) ↔ ∃ x ∈ s, ∃ x_1, x_1 ∈ t x
state_after: no goals
tactic: simp [exists_and_left]
Theorem: one_add_mul_self_le_rpow_one_add
File: Mathlib/Analysis/Convex/SpecificFunctions/Basic.lean

Proof steps:
state_before: s : ℝ
hs : -1 ≤ s
p : ℝ
hp : 1 ≤ p
⊢ 1 + p * s ≤ (1 + s) ^ p
state_after: case inl
s : ℝ
hs : -1 ≤ s
hp : 1 ≤ 1
⊢ 1 + 1 * s ≤ (1 + s) ^ 1

case inr
s : ℝ
hs : -1 ≤ s
p : ℝ
hp✝ : 1 ≤ p
hp : 1 < p
⊢ 1 + p * s ≤ (1 + s) ^ p
tactic: rcases eq_or_lt_of_le hp with (rfl | hp)
state_before: case inr
s : ℝ
hs : -1 ≤ s
p : ℝ
hp✝ : 1 ≤ p
hp : 1 < p
⊢ 1 + p * s ≤ (1 + s) ^ p
state_after: case pos
s : ℝ
hs : -1 ≤ s
p : ℝ
hp✝ : 1 ≤ p
hp : 1 < p
hs' : s = 0
⊢ 1 + p * s ≤ (1 + s) ^ p

case neg
s : ℝ
hs : -1 ≤ s
p : ℝ
hp✝ : 1 ≤ p
hp : 1 < p
hs' : ¬s = 0
⊢ 1 + p * s ≤ (1 + s) ^ p
tactic: by_cases hs' : s = 0
state_before: case neg
s : ℝ
hs : -1 ≤ s
p : ℝ
hp✝ : 1 ≤ p
hp : 1 < p
hs' : ¬s = 0
⊢ 1 + p * s ≤ (1 + s) ^ p
state_after: no goals
tactic: exact (one_add_mul_self_lt_rpow_one_add hs hs' hp).le
Theorem: BoxIntegral.TaggedPrepartition.IsHenstock.disjUnion
File: Mathlib/Analysis/BoxIntegral/Partition/Tagged.lean

Proof steps:
state_before: ι : Type u_1
I J : Box ι
π π₁ π₂ : TaggedPrepartition I
x : ι → ℝ
r r₁ r₂ : (ι → ℝ) → ↑(Ioi 0)
h₁ : π₁.IsHenstock
h₂ : π₂.IsHenstock
h : Disjoint π₁.iUnion π₂.iUnion
⊢ (π₁.disjUnion π₂ h).IsHenstock
state_after: case refine_1
ι : Type u_1
I J✝ : Box ι
π π₁ π₂ : TaggedPrepartition I
x : ι → ℝ
r r₁ r₂ : (ι → ℝ) → ↑(Ioi 0)
h₁ : π₁.IsHenstock
h₂ : π₂.IsHenstock
h : Disjoint π₁.iUnion π₂.iUnion
J : Box ι
hJ✝ : J ∈ π₁.disjUnion π₂ h
hJ : J ∈ π₁.boxes
⊢ (π₁.disjUnion π₂ h).tag J ∈ Box.Icc J

case refine_2
ι : Type u_1
I J✝ : Box ι
π π₁ π₂ : TaggedPrepartition I
x : ι → ℝ
r r₁ r₂ : (ι → ℝ) → ↑(Ioi 0)
h₁ : π₁.IsHenstock
h₂ : π₂.IsHenstock
h : Disjoint π₁.iUnion π₂.iUnion
J : Box ι
hJ✝ : J ∈ π₁.disjUnion π₂ h
hJ : J ∈ π₂.boxes
⊢ (π₁.disjUnion π₂ h).tag J ∈ Box.Icc J
tactic: refine fun J hJ => (Finset.mem_union.1 hJ).elim (fun hJ => ?_) fun hJ => ?_
Theorem: eq_zero_of_add_left
File: Mathlib/Algebra/Group/Units.lean

Proof steps:
state_before: α : Type u
inst✝¹ : CommMonoid α
inst✝ : Subsingleton αˣ
a b : α
h : a * b = 1
⊢ b * a = 1
state_after: no goals
tactic: rwa [mul_comm]
Theorem: CategoryTheory.Limits.biproduct.whiskerEquiv_hom
File: Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean

Proof steps:
state_before: J : Type w
K : Type u_1
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
f : J → C
g : K → C
e : J ≃ K
w : (j : J) → g (e j) ≅ f j
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct g
k : K
⊢ g k = g (e (e.symm k))
state_after: no goals
tactic: simp