1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: IsSubgroup.of_div
File: Mathlib/Deprecated/Subgroup.lean

tactic: have : 1 * a⁻¹ ∈ s := div_mem one_mem ha
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a✝ a₁ a₂ b c : G
inst✝¹ : Group G
inst✝ : AddGroup A
s : Set G
one_mem : 1 ∈ s
div_mem : ∀ {a b : G}, a ∈ s → b ∈ s → a * b⁻¹ ∈ s
a : G
ha : a ∈ s
⊢ a⁻¹ ∈ s
state_after: G : Type u_1
H : Type u_2
A : Type u_3
a✝ a₁ a₂ b c : G
inst✝¹ : Group G
inst✝ : AddGroup A
s : Set G
one_mem : 1 ∈ s
div_mem : ∀ {a b : G}, a ∈ s → b ∈ s → a * b⁻¹ ∈ s
a : G
ha : a ∈ s
this : 1 * a⁻¹ ∈ s
⊢ a⁻¹ ∈ s

tactic: convert this using 1
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a✝ a₁ a₂ b c : G
inst✝¹ : Group G
inst✝ : AddGroup A
s : Set G
one_mem : 1 ∈ s
div_mem : ∀ {a b : G}, a ∈ s → b ∈ s → a * b⁻¹ ∈ s
a : G
ha : a ∈ s
this : 1 * a⁻¹ ∈ s
⊢ a⁻¹ ∈ s
state_after: case h.e'_4
G : Type u_1
H : Type u_2
A : Type u_3
a✝ a₁ a₂ b c : G
inst✝¹ : Group G
inst✝ : AddGroup A
s : Set G
one_mem : 1 ∈ s
div_mem : ∀ {a b : G}, a ∈ s → b ∈ s → a * b⁻¹ ∈ s
a : G
ha : a ∈ s
this : 1 * a⁻¹ ∈ s
⊢ a⁻¹ = 1 * a⁻¹

tactic: rw [one_mul]
state_before: case h.e'_4
G : Type u_1
H : Type u_2
A : Type u_3
a✝ a₁ a₂ b c : G
inst✝¹ : Group G
inst✝ : AddGroup A
s : Set G
one_mem : 1 ∈ s
div_mem : ∀ {a b : G}, a ∈ s → b ∈ s → a * b⁻¹ ∈ s
a : G
ha : a ∈ s
this : 1 * a⁻¹ ∈ s
⊢ a⁻¹ = 1 * a⁻¹
state_after: no goals

tactic: have : a * b⁻¹⁻¹ ∈ s := div_mem ha (inv_mem b hb)
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a✝ a₁ a₂ b✝ c : G
inst✝¹ : Group G
inst✝ : AddGroup A
s : Set G
one_mem : 1 ∈ s
div_mem : ∀ {a b : G}, a ∈ s → b ∈ s → a * b⁻¹ ∈ s
inv_mem : ∀ a ∈ s, a⁻¹ ∈ s
a b : G
ha : a ∈ s
hb : b ∈ s
⊢ a * b ∈ s
state_after: G : Type u_1
H : Type u_2
A : Type u_3
a✝ a₁ a₂ b✝ c : G
inst✝¹ : Group G
inst✝ : AddGroup A
s : Set G
one_mem : 1 ∈ s
div_mem : ∀ {a b : G}, a ∈ s → b ∈ s → a * b⁻¹ ∈ s
inv_mem : ∀ a ∈ s, a⁻¹ ∈ s
a b : G
ha : a ∈ s
hb : b ∈ s
this : a * b⁻¹⁻¹ ∈ s
⊢ a * b ∈ s

tactic: convert this
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a✝ a₁ a₂ b✝ c : G
inst✝¹ : Group G
inst✝ : AddGroup A
s : Set G
one_mem : 1 ∈ s
div_mem : ∀ {a b : G}, a ∈ s → b ∈ s → a * b⁻¹ ∈ s
inv_mem : ∀ a ∈ s, a⁻¹ ∈ s
a b : G
ha : a ∈ s
hb : b ∈ s
this : a * b⁻¹⁻¹ ∈ s
⊢ a * b ∈ s
state_after: case h.e'_4.h.e'_6
G : Type u_1
H : Type u_2
A : Type u_3
a✝ a₁ a₂ b✝ c : G
inst✝¹ : Group G
inst✝ : AddGroup A
s : Set G
one_mem : 1 ∈ s
div_mem : ∀ {a b : G}, a ∈ s → b ∈ s → a * b⁻¹ ∈ s
inv_mem : ∀ a ∈ s, a⁻¹ ∈ s
a b : G
ha : a ∈ s
hb : b ∈ s
this : a * b⁻¹⁻¹ ∈ s
⊢ b = b⁻¹⁻¹

