1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Real.arctan_add
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Arctan.lean

tactic: rw [← arctan_tan (x := _ + _)]
state_before: x y : ℝ
h : x * y < 1
⊢ arctan x + arctan y = arctan ((x + y) / (1 - x * y))
state_after: x y : ℝ
h : x * y < 1
⊢ arctan (tan (arctan x + arctan y)) = arctan ((x + y) / (1 - x * y))

case hx₁
x y : ℝ
h : x * y < 1
⊢ -(π / 2) < arctan x + arctan y

case hx₂
x y : ℝ
h : x * y < 1
⊢ arctan x + arctan y < π / 2

tactic: congr
state_before: x y : ℝ
h : x * y < 1
⊢ arctan (tan (arctan x + arctan y)) = arctan ((x + y) / (1 - x * y))
state_after: case e_x
x y : ℝ
h : x * y < 1
⊢ tan (arctan x + arctan y) = (x + y) / (1 - x * y)

tactic: conv_rhs => rw [← tan_arctan x, ← tan_arctan y]
state_before: case e_x
x y : ℝ
h : x * y < 1
⊢ tan (arctan x + arctan y) = (x + y) / (1 - x * y)
state_after: case e_x
x y : ℝ
h : x * y < 1
⊢ tan (arctan x + arctan y) = (tan (arctan x) + tan (arctan y)) / (1 - tan (arctan x) * tan (arctan y))

tactic: exact tan_add' ⟨arctan_ne_mul_pi_div_two, arctan_ne_mul_pi_div_two⟩
state_before: case e_x
x y : ℝ
h : x * y < 1
⊢ tan (arctan x + arctan y) = (tan (arctan x) + tan (arctan y)) / (1 - tan (arctan x) * tan (arctan y))
state_after: no goals

tactic: rw [neg_lt, neg_add, ← arctan_neg, ← arctan_neg]
state_before: case hx₁
x y : ℝ
h : x * y < 1
⊢ -(π / 2) < arctan x + arctan y
state_after: case hx₁
x y : ℝ
h : x * y < 1
⊢ arctan (-x) + arctan (-y) < π / 2

tactic: rw [← neg_mul_neg] at h
state_before: case hx₁
x y : ℝ
h : x * y < 1
⊢ arctan (-x) + arctan (-y) < π / 2
state_after: case hx₁
x y : ℝ
h : -x * -y < 1
⊢ arctan (-x) + arctan (-y) < π / 2

tactic: exact arctan_add_arctan_lt_pi_div_two h
state_before: case hx₁
x y : ℝ
h : -x * -y < 1
⊢ arctan (-x) + arctan (-y) < π / 2
state_after: no goals

tactic: exact arctan_add_arctan_lt_pi_div_two h
state_before: case hx₂
x y : ℝ
h : x * y < 1
⊢ arctan x + arctan y < π / 2
state_after: no goals
Theorem: PerfectClosure.natCast_eq_iff
File: Mathlib/FieldTheory/PerfectClosure.lean

tactic: constructor <;> intro H
state_before: K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
x y : ℕ
⊢ ↑x = ↑y ↔ ↑x = ↑y
state_after: case mp
K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
x y : ℕ
H : ↑x = ↑y
⊢ ↑x = ↑y

case mpr
K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
x y : ℕ
H : ↑x = ↑y
⊢ ↑x = ↑y

tactic: rw [natCast K p 0, natCast K p 0, H]
state_before: case mpr
K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
x y : ℕ
H : ↑x = ↑y
⊢ ↑x = ↑y
state_after: no goals

tactic: rw [natCast K p 0, natCast K p 0, mk_eq_iff] at H
state_before: case mp
K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
x y : ℕ
H : ↑x = ↑y
⊢ ↑x = ↑y
state_after: case mp
K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
x y : ℕ
H : ∃ z, (⇑(frobenius K p))^[(0, ↑y).1 + z] (0, ↑x).2 = (⇑(frobenius K p))^[(0, ↑x).1 + z] (0, ↑y).2
⊢ ↑x = ↑y

