1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: LiouvilleNumber.aux_calc
File: Mathlib/NumberTheory/Liouville/LiouvilleNumber.lean

tactic: positivity
state_before: n : ℕ
m : ℝ
hm : 2 ≤ m
⊢ 0 ≤ 1 / m ^ (n + 1)!
state_after: no goals

tactic: apply (div_le_div_iff _ _).mpr
state_before: n : ℕ
m : ℝ
hm : 2 ≤ m
⊢ 2 / m ^ (n ! * (n + 1)) ≤ 1 / m ^ (n ! * n)
state_after: n : ℕ
m : ℝ
hm : 2 ≤ m
⊢ 2 * m ^ (n ! * n) ≤ 1 * m ^ (n ! * (n + 1))

n : ℕ
m : ℝ
hm : 2 ≤ m
⊢ 0 < m ^ (n ! * (n + 1))

n : ℕ
m : ℝ
hm : 2 ≤ m
⊢ 0 < m ^ (n ! * n)

tactic: focus
  conv_rhs => rw [one_mul, mul_add, pow_add, mul_one, pow_mul, mul_comm, ← pow_mul]
  refine (mul_le_mul_right ?_).mpr ?_
state_before: n : ℕ
m : ℝ
hm : 2 ≤ m
⊢ 2 * m ^ (n ! * n) ≤ 1 * m ^ (n ! * (n + 1))

n : ℕ
m : ℝ
hm : 2 ≤ m
⊢ 0 < m ^ (n ! * (n + 1))

n : ℕ
m : ℝ
hm : 2 ≤ m
⊢ 0 < m ^ (n ! * n)
state_after: case refine_1
n : ℕ
m : ℝ
hm : 2 ≤ m
⊢ 0 < m ^ (n ! * n)

case refine_2
n : ℕ
m : ℝ
hm : 2 ≤ m
⊢ 2 ≤ m ^ n !

n : ℕ
m : ℝ
hm : 2 ≤ m
⊢ 0 < m ^ (n ! * (n + 1))

n : ℕ
m : ℝ
hm : 2 ≤ m
⊢ 0 < m ^ (n ! * n)

tactic: any_goals exact pow_pos (zero_lt_two.trans_le hm) _
state_before: case refine_1
n : ℕ
m : ℝ
hm : 2 ≤ m
⊢ 0 < m ^ (n ! * n)

case refine_2
n : ℕ
m : ℝ
hm : 2 ≤ m
⊢ 2 ≤ m ^ n !

n : ℕ
m : ℝ
hm : 2 ≤ m
⊢ 0 < m ^ (n ! * (n + 1))

n : ℕ
m : ℝ
hm : 2 ≤ m
⊢ 0 < m ^ (n ! * n)
state_after: case refine_2
n : ℕ
m : ℝ
hm : 2 ≤ m
⊢ 2 ≤ m ^ n !

tactic: exact _root_.trans (_root_.trans hm (pow_one _).symm.le)
  (pow_right_mono (one_le_two.trans hm) n.factorial_pos)
state_before: case refine_2
n : ℕ
m : ℝ
hm : 2 ≤ m
⊢ 2 ≤ m ^ n !
state_after: no goals

tactic: conv_rhs => rw [one_mul, mul_add, pow_add, mul_one, pow_mul, mul_comm, ← pow_mul]
state_before: n : ℕ
m : ℝ
hm : 2 ≤ m
⊢ 2 * m ^ (n ! * n) ≤ 1 * m ^ (n ! * (n + 1))
state_after: n : ℕ
m : ℝ
hm : 2 ≤ m
⊢ 2 * m ^ (n ! * n) ≤ m ^ n ! * m ^ (n ! * n)

tactic: refine (mul_le_mul_right ?_).mpr ?_
state_before: n : ℕ
m : ℝ
hm : 2 ≤ m
⊢ 2 * m ^ (n ! * n) ≤ m ^ n ! * m ^ (n ! * n)
state_after: case refine_1
n : ℕ
m : ℝ
hm : 2 ≤ m
⊢ 0 < m ^ (n ! * n)

case refine_2
n : ℕ
m : ℝ
hm : 2 ≤ m
⊢ 2 ≤ m ^ n !

tactic: exact pow_pos (zero_lt_two.trans_le hm) _
state_before: n : ℕ
m : ℝ
hm : 2 ≤ m
⊢ 0 < m ^ (n ! * n)
state_after: no goals
Theorem: Set.preimage_surjective
File: Mathlib/Data/Set/Image.lean