tactic: rw [inv_inv]
state_before: case h.e'_4.h.e'_6
G : Type u_1
H : Type u_2
A : Type u_3
a✝ a₁ a₂ b✝ c : G
inst✝¹ : Group G
inst✝ : AddGroup A
s : Set G
one_mem : 1 ∈ s
div_mem : ∀ {a b : G}, a ∈ s → b ∈ s → a * b⁻¹ ∈ s
inv_mem : ∀ a ∈ s, a⁻¹ ∈ s
a b : G
ha : a ∈ s
hb : b ∈ s
this : a * b⁻¹⁻¹ ∈ s
⊢ b = b⁻¹⁻¹
state_after: no goals
Theorem: Int.odd_sub'
File: Mathlib/Algebra/Ring/Int.lean

tactic: rw [odd_iff_not_even, even_sub, not_iff, not_iff_comm, odd_iff_not_even]
state_before: m n : ℤ
⊢ Odd (m - n) ↔ (Odd n ↔ Even m)
state_after: no goals
Theorem: ContinuousMap.continuous_curry
File: Mathlib/Topology/CompactOpen.lean

tactic: apply continuous_of_continuous_uncurry
state_before: α : Type u_1
X : Type u_2
Y : Type u_3
Z : Type u_4
T : Type u_5
inst✝⁴ : TopologicalSpace X
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Z
inst✝¹ : TopologicalSpace T
K : Set X
U : Set Y
inst✝ : LocallyCompactSpace (X × Y)
⊢ Continuous curry
state_after: case h
α : Type u_1
X : Type u_2
Y : Type u_3
Z : Type u_4
T : Type u_5
inst✝⁴ : TopologicalSpace X
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Z
inst✝¹ : TopologicalSpace T
K : Set X
U : Set Y
inst✝ : LocallyCompactSpace (X × Y)
⊢ Continuous (Function.uncurry fun x y => x.curry y)

tactic: apply continuous_of_continuous_uncurry
state_before: case h
α : Type u_1
X : Type u_2
Y : Type u_3
Z : Type u_4
T : Type u_5
inst✝⁴ : TopologicalSpace X
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Z
inst✝¹ : TopologicalSpace T
K : Set X
U : Set Y
inst✝ : LocallyCompactSpace (X × Y)
⊢ Continuous (Function.uncurry fun x y => x.curry y)
state_after: case h.h
α : Type u_1
X : Type u_2
Y : Type u_3
Z : Type u_4
T : Type u_5
inst✝⁴ : TopologicalSpace X
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Z
inst✝¹ : TopologicalSpace T
K : Set X
U : Set Y
inst✝ : LocallyCompactSpace (X × Y)
⊢ Continuous (Function.uncurry fun x y => (Function.uncurry (fun x y => x.curry y) x) y)