tactic: cases' H with z H
state_before: case mp
K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
x y : ℕ
H : ∃ z, (⇑(frobenius K p))^[(0, ↑y).1 + z] (0, ↑x).2 = (⇑(frobenius K p))^[(0, ↑x).1 + z] (0, ↑y).2
⊢ ↑x = ↑y
state_after: case mp.intro
K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
x y z : ℕ
H : (⇑(frobenius K p))^[(0, ↑y).1 + z] (0, ↑x).2 = (⇑(frobenius K p))^[(0, ↑x).1 + z] (0, ↑y).2
⊢ ↑x = ↑y

tactic: simpa only [zero_add, iterate_fixed (frobenius_natCast K p _)] using H
state_before: case mp.intro
K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
x y z : ℕ
H : (⇑(frobenius K p))^[(0, ↑y).1 + z] (0, ↑x).2 = (⇑(frobenius K p))^[(0, ↑x).1 + z] (0, ↑y).2
⊢ ↑x = ↑y
state_after: no goals
Theorem: Function.LeftInverse.cast_eq
File: Mathlib/Logic/Function/Basic.lean

tactic: rw [cast_eq_iff_heq, h]
state_before: α : Sort u_1
β : Sort u_2
γ : β → Sort v
f : α → β
g : β → α
h : LeftInverse g f
C : (a : α) → γ (f a)
a : α
⊢ cast ⋯ (C (g (f a))) = C a
state_after: no goals
Theorem: HeytingHom.cancel_left
File: Mathlib/Order/Heyting/Hom.lean

tactic: rw [← comp_apply, h, comp_apply]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝⁴ : FunLike F α β
inst✝³ : HeytingAlgebra α
inst✝² : HeytingAlgebra β
inst✝¹ : HeytingAlgebra γ
inst✝ : HeytingAlgebra δ
f f₁ f₂ : HeytingHom α β
g g₁ g₂ : HeytingHom β γ
hg : Injective ⇑g
h : g.comp f₁ = g.comp f₂
a : α
⊢ g (f₁ a) = g (f₂ a)
state_after: no goals
Theorem: Set.zero_div_subset
File: Mathlib/Data/Set/Pointwise/Basic.lean

tactic: simp [subset_def, mem_div]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : GroupWithZero α
s✝ t s : Set α
⊢ 0 / s ⊆ 0
state_after: no goals
Theorem: rootsOfUnity.integer_power_of_ringEquiv
File: Mathlib/NumberTheory/Cyclotomic/CyclotomicCharacter.lean

tactic: obtain ⟨m, hm⟩ := MonoidHom.map_cyclic ((g : L ≃* L).restrictRootsOfUnity n).toMonoidHom
state_before: L : Type u
inst✝¹ : CommRing L
inst✝ : IsDomain L
n : ℕ+
g : L ≃+* L
⊢ ∃ m, ∀ (t : ↥(rootsOfUnity n L)), g ↑↑t = ↑(↑t ^ m)
state_after: case intro
L : Type u
inst✝¹ : CommRing L
inst✝ : IsDomain L
n : ℕ+
g : L ≃+* L
m : ℤ
hm : ∀ (g_1 : ↥(rootsOfUnity n L)), ((↑g).restrictRootsOfUnity n).toMonoidHom g_1 = g_1 ^ m
⊢ ∃ m, ∀ (t : ↥(rootsOfUnity n L)), g ↑↑t = ↑(↑t ^ m)

tactic: exact ⟨m, fun t ↦ Units.ext_iff.1 <| SetCoe.ext_iff.2 <| hm t⟩
state_before: case intro
L : Type u
inst✝¹ : CommRing L
inst✝ : IsDomain L
n : ℕ+
g : L ≃+* L
m : ℤ
hm : ∀ (g_1 : ↥(rootsOfUnity n L)), ((↑g).restrictRootsOfUnity n).toMonoidHom g_1 = g_1 ^ m
⊢ ∃ m, ∀ (t : ↥(rootsOfUnity n L)), g ↑↑t = ↑(↑t ^ m)
state_after: no goals
Theorem: LinearIndependent.map'
File: Mathlib/LinearAlgebra/LinearIndependent.lean