tactic: refine ⟨fun h x x' hx => ?_, Injective.preimage_surjective⟩
state_before: α : Type u
β : Type v
f : α → β
⊢ Surjective (preimage f) ↔ Injective f
state_after: α : Type u
β : Type v
f : α → β
h : Surjective (preimage f)
x x' : α
hx : f x = f x'
⊢ x = x'

tactic: cases' h {x} with s hs
state_before: α : Type u
β : Type v
f : α → β
h : Surjective (preimage f)
x x' : α
hx : f x = f x'
⊢ x = x'
state_after: case intro
α : Type u
β : Type v
f : α → β
h : Surjective (preimage f)
x x' : α
hx : f x = f x'
s : Set β
hs : f ⁻¹' s = {x}
⊢ x = x'

tactic: have := mem_singleton x
state_before: case intro
α : Type u
β : Type v
f : α → β
h : Surjective (preimage f)
x x' : α
hx : f x = f x'
s : Set β
hs : f ⁻¹' s = {x}
⊢ x = x'
state_after: case intro
α : Type u
β : Type v
f : α → β
h : Surjective (preimage f)
x x' : α
hx : f x = f x'
s : Set β
hs : f ⁻¹' s = {x}
this : x ∈ {x}
⊢ x = x'

tactic: rwa [← hs, mem_preimage, hx, ← mem_preimage, hs, mem_singleton_iff, eq_comm] at this
state_before: case intro
α : Type u
β : Type v
f : α → β
h : Surjective (preimage f)
x x' : α
hx : f x = f x'
s : Set β
hs : f ⁻¹' s = {x}
this : x ∈ {x}
⊢ x = x'
state_after: no goals
Theorem: Ordinal.nfp_zero_mul
File: Mathlib/SetTheory/Ordinal/FixedPoint.lean

tactic: rw [← sup_iterate_eq_nfp]
state_before: ⊢ nfp (HMul.hMul 0) = id
state_after: ⊢ (fun a => sup fun n => (HMul.hMul 0)^[n] a) = id

tactic: induction' n with n _
state_before: a : Ordinal.{u_1}
n : ℕ
⊢ (HMul.hMul 0)^[n] a ≤ id a
state_after: case zero
a : Ordinal.{u_1}
⊢ (HMul.hMul 0)^[0] a ≤ id a

case succ
a : Ordinal.{u_1}
n : ℕ
a✝ : (HMul.hMul 0)^[n] a ≤ id a
⊢ (HMul.hMul 0)^[n + 1] a ≤ id a