tactic: rw [← (Homeomorph.prodAssoc _ _ _).symm.comp_continuous_iff']
state_before: case h.h
α : Type u_1
X : Type u_2
Y : Type u_3
Z : Type u_4
T : Type u_5
inst✝⁴ : TopologicalSpace X
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Z
inst✝¹ : TopologicalSpace T
K : Set X
U : Set Y
inst✝ : LocallyCompactSpace (X × Y)
⊢ Continuous (Function.uncurry fun x y => (Function.uncurry (fun x y => x.curry y) x) y)
state_after: case h.h
α : Type u_1
X : Type u_2
Y : Type u_3
Z : Type u_4
T : Type u_5
inst✝⁴ : TopologicalSpace X
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Z
inst✝¹ : TopologicalSpace T
K : Set X
U : Set Y
inst✝ : LocallyCompactSpace (X × Y)
⊢ Continuous
    ((Function.uncurry fun x y => (Function.uncurry (fun x y => x.curry y) x) y) ∘
      ⇑(Homeomorph.prodAssoc C(X × Y, Z) X Y).symm)

tactic: exact continuous_eval
state_before: case h.h
α : Type u_1
X : Type u_2
Y : Type u_3
Z : Type u_4
T : Type u_5
inst✝⁴ : TopologicalSpace X
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Z
inst✝¹ : TopologicalSpace T
K : Set X
U : Set Y
inst✝ : LocallyCompactSpace (X × Y)
⊢ Continuous
    ((Function.uncurry fun x y => (Function.uncurry (fun x y => x.curry y) x) y) ∘
      ⇑(Homeomorph.prodAssoc C(X × Y, Z) X Y).symm)
state_after: no goals
Theorem: WeierstrassCurve.coeff_preΨ_ne_zero
File: Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Degree.lean

tactic: induction n using Int.negInduction with
| nat n => simpa only [preΨ_ofNat, Int.even_coe_nat]
    using W.coeff_preΨ'_ne_zero <| by exact_mod_cast h
| neg n ih => simpa only [preΨ_neg, coeff_neg, neg_ne_zero, Int.natAbs_neg, even_neg]
    using ih <| neg_ne_zero.mp <| by exact_mod_cast h
state_before: R : Type u
inst✝ : CommRing R
W : WeierstrassCurve R
n : ℤ
h : ↑n ≠ 0
⊢ (W.preΨ n).coeff ((n.natAbs ^ 2 - if Even n then 4 else 1) / 2) ≠ 0
state_after: no goals

tactic: simpa only [preΨ_ofNat, Int.even_coe_nat]
using W.coeff_preΨ'_ne_zero <| by exact_mod_cast h
state_before: case nat
R : Type u
inst✝ : CommRing R
W : WeierstrassCurve R
n : ℕ
h : ↑↑n ≠ 0
⊢ (W.preΨ ↑n).coeff (((↑n).natAbs ^ 2 - if Even ↑n then 4 else 1) / 2) ≠ 0
state_after: no goals

tactic: exact_mod_cast h
state_before: R : Type u
inst✝ : CommRing R
W : WeierstrassCurve R
n : ℕ
h : ↑↑n ≠ 0
⊢ ↑n ≠ 0
state_after: no goals

tactic: simpa only [preΨ_neg, coeff_neg, neg_ne_zero, Int.natAbs_neg, even_neg]
using ih <| neg_ne_zero.mp <| by exact_mod_cast h
state_before: case neg
R : Type u
inst✝ : CommRing R
W : WeierstrassCurve R
n : ℕ
ih : ↑↑n ≠ 0 → (W.preΨ ↑n).coeff (((↑n).natAbs ^ 2 - if Even ↑n then 4 else 1) / 2) ≠ 0
h : ↑(-↑n) ≠ 0
⊢ (W.preΨ (-↑n)).coeff (((-↑n).natAbs ^ 2 - if Even (-↑n) then 4 else 1) / 2) ≠ 0
state_after: no goals

tactic: exact_mod_cast h
state_before: R : Type u
inst✝ : CommRing R
W : WeierstrassCurve R
n : ℕ
ih : ↑↑n ≠ 0 → (W.preΨ ↑n).coeff (((↑n).natAbs ^ 2 - if Even ↑n then 4 else 1) / 2) ≠ 0
h : ↑(-↑n) ≠ 0
⊢ -↑↑n ≠ 0
state_after: no goals
Theorem: Nat.rel_of_forall_rel_succ_of_le_of_lt
File: Mathlib/Order/Monotone/Basic.lean

tactic: induction' hbc with k b_lt_k r_b_k
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type u_2
π : ι → Type u_3
r✝ : α → α → Prop
inst✝¹ : Preorder α
r : β → β → Prop
inst✝ : IsTrans β r
f : ℕ → β
a : ℕ
h : ∀ (n : ℕ), a ≤ n → r (f n) (f (n + 1))
b c : ℕ
hab : a ≤ b
hbc : b < c
⊢ r (f b) (f c)
state_after: case refl
ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type u_2
π : ι → Type u_3
r✝ : α → α → Prop
inst✝¹ : Preorder α
r : β → β → Prop
inst✝ : IsTrans β r
f : ℕ → β
a : ℕ
h : ∀ (n : ℕ), a ≤ n → r (f n) (f (n + 1))
b c : ℕ
hab : a ≤ b
⊢ r (f b) (f b.succ)

case step
ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type u_2
π : ι → Type u_3
r✝ : α → α → Prop
inst✝¹ : Preorder α
r : β → β → Prop
inst✝ : IsTrans β r
f : ℕ → β
a : ℕ
h : ∀ (n : ℕ), a ≤ n → r (f n) (f (n + 1))
b c : ℕ
hab : a ≤ b
k : ℕ
b_lt_k : b.succ.le k
r_b_k : r (f b) (f k)
⊢ r (f b) (f k.succ)

tactic: exacts [h _ hab, _root_.trans r_b_k (h _ (hab.trans_lt b_lt_k).le)]
state_before: case refl
ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type u_2
π : ι → Type u_3
r✝ : α → α → Prop
inst✝¹ : Preorder α
r : β → β → Prop
inst✝ : IsTrans β r
f : ℕ → β
a : ℕ
h : ∀ (n : ℕ), a ≤ n → r (f n) (f (n + 1))
b c : ℕ
hab : a ≤ b
⊢ r (f b) (f b.succ)

case step
ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type u_2
π : ι → Type u_3
r✝ : α → α → Prop
inst✝¹ : Preorder α
r : β → β → Prop
inst✝ : IsTrans β r
f : ℕ → β
a : ℕ
h : ∀ (n : ℕ), a ≤ n → r (f n) (f (n + 1))
b c : ℕ
hab : a ≤ b
k : ℕ
b_lt_k : b.succ.le k
r_b_k : r (f b) (f k)
⊢ r (f b) (f k.succ)
state_after: no goals
Theorem: Rat.add_zero
File: Mathlib/Data/Rat/Defs.lean

tactic: simp [add_def, normalize_eq_mkRat]
state_before: q a b c : ℚ
⊢ a + 0 = a
state_after: no goals
Theorem: Finset.eraseNone_none
File: Mathlib/Data/Finset/Option.lean

tactic: ext
state_before: α : Type u_1
β : Type u_2
⊢ eraseNone {none} = ∅
state_after: case a
α : Type u_1
β : Type u_2
a✝ : α
⊢ a✝ ∈ eraseNone {none} ↔ a✝ ∈ ∅

tactic: simp
state_before: case a
α : Type u_1
β : Type u_2
a✝ : α
⊢ a✝ ∈ eraseNone {none} ↔ a✝ ∈ ∅
state_after: no goals
Theorem: ContractingWith.edist_le_of_fixedPoint
File: Mathlib/Topology/MetricSpace/Contracting.lean

tactic: simpa only [hy.eq, edist_self, add_zero] using hf.edist_inequality h
state_before: α : Type u_1
inst✝ : EMetricSpace α
cs : CompleteSpace α
K : ℝ≥0
f : α → α
hf : ContractingWith K f
x y : α
h : edist x y ≠ ⊤
hy : IsFixedPt f y
⊢ edist x y ≤ edist x (f x) / (1 - ↑K)
state_after: no goals
Theorem: AList.mem_erase
File: Mathlib/Data/List/AList.lean

tactic: rw [mem_keys, keys_erase, s.keys_nodup.mem_erase_iff, ← mem_keys]
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
a a' : α
s : AList β
⊢ a' ∈ erase a s ↔ a' ≠ a ∧ a' ∈ s
state_after: no goals
Theorem: NonUnitalSubalgebra.toSubalgebra_toNonUnitalSubalgebra
File: Mathlib/Algebra/Algebra/Subalgebra/Unitization.lean

tactic: cases S
state_before: R : Type u_1
A : Type u_2
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Algebra R A
S : NonUnitalSubalgebra R A
h1 : 1 ∈ S
⊢ (S.toSubalgebra h1).toNonUnitalSubalgebra = S
state_after: case mk
R : Type u_1
A : Type u_2
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Algebra R A
toNonUnitalSubsemiring✝ : NonUnitalSubsemiring A
smul_mem'✝ : ∀ (c : R) {x : A}, x ∈ toNonUnitalSubsemiring✝.carrier → c • x ∈ toNonUnitalSubsemiring✝.carrier
h1 : 1 ∈ { toNonUnitalSubsemiring := toNonUnitalSubsemiring✝, smul_mem' := smul_mem'✝ }
⊢ ({ toNonUnitalSubsemiring := toNonUnitalSubsemiring✝, smul_mem' := smul_mem'✝ }.toSubalgebra
        h1).toNonUnitalSubalgebra =
    { toNonUnitalSubsemiring := toNonUnitalSubsemiring✝, smul_mem' := smul_mem'✝ }

tactic: rfl
state_before: case mk
R : Type u_1
A : Type u_2
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Algebra R A
toNonUnitalSubsemiring✝ : NonUnitalSubsemiring A
smul_mem'✝ : ∀ (c : R) {x : A}, x ∈ toNonUnitalSubsemiring✝.carrier → c • x ∈ toNonUnitalSubsemiring✝.carrier
h1 : 1 ∈ { toNonUnitalSubsemiring := toNonUnitalSubsemiring✝, smul_mem' := smul_mem'✝ }
⊢ ({ toNonUnitalSubsemiring := toNonUnitalSubsemiring✝, smul_mem' := smul_mem'✝ }.toSubalgebra
        h1).toNonUnitalSubalgebra =
    { toNonUnitalSubsemiring := toNonUnitalSubsemiring✝, smul_mem' := smul_mem'✝ }
state_after: no goals
Theorem: PFun.comp_id
File: Mathlib/Data/PFun.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ι : Type u_6
f✝ f : α →. β
x✝¹ : α
x✝ : β
⊢ x✝ ∈ f.comp (PFun.id α) x✝¹ ↔ x✝ ∈ f x✝¹
state_after: no goals
Theorem: AkraBazziRecurrence.eventually_asympBound_r_pos
File: Mathlib/Computability/AkraBazzi/AkraBazzi.lean

tactic: rw [Filter.eventually_all]
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
⊢ ∀ᶠ (n : ℕ) in atTop, ∀ (i : α), 0 < asympBound g a b (r i n)
state_after: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
⊢ ∀ (i : α), ∀ᶠ (x : ℕ) in atTop, 0 < asympBound g a b (r i x)

tactic: exact fun i => (R.tendsto_atTop_r i).eventually R.eventually_asympBound_pos
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
⊢ ∀ (i : α), ∀ᶠ (x : ℕ) in atTop, 0 < asympBound g a b (r i x)
state_after: no goals
Theorem: segment_same
File: Mathlib/Analysis/Convex/Segment.lean

tactic: simpa only [(add_smul _ _ _).symm, mem_singleton_iff, hab, one_smul, eq_comm] using hz
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
ι : Type u_5
π : ι → Type u_6
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommMonoid E
inst✝ : Module 𝕜 E
s : Set E
x✝¹ y z✝ x z : E
x✝ : z ∈ [x-[𝕜]x]
a b : 𝕜
left✝¹ : 0 ≤ a
left✝ : 0 ≤ b
hab : a + b = 1
hz : a • x + b • x = z
⊢ z ∈ {x}
state_after: no goals
Theorem: Nat.xgcdAux_rec
File: Mathlib/Data/Int/GCD.lean

tactic: obtain ⟨r, rfl⟩ := Nat.exists_eq_succ_of_ne_zero h.ne'
state_before: r : ℕ
s t : ℤ
r' : ℕ
s' t' : ℤ
h : 0 < r
⊢ r.xgcdAux s t r' s' t' = (r' % r).xgcdAux (s' - ↑r' / ↑r * s) (t' - ↑r' / ↑r * t) r s t
state_after: case intro
s t : ℤ
r' : ℕ
s' t' : ℤ
r : ℕ
h : 0 < r.succ
⊢ r.succ.xgcdAux s t r' s' t' = (r' % r.succ).xgcdAux (s' - ↑r' / ↑r.succ * s) (t' - ↑r' / ↑r.succ * t) r.succ s t

