1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: MonoidHom.FixedPointFree.coe_eq_inv_of_sq_eq_one
File: Mathlib/GroupTheory/FixedPointFree.lean

tactic: ext g
state_before: G : Type u_1
inst✝¹ : Group G
φ : G →* G
hφ : FixedPointFree ⇑φ
inst✝ : Finite G
h2 : (⇑φ)^[2] = _root_.id
⊢ ⇑φ = fun x => x⁻¹
state_after: case h
G : Type u_1
inst✝¹ : Group G
φ : G →* G
hφ : FixedPointFree ⇑φ
inst✝ : Finite G
h2 : (⇑φ)^[2] = _root_.id
g : G
⊢ φ g = g⁻¹

tactic: have key : 1 * g * φ g = 1 := hφ.prod_pow_eq_one h2 g
state_before: case h
G : Type u_1
inst✝¹ : Group G
φ : G →* G
hφ : FixedPointFree ⇑φ
inst✝ : Finite G
h2 : (⇑φ)^[2] = _root_.id
g : G
⊢ φ g = g⁻¹
state_after: case h
G : Type u_1
inst✝¹ : Group G
φ : G →* G
hφ : FixedPointFree ⇑φ
inst✝ : Finite G
h2 : (⇑φ)^[2] = _root_.id
g : G
key : 1 * g * φ g = 1
⊢ φ g = g⁻¹

tactic: rwa [one_mul, ← inv_eq_iff_mul_eq_one, eq_comm] at key
state_before: case h
G : Type u_1
inst✝¹ : Group G
φ : G →* G
hφ : FixedPointFree ⇑φ
inst✝ : Finite G
h2 : (⇑φ)^[2] = _root_.id
g : G
key : 1 * g * φ g = 1
⊢ φ g = g⁻¹
state_after: no goals
Theorem: DifferentiableAt.dist
File: Mathlib/Analysis/InnerProductSpace/Calculus.lean

tactic: simp only [dist_eq_norm]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁷ : _root_.RCLike 𝕜
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
inst✝² : NormedSpace ℝ E
G : Type u_4
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace ℝ G
f g : G → E
f' g' : G →L[ℝ] E
s : Set G
x : G
n : ℕ∞
hf : DifferentiableAt ℝ f x
hg : DifferentiableAt ℝ g x
hne : f x ≠ g x
⊢ DifferentiableAt ℝ (fun y => Dist.dist (f y) (g y)) x
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁷ : _root_.RCLike 𝕜
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
inst✝² : NormedSpace ℝ E
G : Type u_4
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace ℝ G
f g : G → E
f' g' : G →L[ℝ] E
s : Set G
x : G
n : ℕ∞
hf : DifferentiableAt ℝ f x
hg : DifferentiableAt ℝ g x
hne : f x ≠ g x
⊢ DifferentiableAt ℝ (fun y => ‖f y - g y‖) x

tactic: exact (hf.sub hg).norm 𝕜 (sub_ne_zero.2 hne)
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁷ : _root_.RCLike 𝕜
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
inst✝² : NormedSpace ℝ E
G : Type u_4
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace ℝ G
f g : G → E
f' g' : G →L[ℝ] E
s : Set G
x : G
n : ℕ∞
hf : DifferentiableAt ℝ f x
hg : DifferentiableAt ℝ g x
hne : f x ≠ g x
⊢ DifferentiableAt ℝ (fun y => ‖f y - g y‖) x
state_after: no goals
Theorem: Polynomial.not_isUnit_of_natDegree_pos_of_isReduced
File: Mathlib/RingTheory/Polynomial/Nilpotent.lean

tactic: simp only [ne_eq, isNilpotent_iff_eq_zero, not_and, not_forall, exists_prop,
  Polynomial.isUnit_iff_coeff_isUnit_isNilpotent]
state_before: R : Type u_1
r : R
inst✝¹ : CommRing R
P : R[X]
inst✝ : IsReduced R
p : R[X]
hpl : 0 < p.natDegree
⊢ ¬IsUnit p
state_after: R : Type u_1
r : R
inst✝¹ : CommRing R
P : R[X]
inst✝ : IsReduced R
p : R[X]
hpl : 0 < p.natDegree
⊢ IsUnit (p.coeff 0) → ∃ x, ¬x = 0 ∧ ¬p.coeff x = 0