tactic: rw [Function.iterate_succ']
state_before: case succ
a : Ordinal.{u_1}
n : ℕ
a✝ : (HMul.hMul 0)^[n] a ≤ id a
⊢ (HMul.hMul 0)^[n + 1] a ≤ id a
state_after: case succ
a : Ordinal.{u_1}
n : ℕ
a✝ : (HMul.hMul 0)^[n] a ≤ id a
⊢ (HMul.hMul 0 ∘ (HMul.hMul 0)^[n]) a ≤ id a

tactic: change 0 * _ ≤ a
state_before: case succ
a : Ordinal.{u_1}
n : ℕ
a✝ : (HMul.hMul 0)^[n] a ≤ id a
⊢ (HMul.hMul 0 ∘ (HMul.hMul 0)^[n]) a ≤ id a
state_after: case succ
a : Ordinal.{u_1}
n : ℕ
a✝ : (HMul.hMul 0)^[n] a ≤ id a
⊢ 0 * (HMul.hMul 0)^[n] a ≤ a

tactic: rw [zero_mul]
state_before: case succ
a : Ordinal.{u_1}
n : ℕ
a✝ : (HMul.hMul 0)^[n] a ≤ id a
⊢ 0 * (HMul.hMul 0)^[n] a ≤ a
state_after: case succ
a : Ordinal.{u_1}
n : ℕ
a✝ : (HMul.hMul 0)^[n] a ≤ id a
⊢ 0 ≤ a

tactic: exact Ordinal.zero_le a
state_before: case succ
a : Ordinal.{u_1}
n : ℕ
a✝ : (HMul.hMul 0)^[n] a ≤ id a
⊢ 0 ≤ a
state_after: no goals

tactic: rfl
state_before: case zero
a : Ordinal.{u_1}
⊢ (HMul.hMul 0)^[0] a ≤ id a
state_after: no goals
Theorem: PEquiv.bot_trans
File: Mathlib/Data/PEquiv.lean

tactic: ext
state_before: α : Type u
β : Type v
γ : Type w
δ : Type x
f : β ≃. γ
⊢ ⊥.trans f = ⊥
state_after: case h.a
α : Type u
β : Type v
γ : Type w
δ : Type x
f : β ≃. γ
x✝ : α
a✝ : γ
⊢ a✝ ∈ (⊥.trans f) x✝ ↔ a✝ ∈ ⊥ x✝

tactic: dsimp [PEquiv.trans]
state_before: case h.a
α : Type u
β : Type v
γ : Type w
δ : Type x
f : β ≃. γ
x✝ : α
a✝ : γ
⊢ a✝ ∈ (⊥.trans f) x✝ ↔ a✝ ∈ ⊥ x✝
state_after: case h.a
α : Type u
β : Type v
γ : Type w
δ : Type x
f : β ≃. γ
x✝ : α
a✝ : γ
⊢ a✝ ∈ none ↔ a✝ ∈ none

tactic: simp
state_before: case h.a
α : Type u
β : Type v
γ : Type w
δ : Type x
f : β ≃. γ
x✝ : α
a✝ : γ
⊢ a✝ ∈ none ↔ a✝ ∈ none
state_after: no goals
Theorem: Polynomial.smeval_eq_sum
File: Mathlib/Algebra/Polynomial/Smeval.lean

tactic: rw [smeval_def]
state_before: R : Type u_1
inst✝³ : Semiring R
r : R
p : R[X]
S : Type u_2
inst✝² : AddCommMonoid S
inst✝¹ : Pow S ℕ
inst✝ : MulActionWithZero R S
x : S
⊢ p.smeval x = p.sum (smul_pow x)
state_after: no goals
Theorem: Nat.insert_self_properDivisors
File: Mathlib/NumberTheory/Divisors.lean

tactic: rw [divisors, properDivisors, Ico_succ_right_eq_insert_Ico (one_le_iff_ne_zero.2 h),
  Finset.filter_insert, if_pos (dvd_refl n)]
state_before: n : ℕ
h : n ≠ 0
⊢ insert n n.properDivisors = n.divisors
state_after: no goals
Theorem: Cubic.eq_sum_three_roots
File: Mathlib/Algebra/CubicDiscriminant.lean

tactic: apply_fun @toPoly _ _
state_before: R : Type u_1
S : Type u_2
F : Type u_3
K : Type u_4
P : Cubic F
inst✝¹ : Field F
inst✝ : Field K
φ : F →+* K
x y z : K
ha : P.a ≠ 0
h3 : (map φ P).roots = {x, y, z}
⊢ map φ P = { a := φ P.a, b := φ P.a * -(x + y + z), c := φ P.a * (x * y + x * z + y * z), d := φ P.a * -(x * y * z) }
state_after: R : Type u_1
S : Type u_2
F : Type u_3
K : Type u_4
P : Cubic F
inst✝¹ : Field F
inst✝ : Field K
φ : F →+* K
x y z : K
ha : P.a ≠ 0
h3 : (map φ P).roots = {x, y, z}
⊢ (map φ P).toPoly =
    { a := φ P.a, b := φ P.a * -(x + y + z), c := φ P.a * (x * y + x * z + y * z), d := φ P.a * -(x * y * z) }.toPoly

case inj
R : Type u_1
S : Type u_2
F : Type u_3
K : Type u_4
P : Cubic F
inst✝¹ : Field F
inst✝ : Field K
φ : F →+* K
x y z : K
ha : P.a ≠ 0
h3 : (map φ P).roots = {x, y, z}
⊢ Function.Injective toPoly

tactic: rw [eq_prod_three_roots ha h3, C_mul_prod_X_sub_C_eq]
state_before: R : Type u_1
S : Type u_2
F : Type u_3
K : Type u_4
P : Cubic F
inst✝¹ : Field F
inst✝ : Field K
φ : F →+* K
x y z : K
ha : P.a ≠ 0
h3 : (map φ P).roots = {x, y, z}
⊢ (map φ P).toPoly =
    { a := φ P.a, b := φ P.a * -(x + y + z), c := φ P.a * (x * y + x * z + y * z), d := φ P.a * -(x * y * z) }.toPoly
state_after: no goals

tactic: exact fun P Q ↦ (toPoly_injective P Q).mp
state_before: case inj
R : Type u_1
S : Type u_2
F : Type u_3
K : Type u_4
P : Cubic F
inst✝¹ : Field F
inst✝ : Field K
φ : F →+* K
x y z : K
ha : P.a ≠ 0
h3 : (map φ P).roots = {x, y, z}
⊢ Function.Injective toPoly
state_after: no goals
Theorem: countable_setOf_isolated_right
File: Mathlib/Topology/Order/LeftRightNhds.lean

tactic: simp only [nhdsWithin_Ioi_eq_bot_iff, setOf_or]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : SecondCountableTopology α
⊢ {x | 𝓝[>] x = ⊥}.Countable
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : SecondCountableTopology α
⊢ ({a | IsTop a} ∪ {a | ∃ b, a ⋖ b}).Countable

tactic: exact (subsingleton_isTop α).countable.union countable_setOf_covBy_right
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : SecondCountableTopology α
⊢ ({a | IsTop a} ∪ {a | ∃ b, a ⋖ b}).Countable
state_after: no goals
Theorem: Nat.bit1_lt_bit0
File: Mathlib/Init/Data/Nat/Lemmas.lean

tactic: rw [succ_add]
state_before: n m : ℕ
h : n < m.succ
this✝ : n ≤ m
this : (n + n).succ ≤ (m + m).succ
⊢ (n + n).succ ≤ m.succ + m
state_after: n m : ℕ
h : n < m.succ
this✝ : n ≤ m
this : (n + n).succ ≤ (m + m).succ
⊢ (n + n).succ ≤ (m + m).succ

tactic: assumption
state_before: n m : ℕ
h : n < m.succ
this✝ : n ≤ m
this : (n + n).succ ≤ (m + m).succ
⊢ (n + n).succ ≤ (m + m).succ
state_after: no goals
Theorem: LieSubmodule.lie_abelian_iff_lie_self_eq_bot
File: Mathlib/Algebra/Lie/Abelian.lean

tactic: simp only [_root_.eq_bot_iff, lieIdeal_oper_eq_span, LieSubmodule.lieSpan_le,
  LieSubmodule.bot_coe, Set.subset_singleton_iff, Set.mem_setOf_eq, exists_imp]
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N N' : LieSubmodule R L M
I J : LieIdeal R L
⊢ IsLieAbelian ↥↑I ↔ ⁅I, I⁆ = ⊥
state_after: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N N' : LieSubmodule R L M
I J : LieIdeal R L
⊢ IsLieAbelian ↥↑I ↔ ∀ (y : L) (x : ↥I) (x_1 : ↥I), ⁅↑x, ↑x_1⁆ = y → y = 0

tactic: refine
  ⟨fun h z x y hz =>
    hz.symm.trans
      (((I : LieSubalgebra R L).coe_bracket x y).symm.trans
        ((coe_zero_iff_zero _ _).mpr (by apply h.trivial))),
    fun h => ⟨fun x y => ((I : LieSubalgebra R L).coe_zero_iff_zero _).mp (h _ x y rfl)⟩⟩
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N N' : LieSubmodule R L M
I J : LieIdeal R L
⊢ IsLieAbelian ↥↑I ↔ ∀ (y : L) (x : ↥I) (x_1 : ↥I), ⁅↑x, ↑x_1⁆ = y → y = 0
state_after: no goals

tactic: apply h.trivial
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N N' : LieSubmodule R L M
I J : LieIdeal R L
h : IsLieAbelian ↥↑I
z : L
x : ↥I
y : ↥I
hz : ⁅↑x, ↑y⁆ = z
⊢ ⁅x, y⁆ = 0
state_after: no goals
Theorem: Fin.natCast_self
File: Mathlib/Data/Fin/Basic.lean

tactic: ext
state_before: n✝ m n : ℕ
inst✝ : NeZero n
⊢ ↑n = 0
state_after: case h
n✝ m n : ℕ
inst✝ : NeZero n
⊢ ↑↑n = ↑0

tactic: simp
state_before: case h
n✝ m n : ℕ
inst✝ : NeZero n
⊢ ↑↑n = ↑0
state_after: no goals
Theorem: Int.toNat_of_nonpos
File: Mathlib/Data/Int/Lemmas.lean

tactic: simp
state_before: a b : ℤ
n✝ n : ℕ
h : ↑(n + 1) ≤ 0
⊢ 0 < ↑(n + 1)
state_after: no goals
Theorem: Ordinal.opow_dvd_opow
File: Mathlib/SetTheory/Ordinal/Exponential.lean

tactic: rw [← opow_add, Ordinal.add_sub_cancel_of_le h]
state_before: a b c : Ordinal.{u_1}
h : b ≤ c
⊢ a ^ c = a ^ b * a ^ (c - b)
state_after: no goals
Theorem: IsIdempotentElem.iff_eq_zero_or_one
File: Mathlib/Algebra/Ring/Idempotents.lean

tactic: refine
  Iff.intro (fun h => or_iff_not_imp_left.mpr fun hp => ?_) fun h =>
    h.elim (fun hp => hp.symm ▸ zero) fun hp => hp.symm ▸ one
state_before: M : Type u_1
N : Type u_2
S : Type u_3
M₀ : Type u_4
M₁ : Type u_5
R : Type u_6
G : Type u_7
G₀ : Type u_8
inst✝⁷ : Mul M
inst✝⁶ : Monoid N
inst✝⁵ : Semigroup S
inst✝⁴ : MulZeroClass M₀
inst✝³ : MulOneClass M₁
inst✝² : NonAssocRing R
inst✝¹ : Group G
inst✝ : CancelMonoidWithZero G₀
p : G₀
⊢ IsIdempotentElem p ↔ p = 0 ∨ p = 1
state_after: M : Type u_1
N : Type u_2
S : Type u_3
M₀ : Type u_4
M₁ : Type u_5
R : Type u_6
G : Type u_7
G₀ : Type u_8
inst✝⁷ : Mul M
inst✝⁶ : Monoid N
inst✝⁵ : Semigroup S
inst✝⁴ : MulZeroClass M₀
inst✝³ : MulOneClass M₁
inst✝² : NonAssocRing R
inst✝¹ : Group G
inst✝ : CancelMonoidWithZero G₀
p : G₀
h : IsIdempotentElem p
hp : ¬p = 0
⊢ p = 1

tactic: exact mul_left_cancel₀ hp (h.trans (mul_one p).symm)
state_before: M : Type u_1
N : Type u_2
S : Type u_3
M₀ : Type u_4
M₁ : Type u_5
R : Type u_6
G : Type u_7
G₀ : Type u_8
inst✝⁷ : Mul M
inst✝⁶ : Monoid N
inst✝⁵ : Semigroup S
inst✝⁴ : MulZeroClass M₀
inst✝³ : MulOneClass M₁
inst✝² : NonAssocRing R
inst✝¹ : Group G
inst✝ : CancelMonoidWithZero G₀
p : G₀
h : IsIdempotentElem p
hp : ¬p = 0
⊢ p = 1
state_after: no goals
Theorem: PNat.XgcdType.start_isSpecial
File: Mathlib/Data/PNat/Xgcd.lean

tactic: dsimp [start, IsSpecial]
state_before: u : XgcdType
a b : ℕ+
⊢ (start a b).IsSpecial
state_after: no goals
Theorem: Real.hasDerivAt_rpow_const
File: Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean

tactic: rcases ne_or_eq x 0 with (hx | rfl)
state_before: z x✝ y x p : ℝ
h : x ≠ 0 ∨ 1 ≤ p
⊢ HasDerivAt (fun x => x ^ p) (p * x ^ (p - 1)) x
state_after: case inl
z x✝ y x p : ℝ
h : x ≠ 0 ∨ 1 ≤ p
hx : x ≠ 0
⊢ HasDerivAt (fun x => x ^ p) (p * x ^ (p - 1)) x

case inr
z x y p : ℝ
h : 0 ≠ 0 ∨ 1 ≤ p
⊢ HasDerivAt (fun x => x ^ p) (p * 0 ^ (p - 1)) 0

tactic: replace h : 1 ≤ p := h.neg_resolve_left rfl
state_before: case inr
z x y p : ℝ
h : 0 ≠ 0 ∨ 1 ≤ p
⊢ HasDerivAt (fun x => x ^ p) (p * 0 ^ (p - 1)) 0
state_after: case inr
z x y p : ℝ
h : 1 ≤ p
⊢ HasDerivAt (fun x => x ^ p) (p * 0 ^ (p - 1)) 0

tactic: apply hasDerivAt_of_hasDerivAt_of_ne fun x hx =>
  (hasStrictDerivAt_rpow_const_of_ne hx p).hasDerivAt
state_before: case inr
z x y p : ℝ
h : 1 ≤ p
⊢ HasDerivAt (fun x => x ^ p) (p * 0 ^ (p - 1)) 0
state_after: case inr.hf
z x y p : ℝ
h : 1 ≤ p
⊢ ContinuousAt (fun x => x ^ p) 0

case inr.hg
z x y p : ℝ
h : 1 ≤ p
⊢ ContinuousAt (fun x => p * x ^ (p - 1)) 0

tactic: exacts [continuousAt_id.rpow_const (Or.inr (zero_le_one.trans h)),
  continuousAt_const.mul (continuousAt_id.rpow_const (Or.inr (sub_nonneg.2 h)))]
state_before: case inr.hf
z x y p : ℝ
h : 1 ≤ p
⊢ ContinuousAt (fun x => x ^ p) 0

case inr.hg
z x y p : ℝ
h : 1 ≤ p
⊢ ContinuousAt (fun x => p * x ^ (p - 1)) 0
state_after: no goals

tactic: exact (hasStrictDerivAt_rpow_const_of_ne hx _).hasDerivAt
state_before: case inl
z x✝ y x p : ℝ
h : x ≠ 0 ∨ 1 ≤ p
hx : x ≠ 0
⊢ HasDerivAt (fun x => x ^ p) (p * x ^ (p - 1)) x
state_after: no goals
Theorem: Surreal.Multiplication.ih1_neg_right
File: Mathlib/SetTheory/Surreal/Multiplication.lean

tactic: rw [← neg_eq_iff_eq_neg, isOption_neg, P24_neg_right]
state_before: x x₁✝ x₂✝ x₃ x' y y₁ y₂ y₃ y'✝ : PGame
h : IH1 x y
x₁ x₂ y' : PGame
⊢ x₁.IsOption x → x₂.IsOption x → y' = -y ∨ y'.IsOption (-y) → P24 x₁ x₂ y'
state_after: x x₁✝ x₂✝ x₃ x' y y₁ y₂ y₃ y'✝ : PGame
h : IH1 x y
x₁ x₂ y' : PGame
⊢ x₁.IsOption x → x₂.IsOption x → -y' = y ∨ (-y').IsOption y → P24 x₁ x₂ (-y')

tactic: apply h
state_before: x x₁✝ x₂✝ x₃ x' y y₁ y₂ y₃ y'✝ : PGame
h : IH1 x y
x₁ x₂ y' : PGame
⊢ x₁.IsOption x → x₂.IsOption x → -y' = y ∨ (-y').IsOption y → P24 x₁ x₂ (-y')
state_after: no goals
Theorem: CategoryTheory.Limits.SingleObj.Types.Quot.Rel.iff_orbitRel
File: Mathlib/CategoryTheory/Limits/Shapes/SingleObj.lean

tactic: have h (g : G) : y = g • x ↔ g • x = y := ⟨symm, symm⟩
state_before: M G✝ : Type v
inst✝² : Monoid M
inst✝¹ : Group G✝
G : Type v
inst✝ : Group G
J : SingleObj G ⥤ Type u
x y : J.obj (SingleObj.star G)
⊢ Types.Quot.Rel J ⟨SingleObj.star G, x⟩ ⟨SingleObj.star G, y⟩ ↔
    (MulAction.orbitRel G (J.obj (SingleObj.star G))).Rel x y
state_after: M G✝ : Type v
inst✝² : Monoid M
inst✝¹ : Group G✝
G : Type v
inst✝ : Group G
J : SingleObj G ⥤ Type u
x y : J.obj (SingleObj.star G)
h : ∀ (g : G), y = g • x ↔ g • x = y
⊢ Types.Quot.Rel J ⟨SingleObj.star G, x⟩ ⟨SingleObj.star G, y⟩ ↔
    (MulAction.orbitRel G (J.obj (SingleObj.star G))).Rel x y

tactic: conv => rhs; rw [Setoid.comm']
state_before: M G✝ : Type v
inst✝² : Monoid M
inst✝¹ : Group G✝
G : Type v
inst✝ : Group G
J : SingleObj G ⥤ Type u
x y : J.obj (SingleObj.star G)
h : ∀ (g : G), y = g • x ↔ g • x = y
⊢ Types.Quot.Rel J ⟨SingleObj.star G, x⟩ ⟨SingleObj.star G, y⟩ ↔
    (MulAction.orbitRel G (J.obj (SingleObj.star G))).Rel x y
state_after: M G✝ : Type v
inst✝² : Monoid M
inst✝¹ : Group G✝
G : Type v
inst✝ : Group G
J : SingleObj G ⥤ Type u
x y : J.obj (SingleObj.star G)
h : ∀ (g : G), y = g • x ↔ g • x = y
⊢ Types.Quot.Rel J ⟨SingleObj.star G, x⟩ ⟨SingleObj.star G, y⟩ ↔
    (MulAction.orbitRel G (J.obj (SingleObj.star G))).Rel y x

tactic: show (∃ g : G, y = g • x) ↔ (∃ g : G, g • x = y)
state_before: M G✝ : Type v
inst✝² : Monoid M
inst✝¹ : Group G✝
G : Type v
inst✝ : Group G
J : SingleObj G ⥤ Type u
x y : J.obj (SingleObj.star G)
h : ∀ (g : G), y = g • x ↔ g • x = y
⊢ Types.Quot.Rel J ⟨SingleObj.star G, x⟩ ⟨SingleObj.star G, y⟩ ↔
    (MulAction.orbitRel G (J.obj (SingleObj.star G))).Rel y x
state_after: M G✝ : Type v
inst✝² : Monoid M
inst✝¹ : Group G✝
G : Type v
inst✝ : Group G
J : SingleObj G ⥤ Type u
x y : J.obj (SingleObj.star G)
h : ∀ (g : G), y = g • x ↔ g • x = y
⊢ (∃ g, y = g • x) ↔ ∃ g, g • x = y

tactic: conv => lhs; simp only [h]
state_before: M G✝ : Type v
inst✝² : Monoid M
inst✝¹ : Group G✝
G : Type v
inst✝ : Group G
J : SingleObj G ⥤ Type u
x y : J.obj (SingleObj.star G)
h : ∀ (g : G), y = g • x ↔ g • x = y
⊢ (∃ g, y = g • x) ↔ ∃ g, g • x = y
state_after: no goals
Theorem: Polynomial.coeff_inv_units
File: Mathlib/Algebra/Polynomial/FieldDivision.lean

tactic: rw [eq_C_of_degree_eq_zero (degree_coe_units u), eq_C_of_degree_eq_zero (degree_coe_units u⁻¹),
  coeff_C, coeff_C, inv_eq_one_div]
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]
u : R[X]ˣ
n : ℕ
⊢ ((↑u).coeff n)⁻¹ = (↑u⁻¹).coeff n
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]
u : R[X]ˣ
n : ℕ
⊢ (1 / if n = 0 then (↑u).coeff 0 else 0) = if n = 0 then (↑u⁻¹).coeff 0 else 0