tactic: simp [xgcdAux]
state_before: case intro
s t : ℤ
r' : ℕ
s' t' : ℤ
r : ℕ
h : 0 < r.succ
⊢ r.succ.xgcdAux s t r' s' t' = (r' % r.succ).xgcdAux (s' - ↑r' / ↑r.succ * s) (t' - ↑r' / ↑r.succ * t) r.succ s t
state_after: no goals
Theorem: mem_closure_of_mem_closure_union
File: Mathlib/Topology/Basic.lean

tactic: rw [mem_closure_iff_nhds_ne_bot] at *
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
h : x ∈ closure (s₁ ∪ s₂)
h₁ : s₁ᶜ ∈ 𝓝 x
⊢ x ∈ closure s₂
state_after: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
h : 𝓝 x ⊓ 𝓟 (s₁ ∪ s₂) ≠ ⊥
h₁ : s₁ᶜ ∈ 𝓝 x
⊢ 𝓝 x ⊓ 𝓟 s₂ ≠ ⊥

tactic: rwa [← sup_principal, inf_sup_left, inf_principal_eq_bot.mpr h₁, bot_sup_eq] at h
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
h : 𝓝 x ⊓ 𝓟 (s₁ ∪ s₂) ≠ ⊥
h₁ : s₁ᶜ ∈ 𝓝 x
⊢ 𝓝 x ⊓ 𝓟 s₂ ≠ ⊥
state_after: no goals
Theorem: MeasureTheory.Measure.sub_apply_eq_zero_of_restrict_le_restrict
File: Mathlib/MeasureTheory/Measure/Sub.lean