tactic: intro _
state_before: R : Type u_1
r : R
inst✝¹ : CommRing R
P : R[X]
inst✝ : IsReduced R
p : R[X]
hpl : 0 < p.natDegree
⊢ IsUnit (p.coeff 0) → ∃ x, ¬x = 0 ∧ ¬p.coeff x = 0
state_after: R : Type u_1
r : R
inst✝¹ : CommRing R
P : R[X]
inst✝ : IsReduced R
p : R[X]
hpl : 0 < p.natDegree
a✝ : IsUnit (p.coeff 0)
⊢ ∃ x, ¬x = 0 ∧ ¬p.coeff x = 0

tactic: refine ⟨p.natDegree, hpl.ne', ?_⟩
state_before: R : Type u_1
r : R
inst✝¹ : CommRing R
P : R[X]
inst✝ : IsReduced R
p : R[X]
hpl : 0 < p.natDegree
a✝ : IsUnit (p.coeff 0)
⊢ ∃ x, ¬x = 0 ∧ ¬p.coeff x = 0
state_after: R : Type u_1
r : R
inst✝¹ : CommRing R
P : R[X]
inst✝ : IsReduced R
p : R[X]
hpl : 0 < p.natDegree
a✝ : IsUnit (p.coeff 0)
⊢ ¬p.coeff p.natDegree = 0

tactic: contrapose! hpl
state_before: R : Type u_1
r : R
inst✝¹ : CommRing R
P : R[X]
inst✝ : IsReduced R
p : R[X]
hpl : 0 < p.natDegree
a✝ : IsUnit (p.coeff 0)
⊢ ¬p.coeff p.natDegree = 0
state_after: R : Type u_1
r : R
inst✝¹ : CommRing R
P : R[X]
inst✝ : IsReduced R
p : R[X]
a✝ : IsUnit (p.coeff 0)
hpl : p.coeff p.natDegree = 0
⊢ p.natDegree ≤ 0

tactic: simp only [coeff_natDegree, leadingCoeff_eq_zero] at hpl
state_before: R : Type u_1
r : R
inst✝¹ : CommRing R
P : R[X]
inst✝ : IsReduced R
p : R[X]
a✝ : IsUnit (p.coeff 0)
hpl : p.coeff p.natDegree = 0
⊢ p.natDegree ≤ 0
state_after: R : Type u_1
r : R
inst✝¹ : CommRing R
P : R[X]
inst✝ : IsReduced R
p : R[X]
a✝ : IsUnit (p.coeff 0)
hpl : p = 0
⊢ p.natDegree ≤ 0

tactic: simp [hpl]
state_before: R : Type u_1
r : R
inst✝¹ : CommRing R
P : R[X]
inst✝ : IsReduced R
p : R[X]
a✝ : IsUnit (p.coeff 0)
hpl : p = 0
⊢ p.natDegree ≤ 0
state_after: no goals
Theorem: Metric.ball_subset_thickening
File: Mathlib/Topology/MetricSpace/Thickening.lean

tactic: simp [Subset.rfl]
state_before: ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
δ✝ : ℝ
s : Set α
x✝ : α
X : Type u
inst✝ : PseudoMetricSpace X
x : X
E : Set X
hx : x ∈ E
δ : ℝ
⊢ ball x δ ⊆ thickening δ {x}
state_after: no goals
Theorem: wittStructureInt_vars
File: Mathlib/RingTheory/WittVector/StructurePolynomial.lean

tactic: have : Function.Injective (Int.castRingHom ℚ) := Int.cast_injective
state_before: p : ℕ
R : Type u_1
idx : Type u_2
inst✝¹ : CommRing R
hp : Fact (Nat.Prime p)
inst✝ : Fintype idx
Φ : MvPolynomial idx ℤ
n : ℕ
⊢ (wittStructureInt p Φ n).vars ⊆ Finset.univ ×ˢ Finset.range (n + 1)
state_after: p : ℕ
R : Type u_1
idx : Type u_2
inst✝¹ : CommRing R
hp : Fact (Nat.Prime p)
inst✝ : Fintype idx
Φ : MvPolynomial idx ℤ
n : ℕ
this : Function.Injective ⇑(Int.castRingHom ℚ)
⊢ (wittStructureInt p Φ n).vars ⊆ Finset.univ ×ˢ Finset.range (n + 1)