tactic: split_ifs
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]
u : R[X]ˣ
n : ℕ
⊢ (1 / if n = 0 then (↑u).coeff 0 else 0) = if n = 0 then (↑u⁻¹).coeff 0 else 0
state_after: case pos
R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n✝ : ℕ
inst✝ : Field R
p q : R[X]
u : R[X]ˣ
n : ℕ
h✝ : n = 0
⊢ 1 / (↑u).coeff 0 = (↑u⁻¹).coeff 0

case neg
R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n✝ : ℕ
inst✝ : Field R
p q : R[X]
u : R[X]ˣ
n : ℕ
h✝ : ¬n = 0
⊢ 1 / 0 = 0

tactic: rw [div_eq_iff_mul_eq (coeff_coe_units_zero_ne_zero u), coeff_zero_eq_eval_zero,
    coeff_zero_eq_eval_zero, ← eval_mul, ← Units.val_mul, inv_mul_self]
state_before: case pos
R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n✝ : ℕ
inst✝ : Field R
p q : R[X]
u : R[X]ˣ
n : ℕ
h✝ : n = 0
⊢ 1 / (↑u).coeff 0 = (↑u⁻¹).coeff 0
state_after: case pos
R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n✝ : ℕ
inst✝ : Field R
p q : R[X]
u : R[X]ˣ
n : ℕ
h✝ : n = 0
⊢ eval 0 ↑1 = 1