tactic: rw [← restrict_apply_self, restrict_sub_eq_restrict_sub_restrict, sub_eq_zero_of_le] <;> simp [*]
state_before: α : Type u_1
m : MeasurableSpace α
μ ν : Measure α
s : Set α
h_le : μ.restrict s ≤ ν.restrict s
h_meas_s : MeasurableSet s
⊢ (μ - ν) s = 0
state_after: no goals
Theorem: String.Iterator.Valid.remainingToString
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

tactic: cases h.out
state_before: l r : List Char
it : Iterator
h : ValidFor l r it
⊢ it.remainingToString = { data := r }
state_after: case refl
l r : List Char
h : ValidFor l r { s := { data := l.reverseAux r }, i := { byteIdx := utf8Len l } }
⊢ { s := { data := l.reverseAux r }, i := { byteIdx := utf8Len l } }.remainingToString = { data := r }

tactic: simpa [Iterator.remainingToString, List.reverseAux_eq] using extract_of_valid l.reverse r []
state_before: case refl
l r : List Char
h : ValidFor l r { s := { data := l.reverseAux r }, i := { byteIdx := utf8Len l } }
⊢ { s := { data := l.reverseAux r }, i := { byteIdx := utf8Len l } }.remainingToString = { data := r }
state_after: no goals
Theorem: Rat.lt_def
File: Mathlib/Algebra/Order/Ring/Rat.lean