tactic: rw [← vars_map_of_injective _ this, map_wittStructureInt]
state_before: p : ℕ
R : Type u_1
idx : Type u_2
inst✝¹ : CommRing R
hp : Fact (Nat.Prime p)
inst✝ : Fintype idx
Φ : MvPolynomial idx ℤ
n : ℕ
this : Function.Injective ⇑(Int.castRingHom ℚ)
⊢ (wittStructureInt p Φ n).vars ⊆ Finset.univ ×ˢ Finset.range (n + 1)
state_after: p : ℕ
R : Type u_1
idx : Type u_2
inst✝¹ : CommRing R
hp : Fact (Nat.Prime p)
inst✝ : Fintype idx
Φ : MvPolynomial idx ℤ
n : ℕ
this : Function.Injective ⇑(Int.castRingHom ℚ)
⊢ (wittStructureRat p ((map (Int.castRingHom ℚ)) Φ) n).vars ⊆ Finset.univ ×ˢ Finset.range (n + 1)

tactic: apply wittStructureRat_vars
state_before: p : ℕ
R : Type u_1
idx : Type u_2
inst✝¹ : CommRing R
hp : Fact (Nat.Prime p)
inst✝ : Fintype idx
Φ : MvPolynomial idx ℤ
n : ℕ
this : Function.Injective ⇑(Int.castRingHom ℚ)
⊢ (wittStructureRat p ((map (Int.castRingHom ℚ)) Φ) n).vars ⊆ Finset.univ ×ˢ Finset.range (n + 1)
state_after: no goals
Theorem: Set.LeftInvOn.filter_map_Iic
File: Mathlib/Order/Filter/Basic.lean

tactic: have : (g ∘ f) =ᶠ[𝓟 s] id := by simpa only [eventuallyEq_principal] using hfg
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f✝ f₁ f₂ : Filter α
g✝ g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
f : α → β
g : β → α
hfg : LeftInvOn g f s
F : Filter α
hF : F ≤ 𝓟 s
⊢ map g (map f F) = F
state_after: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f✝ f₁ f₂ : Filter α
g✝ g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
f : α → β
g : β → α
hfg : LeftInvOn g f s
F : Filter α
hF : F ≤ 𝓟 s
this : g ∘ f =ᶠ[𝓟 s] id
⊢ map g (map f F) = F

tactic: rw [map_map, map_congr (this.filter_mono hF), map_id]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f✝ f₁ f₂ : Filter α
g✝ g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
f : α → β
g : β → α
hfg : LeftInvOn g f s
F : Filter α
hF : F ≤ 𝓟 s
this : g ∘ f =ᶠ[𝓟 s] id
⊢ map g (map f F) = F
state_after: no goals