tactic: simp
state_before: case pos
R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n✝ : ℕ
inst✝ : Field R
p q : R[X]
u : R[X]ˣ
n : ℕ
h✝ : n = 0
⊢ eval 0 ↑1 = 1
state_after: no goals

tactic: simp
state_before: case neg
R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n✝ : ℕ
inst✝ : Field R
p q : R[X]
u : R[X]ˣ
n : ℕ
h✝ : ¬n = 0
⊢ 1 / 0 = 0
state_after: no goals
Theorem: MeasureTheory.FiniteMeasure.restrict_eq_zero_iff
File: Mathlib/MeasureTheory/Measure/FiniteMeasure.lean

tactic: rw [← mass_zero_iff, restrict_mass]
state_before: Ω : Type u_1
inst✝⁴ : MeasurableSpace Ω
R : Type u_2
inst✝³ : SMul R ℝ≥0
inst✝² : SMul R ℝ≥0∞
inst✝¹ : IsScalarTower R ℝ≥0 ℝ≥0∞
inst✝ : IsScalarTower R ℝ≥0∞ ℝ≥0∞
μ : FiniteMeasure Ω
A : Set Ω
⊢ μ.restrict A = 0 ↔ μ A = 0
state_after: no goals
Theorem: ContinuousLinearMap.opNorm_le_of_lipschitz
File: Mathlib/Analysis/NormedSpace/OperatorNorm/Basic.lean