tactic: rw [lt_iff_le_and_ne, Rat.le_def]
state_before: a b c p q : ℚ
⊢ p < q ↔ p.num * ↑q.den < q.num * ↑p.den
state_after: a b c p q : ℚ
⊢ p.num * ↑q.den ≤ q.num * ↑p.den ∧ p ≠ q ↔ p.num * ↑q.den < q.num * ↑p.den

tactic: exact not_iff_not.mpr eq_iff_mul_eq_mul
state_before: a b c p q : ℚ
⊢ p ≠ q ↔ p.num * ↑q.den ≠ q.num * ↑p.den
state_after: no goals

tactic: constructor <;> intro h
state_before: a b c p q : ℚ
this : p ≠ q ↔ p.num * ↑q.den ≠ q.num * ↑p.den
⊢ p.num * ↑q.den ≤ q.num * ↑p.den ∧ p ≠ q ↔ p.num * ↑q.den < q.num * ↑p.den
state_after: case mp
a b c p q : ℚ
this : p ≠ q ↔ p.num * ↑q.den ≠ q.num * ↑p.den
h : p.num * ↑q.den ≤ q.num * ↑p.den ∧ p ≠ q
⊢ p.num * ↑q.den < q.num * ↑p.den

case mpr
a b c p q : ℚ
this : p ≠ q ↔ p.num * ↑q.den ≠ q.num * ↑p.den
h : p.num * ↑q.den < q.num * ↑p.den
⊢ p.num * ↑q.den ≤ q.num * ↑p.den ∧ p ≠ q

tactic: exact lt_iff_le_and_ne.mpr ⟨h.left, this.mp h.right⟩
state_before: case mp
a b c p q : ℚ
this : p ≠ q ↔ p.num * ↑q.den ≠ q.num * ↑p.den
h : p.num * ↑q.den ≤ q.num * ↑p.den ∧ p ≠ q
⊢ p.num * ↑q.den < q.num * ↑p.den
state_after: no goals

tactic: have tmp := lt_iff_le_and_ne.mp h
state_before: case mpr
a b c p q : ℚ
this : p ≠ q ↔ p.num * ↑q.den ≠ q.num * ↑p.den
h : p.num * ↑q.den < q.num * ↑p.den
⊢ p.num * ↑q.den ≤ q.num * ↑p.den ∧ p ≠ q
state_after: case mpr
a b c p q : ℚ
this : p ≠ q ↔ p.num * ↑q.den ≠ q.num * ↑p.den
h : p.num * ↑q.den < q.num * ↑p.den
tmp : p.num * ↑q.den ≤ q.num * ↑p.den ∧ p.num * ↑q.den ≠ q.num * ↑p.den
⊢ p.num * ↑q.den ≤ q.num * ↑p.den ∧ p ≠ q