tactic: simp [hf_inj]
state_before: ι : Type u'
ι' : Type u_1
R : Type u_2
K : Type u_3
M : Type u_4
M' : Type u_5
M'' : Type u_6
V : Type u
V' : Type u_7
v : ι → M
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : AddCommMonoid M'
inst✝³ : AddCommMonoid M''
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M''
a b : R
x y : M
hv : LinearIndependent R v
f : M →ₗ[R] M'
hf_inj : LinearMap.ker f = ⊥
⊢ Disjoint (span R (range v)) (LinearMap.ker f)
state_after: no goals
Theorem: Set.Subsingleton.isCornerFree
File: Mathlib/Combinatorics/Additive/Corner/Defs.lean

tactic: simpa using hA hxyd.fst_fst_mem hxyd.snd_fst_mem
state_before: G : Type u_1
H : Type u_2
inst✝¹ : AddCommMonoid G
inst✝ : AddCommMonoid H
A B : Set (G × G)
s : Set G
t : Set H
f : G → H
a b c x₁ y₁ x₂ y₂ : G
hA : A.Subsingleton
_x₁ _y₁ _x₂ _y₂ : G
hxyd : IsCorner A _x₁ _y₁ _x₂ _y₂
⊢ _x₁ = _x₂
state_after: no goals
Theorem: AlgebraicGeometry.Spec.locallyRingedSpaceMap_id
File: Mathlib/AlgebraicGeometry/Spec.lean

tactic: rw [Spec.locallyRingedSpaceMap_val, Spec.sheafedSpaceMap_id]
state_before: R : CommRingCat
⊢ (locallyRingedSpaceMap (𝟙 R)).val = (𝟙 (locallyRingedSpaceObj R)).val
state_after: R : CommRingCat
⊢ 𝟙 (sheafedSpaceObj R) = (𝟙 (locallyRingedSpaceObj R)).val

tactic: rfl
state_before: R : CommRingCat
⊢ 𝟙 (sheafedSpaceObj R) = (𝟙 (locallyRingedSpaceObj R)).val
state_after: no goals
Theorem: ContinuousAt.finset_inf'
File: Mathlib/Topology/Order/Lattice.lean