tactic: simpa only [dist_zero_right, f.map_zero] using hf.dist_le_mul x 0
state_before: 𝕜 : Type u_1
𝕜₂ : Type u_2
𝕜₃ : Type u_3
E : Type u_4
Eₗ : Type u_5
F : Type u_6
Fₗ : Type u_7
G : Type u_8
Gₗ : Type u_9
𝓕 : Type u_10
inst✝¹⁵ : SeminormedAddCommGroup E
inst✝¹⁴ : SeminormedAddCommGroup Eₗ
inst✝¹³ : SeminormedAddCommGroup F
inst✝¹² : SeminormedAddCommGroup Fₗ
inst✝¹¹ : SeminormedAddCommGroup G
inst✝¹⁰ : SeminormedAddCommGroup Gₗ
inst✝⁹ : NontriviallyNormedField 𝕜
inst✝⁸ : NontriviallyNormedField 𝕜₂
inst✝⁷ : NontriviallyNormedField 𝕜₃
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedSpace 𝕜 Eₗ
inst✝⁴ : NormedSpace 𝕜₂ F
inst✝³ : NormedSpace 𝕜 Fₗ
inst✝² : NormedSpace 𝕜₃ G
σ₁₂ : 𝕜 →+* 𝕜₂
σ₂₃ : 𝕜₂ →+* 𝕜₃
σ₁₃ : 𝕜 →+* 𝕜₃
inst✝¹ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝ : FunLike 𝓕 E F
f : E →SL[σ₁₂] F
K : ℝ≥0
hf : LipschitzWith K ⇑f
x : E
⊢ ‖f x‖ ≤ ↑K * ‖x‖
state_after: no goals
Theorem: DirectSum.IsInternal.submodule_iSup_eq_top
File: Mathlib/Algebra/DirectSum/Module.lean