tactic: exact ⟨tmp.left, this.mpr tmp.right⟩
state_before: case mpr
a b c p q : ℚ
this : p ≠ q ↔ p.num * ↑q.den ≠ q.num * ↑p.den
h : p.num * ↑q.den < q.num * ↑p.den
tmp : p.num * ↑q.den ≤ q.num * ↑p.den ∧ p.num * ↑q.den ≠ q.num * ↑p.den
⊢ p.num * ↑q.den ≤ q.num * ↑p.den ∧ p ≠ q
state_after: no goals
Theorem: QuaternionAlgebra.mul_coe_eq_smul
File: Mathlib/Algebra/Quaternion.lean

tactic: rw [← coe_commutes, coe_mul_eq_smul]
state_before: S : Type u_1
T : Type u_2
R : Type u_3
inst✝ : CommRing R
c₁ c₂ r x y z : R
a b c : ℍ[R,c₁,c₂]
⊢ a * ↑r = r • a
state_after: no goals
Theorem: String.valid_next
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

tactic: match s, p, h with
| ⟨_⟩, ⟨_⟩, ⟨cs, [], rfl, rfl⟩ => simp at h₂
| ⟨_⟩, ⟨_⟩, ⟨cs, c::cs', rfl, rfl⟩ =>
  rw [utf8ByteSize.go_eq, next_of_valid]
  simpa using Pos.Valid.mk (cs ++ [c]) cs'
state_before: s : String
p : Pos
h : Pos.Valid s p
h₂ : p < s.endPos
⊢ Pos.Valid s (s.next p)
state_after: no goals

tactic: simp at h₂
state_before: s : String
p : Pos
h : Pos.Valid s p
cs : List Char
h₂ : { byteIdx := utf8ByteSize.go cs } < { data := cs ++ [] }.endPos
⊢ Pos.Valid { data := cs ++ [] } ({ data := cs ++ [] }.next { byteIdx := utf8ByteSize.go cs })
state_after: no goals