tactic: simpa only [← Finset.inf'_apply] using finset_inf'_apply hne hs
state_before: L : Type u_1
X : Type u_2
inst✝³ : TopologicalSpace L
inst✝² : TopologicalSpace X
ι : Type u_3
inst✝¹ : SemilatticeInf L
inst✝ : ContinuousInf L
s : Finset ι
f : ι → X → L
t : Set X
x : X
hne : s.Nonempty
hs : ∀ i ∈ s, ContinuousAt (f i) x
⊢ ContinuousAt (s.inf' hne f) x
state_after: no goals
Theorem: Polynomial.eval_natCast_map
File: Mathlib/Algebra/Polynomial/Eval.lean

tactic: induction p using Polynomial.induction_on' with
| h_add p q hp hq =>
  simp only [hp, hq, Polynomial.map_add, RingHom.map_add, eval_add]
| h_monomial n r =>
  simp only [map_natCast f, eval_monomial, map_monomial, f.map_pow, f.map_mul]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n✝ : ℕ
inst✝¹ : Semiring R
p✝ q r : R[X]
inst✝ : Semiring S
f✝ f : R →+* S
p : R[X]
n : ℕ
⊢ eval (↑n) (map f p) = f (eval (↑n) p)
state_after: no goals

tactic: simp only [hp, hq, Polynomial.map_add, RingHom.map_add, eval_add]
state_before: case h_add
R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n✝ : ℕ
inst✝¹ : Semiring R
p✝ q✝ r : R[X]
inst✝ : Semiring S
f✝ f : R →+* S
n : ℕ
p q : R[X]
hp : eval (↑n) (map f p) = f (eval (↑n) p)
hq : eval (↑n) (map f q) = f (eval (↑n) q)
⊢ eval (↑n) (map f (p + q)) = f (eval (↑n) (p + q))
state_after: no goals

tactic: simp only [map_natCast f, eval_monomial, map_monomial, f.map_pow, f.map_mul]
state_before: case h_monomial
R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n✝¹ : ℕ
inst✝¹ : Semiring R
p q r✝ : R[X]
inst✝ : Semiring S
f✝ f : R →+* S
n✝ n : ℕ
r : R
⊢ eval (↑n✝) (map f ((monomial n) r)) = f (eval (↑n✝) ((monomial n) r))
state_after: no goals
Theorem: minpoly.eq_of_root
File: Mathlib/FieldTheory/Adjoin.lean

tactic: have hy : IsAlgebraic K y := ⟨minpoly K x, ne_zero hx.isIntegral, h_ev⟩
state_before: K : Type u_1
L : Type u_2
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Algebra K L
x y : L
hx : IsAlgebraic K x
h_ev : (Polynomial.aeval y) (minpoly K x) = 0
⊢ minpoly K y = minpoly K x
state_after: K : Type u_1
L : Type u_2
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Algebra K L
x y : L
hx : IsAlgebraic K x
h_ev : (Polynomial.aeval y) (minpoly K x) = 0
hy : IsAlgebraic K y
⊢ minpoly K y = minpoly K x

tactic: exact Polynomial.eq_of_monic_of_associated (monic hy.isIntegral) (monic hx.isIntegral)
  (Irreducible.associated_of_dvd (irreducible hy.isIntegral)
    (irreducible hx.isIntegral) (dvd K y h_ev))
state_before: K : Type u_1
L : Type u_2
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Algebra K L
x y : L
hx : IsAlgebraic K x
h_ev : (Polynomial.aeval y) (minpoly K x) = 0
hy : IsAlgebraic K y
⊢ minpoly K y = minpoly K x
state_after: no goals
Theorem: Finset.lcm_eq_zero_iff
File: Mathlib/Algebra/GCDMonoid/Finset.lean

tactic: simp only [Multiset.mem_map, lcm_def, Multiset.lcm_eq_zero_iff, Set.mem_image, mem_coe, ←
  Finset.mem_def]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizedGCDMonoid α
s s₁ s₂ : Finset β
f : β → α
inst✝ : Nontrivial α
⊢ s.lcm f = 0 ↔ 0 ∈ f '' ↑s
state_after: no goals
Theorem: Matroid.not_infiniteRk
File: Mathlib/Data/Matroid/Basic.lean

tactic: intro h
state_before: α : Type u_1
M✝ M : Matroid α
inst✝ : M.FiniteRk
⊢ ¬M.InfiniteRk
state_after: α : Type u_1
M✝ M : Matroid α
inst✝ : M.FiniteRk
h : M.InfiniteRk
⊢ False

tactic: obtain ⟨B,hB⟩ := M.exists_base
state_before: α : Type u_1
M✝ M : Matroid α
inst✝ : M.FiniteRk
h : M.InfiniteRk
⊢ False
state_after: case intro
α : Type u_1
M✝ M : Matroid α
inst✝ : M.FiniteRk
h : M.InfiniteRk
B : Set α
hB : M.Base B
⊢ False

tactic: exact hB.infinite hB.finite
state_before: case intro
α : Type u_1
M✝ M : Matroid α
inst✝ : M.FiniteRk
h : M.InfiniteRk
B : Set α
hB : M.Base B
⊢ False
state_after: no goals
Theorem: List.count_not_add_count
File: Mathlib/Data/Bool/Count.lean

tactic: suffices (fun x => x == b) = (fun a => decide ¬(a == !b) = true) by rw [this]
state_before: l : List Bool
b : Bool
⊢ countP (fun x => x == b) l = countP (fun a => decide ¬(a == !b) = true) l
state_after: l : List Bool
b : Bool
⊢ (fun x => x == b) = fun a => decide ¬(a == !b) = true

tactic: ext x
state_before: l : List Bool
b : Bool
⊢ (fun x => x == b) = fun a => decide ¬(a == !b) = true
state_after: case h
l : List Bool
b x : Bool
⊢ (x == b) = decide ¬(x == !b) = true

tactic: cases x <;> cases b <;> rfl
state_before: case h
l : List Bool
b x : Bool
⊢ (x == b) = decide ¬(x == !b) = true
state_after: no goals

tactic: rw [this]
state_before: l : List Bool
b : Bool
this : (fun x => x == b) = fun a => decide ¬(a == !b) = true
⊢ countP (fun x => x == b) l = countP (fun a => decide ¬(a == !b) = true) l
state_after: no goals
Theorem: max_self
File: Mathlib/Init/Order/LinearOrder.lean

tactic: simp [max_def]
state_before: α : Type u
inst✝ : LinearOrder α
a : α
⊢ max a a = a
state_after: no goals
Theorem: Multiset.uIcc_eq
File: Mathlib/Data/Multiset/Interval.lean

tactic: simp [uIcc]
state_before: α : Type u_1
inst✝ : DecidableEq α
s t : Multiset α
⊢ Finset.map equivDFinsupp.symm.toEmbedding (Finset.Icc (toDFinsupp (s ⊓ t)) (toDFinsupp (s ⊔ t))) =
    Finset.map equivDFinsupp.symm.toEmbedding (uIcc (toDFinsupp s) (toDFinsupp t))
state_after: no goals
Theorem: SimpleGraph.Walk.append_copy_copy
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: subst_vars
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v w u' v' w' : V
p : G.Walk u v
q : G.Walk v w
hu : u = u'
hv : v = v'
hw : w = w'
⊢ (p.copy hu hv).append (q.copy hv hw) = (p.append q).copy hu hw
state_after: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u' v' w' : V
p : G.Walk u' v'
q : G.Walk v' w'
⊢ (p.copy ⋯ ⋯).append (q.copy ⋯ ⋯) = (p.append q).copy ⋯ ⋯

tactic: rfl
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u' v' w' : V
p : G.Walk u' v'
q : G.Walk v' w'
⊢ (p.copy ⋯ ⋯).append (q.copy ⋯ ⋯) = (p.append q).copy ⋯ ⋯
state_after: no goals
Theorem: Ordinal.enumOrd_mem_aux
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: rw [enumOrd_def']
state_before: S : Set Ordinal.{u}
hS : Unbounded (fun x x_1 => x < x_1) S
o : Ordinal.{u}
⊢ enumOrd S o ∈ S ∩ Ici (o.blsub fun c x => enumOrd S c)
state_after: S : Set Ordinal.{u}
hS : Unbounded (fun x x_1 => x < x_1) S
o : Ordinal.{u}
⊢ sInf (S ∩ Ici (o.blsub fun a x => enumOrd S a)) ∈ S ∩ Ici (o.blsub fun c x => enumOrd S c)

tactic: exact csInf_mem (enumOrd_def'_nonempty hS _)
state_before: S : Set Ordinal.{u}
hS : Unbounded (fun x x_1 => x < x_1) S
o : Ordinal.{u}
⊢ sInf (S ∩ Ici (o.blsub fun a x => enumOrd S a)) ∈ S ∩ Ici (o.blsub fun c x => enumOrd S c)
state_after: no goals
Theorem: MeasureTheory.upperCrossingTime_lt_lowerCrossingTime
File: Mathlib/Probability/Martingale/Upcrossing.lean

tactic: refine lt_of_le_of_ne upperCrossingTime_le_lowerCrossingTime fun h =>
  not_le.2 hab <| le_trans ?_ (stoppedValue_lowerCrossingTime hn)
state_before: Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f : ℕ → Ω → ℝ
N n m : ℕ
ω : Ω
hab : a < b
hn : lowerCrossingTime a b f N (n + 1) ω ≠ N
⊢ upperCrossingTime a b f N (n + 1) ω < lowerCrossingTime a b f N (n + 1) ω
state_after: Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f : ℕ → Ω → ℝ
N n m : ℕ
ω : Ω
hab : a < b
hn : lowerCrossingTime a b f N (n + 1) ω ≠ N
h : upperCrossingTime a b f N (n + 1) ω = lowerCrossingTime a b f N (n + 1) ω
⊢ b ≤ stoppedValue f (lowerCrossingTime a b f N (n + 1)) ω

tactic: simp only [stoppedValue]
state_before: Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f : ℕ → Ω → ℝ
N n m : ℕ
ω : Ω
hab : a < b
hn : lowerCrossingTime a b f N (n + 1) ω ≠ N
h : upperCrossingTime a b f N (n + 1) ω = lowerCrossingTime a b f N (n + 1) ω
⊢ b ≤ stoppedValue f (lowerCrossingTime a b f N (n + 1)) ω
state_after: Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f : ℕ → Ω → ℝ
N n m : ℕ
ω : Ω
hab : a < b
hn : lowerCrossingTime a b f N (n + 1) ω ≠ N
h : upperCrossingTime a b f N (n + 1) ω = lowerCrossingTime a b f N (n + 1) ω
⊢ b ≤ f (lowerCrossingTime a b f N (n + 1) ω) ω

tactic: rw [← h]
state_before: Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f : ℕ → Ω → ℝ
N n m : ℕ
ω : Ω
hab : a < b
hn : lowerCrossingTime a b f N (n + 1) ω ≠ N
h : upperCrossingTime a b f N (n + 1) ω = lowerCrossingTime a b f N (n + 1) ω
⊢ b ≤ f (lowerCrossingTime a b f N (n + 1) ω) ω
state_after: Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f : ℕ → Ω → ℝ
N n m : ℕ
ω : Ω
hab : a < b
hn : lowerCrossingTime a b f N (n + 1) ω ≠ N
h : upperCrossingTime a b f N (n + 1) ω = lowerCrossingTime a b f N (n + 1) ω
⊢ b ≤ f (upperCrossingTime a b f N (n + 1) ω) ω

tactic: exact stoppedValue_upperCrossingTime (h.symm ▸ hn)
state_before: Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f : ℕ → Ω → ℝ
N n m : ℕ
ω : Ω
hab : a < b
hn : lowerCrossingTime a b f N (n + 1) ω ≠ N
h : upperCrossingTime a b f N (n + 1) ω = lowerCrossingTime a b f N (n + 1) ω
⊢ b ≤ f (upperCrossingTime a b f N (n + 1) ω) ω
state_after: no goals
Theorem: LieAlgebra.abelian_iff_derived_one_eq_bot
File: Mathlib/Algebra/Lie/Solvable.lean

tactic: rw [derivedSeriesOfIdeal_succ, derivedSeriesOfIdeal_zero,
  LieSubmodule.lie_abelian_iff_lie_self_eq_bot]
state_before: R : Type u
L : Type v
M : Type w
L' : Type w₁
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
I J : LieIdeal R L
f : L' →ₗ⁅R⁆ L
⊢ IsLieAbelian ↥↑I ↔ D 1 I = ⊥
state_after: no goals
Theorem: MvPolynomial.hom_bind₁
File: Mathlib/Algebra/MvPolynomial/Monad.lean

tactic: rw [bind₁, map_aeval, algebraMap_eq]
state_before: σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
T : Type u_5
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S
inst✝ : CommSemiring T
f✝ : σ → MvPolynomial τ R
f : MvPolynomial τ R →+* S
g : σ → MvPolynomial τ R
φ : MvPolynomial σ R
⊢ f ((bind₁ g) φ) = (eval₂Hom (f.comp C) fun i => f (g i)) φ
state_after: no goals
Theorem: collinear_iff_finrank_le_one
File: Mathlib/LinearAlgebra/AffineSpace/FiniteDimensional.lean

tactic: have h := collinear_iff_rank_le_one k s
state_before: k : Type u_1
V : Type u_2
P : Type u_3
ι : Type u_4
inst✝⁴ : DivisionRing k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
s : Set P
inst✝ : FiniteDimensional k ↥(vectorSpan k s)
⊢ Collinear k s ↔ finrank k ↥(vectorSpan k s) ≤ 1
state_after: k : Type u_1
V : Type u_2
P : Type u_3
ι : Type u_4
inst✝⁴ : DivisionRing k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
s : Set P
inst✝ : FiniteDimensional k ↥(vectorSpan k s)
h : Collinear k s ↔ Module.rank k ↥(vectorSpan k s) ≤ 1
⊢ Collinear k s ↔ finrank k ↥(vectorSpan k s) ≤ 1

tactic: rw [← finrank_eq_rank] at h
state_before: k : Type u_1
V : Type u_2
P : Type u_3
ι : Type u_4
inst✝⁴ : DivisionRing k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
s : Set P
inst✝ : FiniteDimensional k ↥(vectorSpan k s)
h : Collinear k s ↔ Module.rank k ↥(vectorSpan k s) ≤ 1
⊢ Collinear k s ↔ finrank k ↥(vectorSpan k s) ≤ 1
state_after: k : Type u_1
V : Type u_2
P : Type u_3
ι : Type u_4
inst✝⁴ : DivisionRing k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
s : Set P
inst✝ : FiniteDimensional k ↥(vectorSpan k s)
h : Collinear k s ↔ ↑(finrank k ↥(vectorSpan k s)) ≤ 1
⊢ Collinear k s ↔ finrank k ↥(vectorSpan k s) ≤ 1

tactic: exact mod_cast h
state_before: k : Type u_1
V : Type u_2
P : Type u_3
ι : Type u_4
inst✝⁴ : DivisionRing k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
s : Set P
inst✝ : FiniteDimensional k ↥(vectorSpan k s)
h : Collinear k s ↔ ↑(finrank k ↥(vectorSpan k s)) ≤ 1
⊢ Collinear k s ↔ finrank k ↥(vectorSpan k s) ≤ 1
state_after: no goals
Theorem: ENNReal.isOpen_Ico_zero
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: rw [ENNReal.Ico_eq_Iio]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
⊢ IsOpen (Ico 0 b)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
⊢ IsOpen (Iio b)

tactic: exact isOpen_Iio
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
⊢ IsOpen (Iio b)
state_after: no goals
Theorem: mul_inv_eq_iff_eq_mul
File: Mathlib/Algebra/Group/Basic.lean

tactic: rw [← h, inv_mul_cancel_right]
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a b c d : G
n : ℤ
h : a * b⁻¹ = c
⊢ a = c * b
state_after: no goals

tactic: rw [h, mul_inv_cancel_right]
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a b c d : G
n : ℤ
h : a = c * b
⊢ a * b⁻¹ = c
state_after: no goals
Theorem: QuadraticForm.pi_apply_single
File: Mathlib/LinearAlgebra/QuadraticForm/Prod.lean

tactic: rw [pi_apply, Fintype.sum_eq_single i fun j hj => ?_, Pi.single_eq_same]
state_before: ι : Type u_1
R : Type u_2
M₁ : Type u_3
M₂ : Type u_4
N₁ : Type u_5
N₂ : Type u_6
Mᵢ : ι → Type u_7
Nᵢ : ι → Type u_8
inst✝⁶ : CommSemiring R
inst✝⁵ : (i : ι) → AddCommMonoid (Mᵢ i)
inst✝⁴ : (i : ι) → AddCommMonoid (Nᵢ i)
inst✝³ : (i : ι) → Module R (Mᵢ i)
inst✝² : (i : ι) → Module R (Nᵢ i)
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
Q : (i : ι) → QuadraticForm R (Mᵢ i)
i : ι
m : Mᵢ i
⊢ (pi Q) (Pi.single i m) = (Q i) m
state_after: ι : Type u_1
R : Type u_2
M₁ : Type u_3
M₂ : Type u_4
N₁ : Type u_5
N₂ : Type u_6
Mᵢ : ι → Type u_7
Nᵢ : ι → Type u_8
inst✝⁶ : CommSemiring R
inst✝⁵ : (i : ι) → AddCommMonoid (Mᵢ i)
inst✝⁴ : (i : ι) → AddCommMonoid (Nᵢ i)
inst✝³ : (i : ι) → Module R (Mᵢ i)
inst✝² : (i : ι) → Module R (Nᵢ i)
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
Q : (i : ι) → QuadraticForm R (Mᵢ i)
i : ι
m : Mᵢ i
j : ι
hj : j ≠ i
⊢ (Q j) (Pi.single i m j) = 0

tactic: rw [Pi.single_eq_of_ne hj, map_zero]
state_before: ι : Type u_1
R : Type u_2
M₁ : Type u_3
M₂ : Type u_4
N₁ : Type u_5
N₂ : Type u_6
Mᵢ : ι → Type u_7
Nᵢ : ι → Type u_8
inst✝⁶ : CommSemiring R
inst✝⁵ : (i : ι) → AddCommMonoid (Mᵢ i)
inst✝⁴ : (i : ι) → AddCommMonoid (Nᵢ i)
inst✝³ : (i : ι) → Module R (Mᵢ i)
inst✝² : (i : ι) → Module R (Nᵢ i)
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
Q : (i : ι) → QuadraticForm R (Mᵢ i)
i : ι
m : Mᵢ i
j : ι
hj : j ≠ i
⊢ (Q j) (Pi.single i m j) = 0
state_after: no goals
Theorem: supPrime_iff_not_isMin
File: Mathlib/Order/Irreducible.lean

tactic: simp
state_before: ι : Type u_1
α : Type u_2
inst✝ : LinearOrder α
a : α
⊢ ∀ ⦃b c : α⦄, a ≤ b ⊔ c → a ≤ b ∨ a ≤ c
state_after: no goals
Theorem: EqualCharZero.pnatCast_one
File: Mathlib/Algebra/CharP/MixedCharZero.lean

tactic: apply Units.ext
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : Fact (∀ (I : Ideal R), I ≠ ⊤ → CharZero (R ⧸ I))
⊢ ↑1 = 1
state_after: case a
R : Type u_1
inst✝¹ : CommRing R
inst✝ : Fact (∀ (I : Ideal R), I ≠ ⊤ → CharZero (R ⧸ I))
⊢ ↑↑1 = ↑1

tactic: rw [Units.val_one]
state_before: case a
R : Type u_1
inst✝¹ : CommRing R
inst✝ : Fact (∀ (I : Ideal R), I ≠ ⊤ → CharZero (R ⧸ I))
⊢ ↑↑1 = ↑1
state_after: case a
R : Type u_1
inst✝¹ : CommRing R
inst✝ : Fact (∀ (I : Ideal R), I ≠ ⊤ → CharZero (R ⧸ I))
⊢ ↑↑1 = 1

tactic: change ((PNat.isUnit_natCast (R := R) 1).unit : R) = 1
state_before: case a
R : Type u_1
inst✝¹ : CommRing R
inst✝ : Fact (∀ (I : Ideal R), I ≠ ⊤ → CharZero (R ⧸ I))
⊢ ↑↑1 = 1
state_after: case a
R : Type u_1
inst✝¹ : CommRing R
inst✝ : Fact (∀ (I : Ideal R), I ≠ ⊤ → CharZero (R ⧸ I))
⊢ ↑⋯.unit = 1

tactic: rw [IsUnit.unit_spec (PNat.isUnit_natCast 1)]
state_before: case a
R : Type u_1
inst✝¹ : CommRing R
inst✝ : Fact (∀ (I : Ideal R), I ≠ ⊤ → CharZero (R ⧸ I))
⊢ ↑⋯.unit = 1
state_after: case a
R : Type u_1
inst✝¹ : CommRing R
inst✝ : Fact (∀ (I : Ideal R), I ≠ ⊤ → CharZero (R ⧸ I))
⊢ ↑↑1 = 1

tactic: rw [PNat.one_coe, Nat.cast_one]
state_before: case a
R : Type u_1
inst✝¹ : CommRing R
inst✝ : Fact (∀ (I : Ideal R), I ≠ ⊤ → CharZero (R ⧸ I))
⊢ ↑↑1 = 1
state_after: no goals