tactic: rw [Submodule.iSup_eq_range_dfinsupp_lsum, LinearMap.range_eq_top]
state_before: R : Type u
inst✝² : Semiring R
ι : Type v
dec_ι : DecidableEq ι
M : Type u_1
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
A : ι → Submodule R M
h : IsInternal A
⊢ iSup A = ⊤
state_after: R : Type u
inst✝² : Semiring R
ι : Type v
dec_ι : DecidableEq ι
M : Type u_1
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
A : ι → Submodule R M
h : IsInternal A
⊢ Function.Surjective ⇑((DFinsupp.lsum ℕ) fun i => (A i).subtype)

tactic: exact Function.Bijective.surjective h
state_before: R : Type u
inst✝² : Semiring R
ι : Type v
dec_ι : DecidableEq ι
M : Type u_1
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
A : ι → Submodule R M
h : IsInternal A
⊢ Function.Surjective ⇑((DFinsupp.lsum ℕ) fun i => (A i).subtype)
state_after: no goals
Theorem: Filter.Subsingleton.isCountablyGenerated
File: Mathlib/Order/Filter/Subsingleton.lean

tactic: rcases subsingleton_iff_bot_or_pure.1 hl with rfl|⟨x, rfl⟩
state_before: α : Type u_1
β : Type u_2
l : Filter α
hl : l.Subsingleton
⊢ l.IsCountablyGenerated
state_after: case inl
α : Type u_1
β : Type u_2
hl : ⊥.Subsingleton
⊢ ⊥.IsCountablyGenerated

case inr.intro
α : Type u_1
β : Type u_2
x : α
hl : (pure x).Subsingleton
⊢ (pure x).IsCountablyGenerated

tactic: exact isCountablyGenerated_bot
state_before: case inl
α : Type u_1
β : Type u_2
hl : ⊥.Subsingleton
⊢ ⊥.IsCountablyGenerated
state_after: no goals

tactic: exact isCountablyGenerated_pure x
state_before: case inr.intro
α : Type u_1
β : Type u_2
x : α
hl : (pure x).Subsingleton
⊢ (pure x).IsCountablyGenerated
state_after: no goals
Theorem: toIcoMod_sub_zsmul
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: rw [sub_eq_add_neg, ← neg_smul, toIcoMod_add_zsmul]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
m : ℤ
⊢ toIcoMod hp a (b - m • p) = toIcoMod hp a b
state_after: no goals