tactic: rw [utf8ByteSize.go_eq, next_of_valid]
state_before: s : String
p : Pos
h : Pos.Valid s p
cs : List Char
c : Char
cs' : List Char
h₂ : { byteIdx := utf8ByteSize.go cs } < { data := cs ++ c :: cs' }.endPos
⊢ Pos.Valid { data := cs ++ c :: cs' } ({ data := cs ++ c :: cs' }.next { byteIdx := utf8ByteSize.go cs })
state_after: s : String
p : Pos
h : Pos.Valid s p
cs : List Char
c : Char
cs' : List Char
h₂ : { byteIdx := utf8ByteSize.go cs } < { data := cs ++ c :: cs' }.endPos
⊢ Pos.Valid { data := cs ++ c :: cs' } { byteIdx := utf8Len cs + c.utf8Size }

tactic: simpa using Pos.Valid.mk (cs ++ [c]) cs'
state_before: s : String
p : Pos
h : Pos.Valid s p
cs : List Char
c : Char
cs' : List Char
h₂ : { byteIdx := utf8ByteSize.go cs } < { data := cs ++ c :: cs' }.endPos
⊢ Pos.Valid { data := cs ++ c :: cs' } { byteIdx := utf8Len cs + c.utf8Size }
state_after: no goals
Theorem: Asymptotics.isBigO_iff_eventually
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

tactic: simp only [IsBigOWith_def]
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
G : Type u_5
E' : Type u_6
F' : Type u_7
G' : Type u_8
E'' : Type u_9
F'' : Type u_10
G'' : Type u_11
E''' : Type u_12
R : Type u_13
R' : Type u_14
𝕜 : Type u_15
𝕜' : Type u_16
inst✝¹³ : Norm E
inst✝¹² : Norm F
inst✝¹¹ : Norm G
inst✝¹⁰ : SeminormedAddCommGroup E'
inst✝⁹ : SeminormedAddCommGroup F'
inst✝⁸ : SeminormedAddCommGroup G'
inst✝⁷ : NormedAddCommGroup E''
inst✝⁶ : NormedAddCommGroup F''
inst✝⁵ : NormedAddCommGroup G''
inst✝⁴ : SeminormedRing R
inst✝³ : SeminormedAddGroup E'''
inst✝² : SeminormedRing R'
inst✝¹ : NormedDivisionRing 𝕜
inst✝ : NormedDivisionRing 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
⊢ (∀ᶠ (c : ℝ) in atTop, IsBigOWith c l f g') ↔ ∀ᶠ (c : ℝ) in atTop, ∀ᶠ (x : α) in l, ‖f x‖ ≤ c * ‖g' x‖
state_after: no goals
Theorem: WittVector.init_sub
File: Mathlib/RingTheory/WittVector/InitTail.lean

tactic: init_ring using wittSub_vars
state_before: p : ℕ
hp : Fact (Nat.Prime p)
n✝ : ℕ
R : Type u_1
inst✝ : CommRing R
x y : 𝕎 R
n : ℕ
⊢ init n (x - y) = init n (init n x - init n y)
state_after: no goals
Theorem: ClassGroup.mk0_surjective
File: Mathlib/RingTheory/ClassGroup.lean

tactic: rintro ⟨I⟩
state_before: R : Type u_1
K : Type u_2
L : Type u_3
inst✝¹¹ : CommRing R
inst✝¹⁰ : Field K
inst✝⁹ : Field L
inst✝⁸ : DecidableEq L
inst✝⁷ : Algebra R K
inst✝⁶ : IsFractionRing R K
inst✝⁵ : Algebra K L
inst✝⁴ : FiniteDimensional K L
inst✝³ : Algebra R L
inst✝² : IsScalarTower R K L
inst✝¹ : IsDomain R
inst✝ : IsDedekindDomain R
⊢ Function.Surjective ⇑mk0
state_after: case mk
R : Type u_1
K : Type u_2
L : Type u_3
inst✝¹¹ : CommRing R
inst✝¹⁰ : Field K
inst✝⁹ : Field L
inst✝⁸ : DecidableEq L
inst✝⁷ : Algebra R K
inst✝⁶ : IsFractionRing R K
inst✝⁵ : Algebra K L
inst✝⁴ : FiniteDimensional K L
inst✝³ : Algebra R L
inst✝² : IsScalarTower R K L
inst✝¹ : IsDomain R
inst✝ : IsDedekindDomain R
b✝ : ClassGroup R
I : (FractionalIdeal R⁰ (FractionRing R))ˣ
⊢ ∃ a, mk0 a = Quot.mk Setoid.r I

tactic: refine ⟨⟨ClassGroup.integralRep I.1, ClassGroup.integralRep_mem_nonZeroDivisors I.ne_zero⟩, ?_⟩
state_before: case mk
R : Type u_1
K : Type u_2
L : Type u_3
inst✝¹¹ : CommRing R
inst✝¹⁰ : Field K
inst✝⁹ : Field L
inst✝⁸ : DecidableEq L
inst✝⁷ : Algebra R K
inst✝⁶ : IsFractionRing R K
inst✝⁵ : Algebra K L
inst✝⁴ : FiniteDimensional K L
inst✝³ : Algebra R L
inst✝² : IsScalarTower R K L
inst✝¹ : IsDomain R
inst✝ : IsDedekindDomain R
b✝ : ClassGroup R
I : (FractionalIdeal R⁰ (FractionRing R))ˣ
⊢ ∃ a, mk0 a = Quot.mk Setoid.r I
state_after: case mk
R : Type u_1
K : Type u_2
L : Type u_3
inst✝¹¹ : CommRing R
inst✝¹⁰ : Field K
inst✝⁹ : Field L
inst✝⁸ : DecidableEq L
inst✝⁷ : Algebra R K
inst✝⁶ : IsFractionRing R K
inst✝⁵ : Algebra K L
inst✝⁴ : FiniteDimensional K L
inst✝³ : Algebra R L
inst✝² : IsScalarTower R K L
inst✝¹ : IsDomain R
inst✝ : IsDedekindDomain R
b✝ : ClassGroup R
I : (FractionalIdeal R⁰ (FractionRing R))ˣ
⊢ mk0 ⟨integralRep ↑I, ⋯⟩ = Quot.mk Setoid.r I

tactic: rw [ClassGroup.mk0_integralRep, ClassGroup.Quot_mk_eq_mk]
state_before: case mk
R : Type u_1
K : Type u_2
L : Type u_3
inst✝¹¹ : CommRing R
inst✝¹⁰ : Field K
inst✝⁹ : Field L
inst✝⁸ : DecidableEq L
inst✝⁷ : Algebra R K
inst✝⁶ : IsFractionRing R K
inst✝⁵ : Algebra K L
inst✝⁴ : FiniteDimensional K L
inst✝³ : Algebra R L
inst✝² : IsScalarTower R K L
inst✝¹ : IsDomain R
inst✝ : IsDedekindDomain R
b✝ : ClassGroup R
I : (FractionalIdeal R⁰ (FractionRing R))ˣ
⊢ mk0 ⟨integralRep ↑I, ⋯⟩ = Quot.mk Setoid.r I
state_after: no goals