tactic: simpa only [eventuallyEq_principal] using hfg
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f✝ f₁ f₂ : Filter α
g✝ g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
f : α → β
g : β → α
hfg : LeftInvOn g f s
F : Filter α
hF : F ≤ 𝓟 s
⊢ g ∘ f =ᶠ[𝓟 s] id
state_after: no goals
Theorem: half_lt_self_iff
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: rw [div_lt_iff (zero_lt_two' α), mul_two, lt_add_iff_pos_left]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
⊢ a / 2 < a ↔ 0 < a
state_after: no goals
Theorem: Submodule.exists_finset_of_mem_iSup
File: Mathlib/LinearAlgebra/Finsupp.lean

tactic: have :=
  CompleteLattice.IsCompactElement.exists_finset_of_le_iSup (Submodule R M)
    (Submodule.singleton_span_isCompactElement m) p
state_before: R : Type u_1
M : Type u_2
N : Type u_3
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid N
inst✝ : Module R N
ι : Type u_4
p : ι → Submodule R M
m : M
hm : m ∈ ⨆ i, p i
⊢ ∃ s, m ∈ ⨆ i ∈ s, p i
state_after: R : Type u_1
M : Type u_2
N : Type u_3
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid N
inst✝ : Module R N
ι : Type u_4
p : ι → Submodule R M
m : M
hm : m ∈ ⨆ i, p i
this : span R {m} ≤ ⨆ i, p i → ∃ s, span R {m} ≤ ⨆ i ∈ s, p i
⊢ ∃ s, m ∈ ⨆ i ∈ s, p i

tactic: simp only [Submodule.span_singleton_le_iff_mem] at this
state_before: R : Type u_1
M : Type u_2
N : Type u_3
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid N
inst✝ : Module R N
ι : Type u_4
p : ι → Submodule R M
m : M
hm : m ∈ ⨆ i, p i
this : span R {m} ≤ ⨆ i, p i → ∃ s, span R {m} ≤ ⨆ i ∈ s, p i
⊢ ∃ s, m ∈ ⨆ i ∈ s, p i
state_after: R : Type u_1
M : Type u_2
N : Type u_3
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid N
inst✝ : Module R N
ι : Type u_4
p : ι → Submodule R M
m : M
hm : m ∈ ⨆ i, p i
this : m ∈ ⨆ i, p i → ∃ s, m ∈ ⨆ i ∈ s, p i
⊢ ∃ s, m ∈ ⨆ i ∈ s, p i

tactic: exact this hm
state_before: R : Type u_1
M : Type u_2
N : Type u_3
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid N
inst✝ : Module R N
ι : Type u_4
p : ι → Submodule R M
m : M
hm : m ∈ ⨆ i, p i
this : m ∈ ⨆ i, p i → ∃ s, m ∈ ⨆ i ∈ s, p i
⊢ ∃ s, m ∈ ⨆ i ∈ s, p i
state_after: no goals
Theorem: Pell.x_sub_y_dvd_pow
File: Mathlib/NumberTheory/PellMatiyasevic.lean

tactic: simp [xz, yz, Int.ofNat_zero, Int.ofNat_one]
state_before: a : ℕ
a1 : 1 < a
y : ℕ
⊢ 2 * ↑a * ↑y - ↑y * ↑y - 1 ∣ yz a1 0 * (↑a - ↑y) + ↑(y ^ 0) - xz a1 0
state_after: no goals

tactic: simp [xz, yz, Int.ofNat_zero, Int.ofNat_one]
state_before: a : ℕ
a1 : 1 < a
y : ℕ
⊢ 2 * ↑a * ↑y - ↑y * ↑y - 1 ∣ yz a1 1 * (↑a - ↑y) + ↑(y ^ 1) - xz a1 1
state_after: no goals

tactic: have : (2 * a * y - y * y - 1 : ℤ) ∣ ↑(y ^ (n + 2)) - ↑(2 * a) * ↑(y ^ (n + 1)) + ↑(y ^ n) :=
  ⟨-↑(y ^ n), by
    simp [_root_.pow_succ, mul_add, Int.ofNat_mul, show ((2 : ℕ) : ℤ) = 2 from rfl, mul_comm,
      mul_left_comm]
    ring⟩
state_before: a : ℕ
a1 : 1 < a
y n : ℕ
⊢ 2 * ↑a * ↑y - ↑y * ↑y - 1 ∣ yz a1 (n + 2) * (↑a - ↑y) + ↑(y ^ (n + 2)) - xz a1 (n + 2)
state_after: a : ℕ
a1 : 1 < a
y n : ℕ
this : 2 * ↑a * ↑y - ↑y * ↑y - 1 ∣ ↑(y ^ (n + 2)) - ↑(2 * a) * ↑(y ^ (n + 1)) + ↑(y ^ n)
⊢ 2 * ↑a * ↑y - ↑y * ↑y - 1 ∣ yz a1 (n + 2) * (↑a - ↑y) + ↑(y ^ (n + 2)) - xz a1 (n + 2)

tactic: rw [xz_succ_succ, yz_succ_succ, x_sub_y_dvd_pow_lem ↑(y ^ (n + 2)) ↑(y ^ (n + 1)) ↑(y ^ n)]
state_before: a : ℕ
a1 : 1 < a
y n : ℕ
this : 2 * ↑a * ↑y - ↑y * ↑y - 1 ∣ ↑(y ^ (n + 2)) - ↑(2 * a) * ↑(y ^ (n + 1)) + ↑(y ^ n)
⊢ 2 * ↑a * ↑y - ↑y * ↑y - 1 ∣ yz a1 (n + 2) * (↑a - ↑y) + ↑(y ^ (n + 2)) - xz a1 (n + 2)
state_after: a : ℕ
a1 : 1 < a
y n : ℕ
this : 2 * ↑a * ↑y - ↑y * ↑y - 1 ∣ ↑(y ^ (n + 2)) - ↑(2 * a) * ↑(y ^ (n + 1)) + ↑(y ^ n)
⊢ 2 * ↑a * ↑y - ↑y * ↑y - 1 ∣
    ↑(y ^ (n + 2)) - ↑(2 * a) * ↑(y ^ (n + 1)) + ↑(y ^ n) +
        ↑(2 * a) * (yz a1 (n + 1) * (↑a - ↑y) + ↑(y ^ (n + 1)) - xz a1 (n + 1)) -
      (yz a1 n * (↑a - ↑y) + ↑(y ^ n) - xz a1 n)

tactic: exact _root_.dvd_sub (dvd_add this <| (x_sub_y_dvd_pow _ (n + 1)).mul_left _)
  (x_sub_y_dvd_pow _ n)
state_before: a : ℕ
a1 : 1 < a
y n : ℕ
this : 2 * ↑a * ↑y - ↑y * ↑y - 1 ∣ ↑(y ^ (n + 2)) - ↑(2 * a) * ↑(y ^ (n + 1)) + ↑(y ^ n)
⊢ 2 * ↑a * ↑y - ↑y * ↑y - 1 ∣
    ↑(y ^ (n + 2)) - ↑(2 * a) * ↑(y ^ (n + 1)) + ↑(y ^ n) +
        ↑(2 * a) * (yz a1 (n + 1) * (↑a - ↑y) + ↑(y ^ (n + 1)) - xz a1 (n + 1)) -
      (yz a1 n * (↑a - ↑y) + ↑(y ^ n) - xz a1 n)
state_after: no goals

tactic: simp [_root_.pow_succ, mul_add, Int.ofNat_mul, show ((2 : ℕ) : ℤ) = 2 from rfl, mul_comm,
  mul_left_comm]
state_before: a : ℕ
a1 : 1 < a
y n : ℕ
⊢ ↑(y ^ (n + 2)) - ↑(2 * a) * ↑(y ^ (n + 1)) + ↑(y ^ n) = (2 * ↑a * ↑y - ↑y * ↑y - 1) * -↑(y ^ n)
state_after: a : ℕ
a1 : 1 < a
y n : ℕ
⊢ ↑y * (↑y * ↑y ^ n) - ↑a * (↑y * ↑y ^ n * 2) + ↑y ^ n = -(↑y ^ n * (↑a * (↑y * 2) - ↑y * ↑y - 1))

tactic: ring
state_before: a : ℕ
a1 : 1 < a
y n : ℕ
⊢ ↑y * (↑y * ↑y ^ n) - ↑a * (↑y * ↑y ^ n * 2) + ↑y ^ n = -(↑y ^ n * (↑a * (↑y * 2) - ↑y * ↑y - 1))
state_after: no goals
Theorem: OrdinalApprox.lfpApprox_ord_mem_fixedPoint
File: Mathlib/SetTheory/Ordinal/FixedPointApproximants.lean

tactic: let ⟨a, h_a, b, h_b, h_nab, h_fab⟩ := exists_lfpApprox_eq_lfpApprox f x
state_before: α : Type u
inst✝ : CompleteLattice α
f : α →o α
x : α
h_init : x ≤ f x
⊢ lfpApprox f x (succ #α).ord ∈ fixedPoints ⇑f
state_after: α : Type u
inst✝ : CompleteLattice α
f : α →o α
x : α
h_init : x ≤ f x
a : Ordinal.{u}
h_a : a < (succ #α).ord
b : Ordinal.{u}
h_b : b < (succ #α).ord
h_nab : a ≠ b
h_fab : lfpApprox f x a = lfpApprox f x b
⊢ lfpApprox f x (succ #α).ord ∈ fixedPoints ⇑f

tactic: cases le_total a b with
| inl h_ab =>
  exact lfpApprox_mem_fixedPoints_of_eq f x h_init
    (h_nab.lt_of_le h_ab) (le_of_lt h_a) h_fab
| inr h_ba =>
  exact lfpApprox_mem_fixedPoints_of_eq f x h_init
    (h_nab.symm.lt_of_le h_ba) (le_of_lt h_b) (h_fab.symm)
state_before: α : Type u
inst✝ : CompleteLattice α
f : α →o α
x : α
h_init : x ≤ f x
a : Ordinal.{u}
h_a : a < (succ #α).ord
b : Ordinal.{u}
h_b : b < (succ #α).ord
h_nab : a ≠ b
h_fab : lfpApprox f x a = lfpApprox f x b
⊢ lfpApprox f x (succ #α).ord ∈ fixedPoints ⇑f
state_after: no goals

tactic: exact lfpApprox_mem_fixedPoints_of_eq f x h_init
  (h_nab.lt_of_le h_ab) (le_of_lt h_a) h_fab
state_before: case inl
α : Type u
inst✝ : CompleteLattice α
f : α →o α
x : α
h_init : x ≤ f x
a : Ordinal.{u}
h_a : a < (succ #α).ord
b : Ordinal.{u}
h_b : b < (succ #α).ord
h_nab : a ≠ b
h_fab : lfpApprox f x a = lfpApprox f x b
h_ab : a ≤ b
⊢ lfpApprox f x (succ #α).ord ∈ fixedPoints ⇑f
state_after: no goals

tactic: exact lfpApprox_mem_fixedPoints_of_eq f x h_init
  (h_nab.symm.lt_of_le h_ba) (le_of_lt h_b) (h_fab.symm)
state_before: case inr
α : Type u
inst✝ : CompleteLattice α
f : α →o α
x : α
h_init : x ≤ f x
a : Ordinal.{u}
h_a : a < (succ #α).ord
b : Ordinal.{u}
h_b : b < (succ #α).ord
h_nab : a ≠ b
h_fab : lfpApprox f x a = lfpApprox f x b
h_ba : b ≤ a
⊢ lfpApprox f x (succ #α).ord ∈ fixedPoints ⇑f
state_after: no goals
Theorem: SetTheory.Game.not_le
File: Mathlib/SetTheory/Game/Basic.lean

tactic: rintro ⟨x⟩ ⟨y⟩
state_before: ⊢ ∀ {x y : Game}, ¬x ≤ y ↔ y ⧏ x
state_after: case mk.mk
x✝ : Game
x : PGame
y✝ : Game
y : PGame
⊢ ¬Quot.mk Setoid.r x ≤ Quot.mk Setoid.r y ↔ Quot.mk Setoid.r y ⧏ Quot.mk Setoid.r x

tactic: exact PGame.not_le
state_before: case mk.mk
x✝ : Game
x : PGame
y✝ : Game
y : PGame
⊢ ¬Quot.mk Setoid.r x ≤ Quot.mk Setoid.r y ↔ Quot.mk Setoid.r y ⧏ Quot.mk Setoid.r x
state_after: no goals
Theorem: ZNum.cast_inj
File: Mathlib/Data/Num/Lemmas.lean

tactic: rw [← cast_to_int m, ← cast_to_int n, Int.cast_inj (α := α), to_int_inj]
state_before: α : Type u_1
inst✝ : LinearOrderedRing α
m n : ZNum
⊢ ↑m = ↑n ↔ m = n
state_after: no goals
Theorem: deriv.lhopital_zero_nhds
File: Mathlib/Analysis/Calculus/LHopital.lean

tactic: apply lhopital_zero_nhds' <;>
  (first | apply eventually_nhdsWithin_of_eventually_nhds |
    apply tendsto_nhdsWithin_of_tendsto_nhds) <;> assumption
state_before: a b : ℝ
hab : a < b
l : Filter ℝ
f f' g g' : ℝ → ℝ
hdf : ∀ᶠ (x : ℝ) in 𝓝 a, DifferentiableAt ℝ f x
hg' : ∀ᶠ (x : ℝ) in 𝓝 a, deriv g x ≠ 0
hfa : Tendsto f (𝓝 a) (𝓝 0)
hga : Tendsto g (𝓝 a) (𝓝 0)
hdiv : Tendsto (fun x => deriv f x / deriv g x) (𝓝 a) l
⊢ Tendsto (fun x => f x / g x) (𝓝[≠] a) l
state_after: no goals

tactic: first | apply eventually_nhdsWithin_of_eventually_nhds |
 apply tendsto_nhdsWithin_of_tendsto_nhds
state_before: case hdiv
a b : ℝ
hab : a < b
l : Filter ℝ
f f' g g' : ℝ → ℝ
hdf : ∀ᶠ (x : ℝ) in 𝓝 a, DifferentiableAt ℝ f x
hg' : ∀ᶠ (x : ℝ) in 𝓝 a, deriv g x ≠ 0
hfa : Tendsto f (𝓝 a) (𝓝 0)
hga : Tendsto g (𝓝 a) (𝓝 0)
hdiv : Tendsto (fun x => deriv f x / deriv g x) (𝓝 a) l
⊢ Tendsto (fun x => deriv f x / deriv g x) (𝓝[≠] a) l
state_after: case hdiv.h
a b : ℝ
hab : a < b
l : Filter ℝ
f f' g g' : ℝ → ℝ
hdf : ∀ᶠ (x : ℝ) in 𝓝 a, DifferentiableAt ℝ f x
hg' : ∀ᶠ (x : ℝ) in 𝓝 a, deriv g x ≠ 0
hfa : Tendsto f (𝓝 a) (𝓝 0)
hga : Tendsto g (𝓝 a) (𝓝 0)
hdiv : Tendsto (fun x => deriv f x / deriv g x) (𝓝 a) l
⊢ Tendsto (fun x => deriv f x / deriv g x) (𝓝 a) l

tactic: apply eventually_nhdsWithin_of_eventually_nhds
state_before: case hg'
a b : ℝ
hab : a < b
l : Filter ℝ
f f' g g' : ℝ → ℝ
hdf : ∀ᶠ (x : ℝ) in 𝓝 a, DifferentiableAt ℝ f x
hg' : ∀ᶠ (x : ℝ) in 𝓝 a, deriv g x ≠ 0
hfa : Tendsto f (𝓝 a) (𝓝 0)
hga : Tendsto g (𝓝 a) (𝓝 0)
hdiv : Tendsto (fun x => deriv f x / deriv g x) (𝓝 a) l
⊢ ∀ᶠ (x : ℝ) in 𝓝[≠] a, deriv g x ≠ 0
state_after: case hg'.h
a b : ℝ
hab : a < b
l : Filter ℝ
f f' g g' : ℝ → ℝ
hdf : ∀ᶠ (x : ℝ) in 𝓝 a, DifferentiableAt ℝ f x
hg' : ∀ᶠ (x : ℝ) in 𝓝 a, deriv g x ≠ 0
hfa : Tendsto f (𝓝 a) (𝓝 0)
hga : Tendsto g (𝓝 a) (𝓝 0)
hdiv : Tendsto (fun x => deriv f x / deriv g x) (𝓝 a) l
⊢ ∀ᶠ (x : ℝ) in 𝓝 a, deriv g x ≠ 0

tactic: apply tendsto_nhdsWithin_of_tendsto_nhds
state_before: case hdiv
a b : ℝ
hab : a < b
l : Filter ℝ
f f' g g' : ℝ → ℝ
hdf : ∀ᶠ (x : ℝ) in 𝓝 a, DifferentiableAt ℝ f x
hg' : ∀ᶠ (x : ℝ) in 𝓝 a, deriv g x ≠ 0
hfa : Tendsto f (𝓝 a) (𝓝 0)
hga : Tendsto g (𝓝 a) (𝓝 0)
hdiv : Tendsto (fun x => deriv f x / deriv g x) (𝓝 a) l
⊢ Tendsto (fun x => deriv f x / deriv g x) (𝓝[≠] a) l
state_after: case hdiv.h
a b : ℝ
hab : a < b
l : Filter ℝ
f f' g g' : ℝ → ℝ
hdf : ∀ᶠ (x : ℝ) in 𝓝 a, DifferentiableAt ℝ f x
hg' : ∀ᶠ (x : ℝ) in 𝓝 a, deriv g x ≠ 0
hfa : Tendsto f (𝓝 a) (𝓝 0)
hga : Tendsto g (𝓝 a) (𝓝 0)
hdiv : Tendsto (fun x => deriv f x / deriv g x) (𝓝 a) l
⊢ Tendsto (fun x => deriv f x / deriv g x) (𝓝 a) l
Theorem: liftOfDerivationToSquareZero_mk_apply
File: Mathlib/RingTheory/Derivation/ToSquareZero.lean

tactic: rw [liftOfDerivationToSquareZero_apply, map_add, Ideal.Quotient.eq_zero_iff_mem.mpr (d x).prop,
  zero_add]
state_before: R : Type u
A : Type v
B : Type w
inst✝⁶ : CommSemiring R
inst✝⁵ : CommSemiring A
inst✝⁴ : CommRing B
inst✝³ : Algebra R A
inst✝² : Algebra R B
I : Ideal B
hI : I ^ 2 = ⊥
inst✝¹ : Algebra A B
inst✝ : IsScalarTower R A B
d : Derivation R A ↥I
x : A
⊢ (Ideal.Quotient.mk I) ((liftOfDerivationToSquareZero I hI d) x) = (algebraMap A (B ⧸ I)) x
state_after: R : Type u
A : Type v
B : Type w
inst✝⁶ : CommSemiring R
inst✝⁵ : CommSemiring A
inst✝⁴ : CommRing B
inst✝³ : Algebra R A
inst✝² : Algebra R B
I : Ideal B
hI : I ^ 2 = ⊥
inst✝¹ : Algebra A B
inst✝ : IsScalarTower R A B
d : Derivation R A ↥I
x : A
⊢ (Ideal.Quotient.mk I) ((algebraMap A B) x) = (algebraMap A (B ⧸ I)) x

tactic: rfl
state_before: R : Type u
A : Type v
B : Type w
inst✝⁶ : CommSemiring R
inst✝⁵ : CommSemiring A
inst✝⁴ : CommRing B
inst✝³ : Algebra R A
inst✝² : Algebra R B
I : Ideal B
hI : I ^ 2 = ⊥
inst✝¹ : Algebra A B
inst✝ : IsScalarTower R A B
d : Derivation R A ↥I
x : A
⊢ (Ideal.Quotient.mk I) ((algebraMap A B) x) = (algebraMap A (B ⧸ I)) x
state_after: no goals
Theorem: mul_lt_of_lt_one_left
File: Mathlib/Algebra/Order/GroupWithZero/Unbundled.lean

tactic: simpa only [one_mul] using mul_lt_mul_of_pos_right h hb
state_before: α : Type u_1
a b c d : α
inst✝³ : MulOneClass α
inst✝² : Zero α
inst✝¹ : Preorder α
inst✝ : MulPosStrictMono α
hb : 0 < b
h : a < 1
⊢ a * b < b
state_after: no goals
Theorem: MeasureTheory.Memℒp.sub
File: Mathlib/MeasureTheory/Function/LpSeminorm/TriangleInequality.lean

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: α : 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: exact hf.add hg.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
Theorem: Ordering.swap_then
File: .lake/packages/batteries/Batteries/Classes/Order.lean

tactic: cases o₁ <;> rfl
state_before: o₁ o₂ : Ordering
⊢ (o₁.then o₂).swap = o₁.swap.then o₂.swap
state_after: no goals
Theorem: circleIntegral.integral_smul_const
File: Mathlib/MeasureTheory/Integral/CircleIntegral.lean

tactic: simp only [circleIntegral, intervalIntegral.integral_smul_const, ← smul_assoc]
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ → ℂ
a : E
c : ℂ
R : ℝ
⊢ (∮ (z : ℂ) in C(c, R), f z • a) = (∮ (z : ℂ) in C(c, R), f z) • a
state_after: no goals
Theorem: inv_div
File: Mathlib/Algebra/Group/Basic.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : DivisionMonoid α
a b c d : α
⊢ (a / b)⁻¹ = b / a
state_after: no goals
Theorem: inv_mul_cancel_right₀
File: Mathlib/Algebra/GroupWithZero/Basic.lean

tactic: simp [h]
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 g h✝ x : G₀
h : b ≠ 0
a : G₀
⊢ a * (b⁻¹ * b) = a
state_after: no goals
Theorem: Cardinal.add_eq_right
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

tactic: rw [add_comm, add_eq_left hb ha]
state_before: a b : Cardinal.{u_1}
hb : ℵ₀ ≤ b
ha : a ≤ b
⊢ a + b = b
state_after: no goals
Theorem: IntermediateField.isPurelyInseparable_adjoin_iff_pow_mem
File: Mathlib/FieldTheory/PurelyInseparable.lean

tactic: simp_rw [← le_perfectClosure_iff, adjoin_le_iff, ← mem_perfectClosure_iff_pow_mem q,
  Set.le_iff_subset, Set.subset_def, SetLike.mem_coe]
state_before: F : Type u
E : Type v
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Algebra F E
K : Type w
inst✝¹ : Field K
inst✝ : Algebra F K
q : ℕ
hF : ExpChar F q
S : Set E
⊢ IsPurelyInseparable F ↥(adjoin F S) ↔ ∀ x ∈ S, ∃ n, x ^ q ^ n ∈ (algebraMap F E).range
state_after: no goals
Theorem: MvPolynomial.coeff_modMonomial_of_not_le
File: Mathlib/Algebra/MvPolynomial/Division.lean

tactic: rintro ⟨d, rfl⟩
state_before: σ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
s' s : σ →₀ ℕ
x : MvPolynomial σ R
h : ¬s ≤ s'
⊢ ¬∃ d, s' = s + d
state_after: case intro
σ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
s : σ →₀ ℕ
x : MvPolynomial σ R
d : σ →₀ ℕ
h : ¬s ≤ s + d
⊢ False

tactic: exact h le_self_add
state_before: case intro
σ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
s : σ →₀ ℕ
x : MvPolynomial σ R
d : σ →₀ ℕ
h : ¬s ≤ s + d
⊢ False
state_after: no goals
Theorem: mul_mem_cancel_right
File: Mathlib/Algebra/Group/Subgroup/Basic.lean

tactic: simpa using mul_mem hba (inv_mem h)
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁷ : Group G
inst✝⁶ : Group G'
inst✝⁵ : Group G''
A : Type u_4
inst✝⁴ : AddGroup A
M : Type u_5
S : Type u_6
inst✝³ : DivInvMonoid M
inst✝² : SetLike S M
hSM : SubgroupClass S M
H K : S
inst✝¹ : SetLike S G
inst✝ : SubgroupClass S G
x y : G
h : x ∈ H
hba : y * x ∈ H
⊢ y ∈ H
state_after: no goals