ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Batteries.LTCmp.eq_compareOfLessAndEq
File: .lake/packages/batteries/Batteries/Classes/Order.lean

Proof steps:
state_before: α : Type u_1
cmp : α → α → Ordering
inst✝⁶ : LT α
inst✝⁵ : DecidableEq α
inst✝⁴ : BEq α
inst✝³ : LawfulBEq α
inst✝² : BEqCmp cmp
inst✝¹ : LTCmp cmp
x y : α
inst✝ : Decidable (x < y)
⊢ cmp x y = compareOfLessAndEq x y
state_after: α : Type u_1
cmp : α → α → Ordering
inst✝⁶ : LT α
inst✝⁵ : DecidableEq α
inst✝⁴ : BEq α
inst✝³ : LawfulBEq α
inst✝² : BEqCmp cmp
inst✝¹ : LTCmp cmp
x y : α
inst✝ : Decidable (x < y)
⊢ cmp x y = if x < y then Ordering.lt else if x = y then Ordering.eq else Ordering.gt
tactic: simp [compareOfLessAndEq]
state_before: α : Type u_1
cmp : α → α → Ordering
inst✝⁶ : LT α
inst✝⁵ : DecidableEq α
inst✝⁴ : BEq α
inst✝³ : LawfulBEq α
inst✝² : BEqCmp cmp
inst✝¹ : LTCmp cmp
x y : α
inst✝ : Decidable (x < y)
⊢ cmp x y = if x < y then Ordering.lt else if x = y then Ordering.eq else Ordering.gt
state_after: case isTrue
α : Type u_1
cmp : α → α → Ordering
inst✝⁶ : LT α
inst✝⁵ : DecidableEq α
inst✝⁴ : BEq α
inst✝³ : LawfulBEq α
inst✝² : BEqCmp cmp
inst✝¹ : LTCmp cmp
x y : α
inst✝ : Decidable (x < y)
h1 : x < y
⊢ cmp x y = Ordering.lt

case isFalse.isTrue
α : Type u_1
cmp : α → α → Ordering
inst✝⁶ : LT α
inst✝⁵ : DecidableEq α
inst✝⁴ : BEq α
inst✝³ : LawfulBEq α
inst✝² : BEqCmp cmp
inst✝¹ : LTCmp cmp
x y : α
inst✝ : Decidable (x < y)
h1 : ¬x < y
h2 : x = y
⊢ cmp x y = Ordering.eq

case isFalse.isFalse
α : Type u_1
cmp : α → α → Ordering
inst✝⁶ : LT α
inst✝⁵ : DecidableEq α
inst✝⁴ : BEq α
inst✝³ : LawfulBEq α
inst✝² : BEqCmp cmp
inst✝¹ : LTCmp cmp
x y : α
inst✝ : Decidable (x < y)
h1 : ¬x < y
h2 : ¬x = y
⊢ cmp x y = Ordering.gt
tactic: split <;> rename_i h1 <;> [skip; split <;> rename_i h2]
Theorem: Monoid.CoprodI.Word.equivPair_smul_same
File: Mathlib/GroupTheory/CoprodI.lean

Proof steps:
state_before: ι : Type u_1
M : ι → Type u_2
inst✝³ : (i : ι) → Monoid (M i)
N : Type u_3
inst✝² : Monoid N
inst✝¹ : (i : ι) → DecidableEq (M i)
inst✝ : DecidableEq ι
i : ι
m : M i
w : Word M
⊢ (equivPair i) (of m • w) = { head := m * ((equivPair i) w).head, tail := ((equivPair i) w).tail, fstIdx_ne := ⋯ }
state_after: ι : Type u_1
M : ι → Type u_2
inst✝³ : (i : ι) → Monoid (M i)
N : Type u_3
inst✝² : Monoid N
inst✝¹ : (i : ι) → DecidableEq (M i)
inst✝ : DecidableEq ι
i : ι
m : M i
w : Word M
⊢ (equivPair i)
      ((equivPair i).symm
        (let __src := (equivPair i) w;
        { head := m * ((equivPair i) w).head, tail := __src.tail, fstIdx_ne := ⋯ })) =
    { head := m * ((equivPair i) w).head, tail := ((equivPair i) w).tail, fstIdx_ne := ⋯ }
tactic: rw [of_smul_def, ← equivPair_symm]
state_before: ι : Type u_1
M : ι → Type u_2
inst✝³ : (i : ι) → Monoid (M i)
N : Type u_3
inst✝² : Monoid N
inst✝¹ : (i : ι) → DecidableEq (M i)
inst✝ : DecidableEq ι
i : ι
m : M i
w : Word M
⊢ (equivPair i)
      ((equivPair i).symm
        (let __src := (equivPair i) w;
        { head := m * ((equivPair i) w).head, tail := __src.tail, fstIdx_ne := ⋯ })) =
    { head := m * ((equivPair i) w).head, tail := ((equivPair i) w).tail, fstIdx_ne := ⋯ }
state_after: no goals
tactic: simp
Theorem: List.disjoint_append_right
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: α✝ : Type u_1
l l₁ l₂ : List α✝
⊢ (l₁ ++ l₂).Disjoint l ↔ l.Disjoint l₁ ∧ l.Disjoint l₂
state_after: α✝ : Type u_1
l l₁ l₂ : List α✝
⊢ l₁.Disjoint l ∧ l₂.Disjoint l ↔ l.Disjoint l₁ ∧ l.Disjoint l₂
tactic: rw [disjoint_append_left]
state_before: α✝ : Type u_1
l l₁ l₂ : List α✝
⊢ l₁.Disjoint l ∧ l₂.Disjoint l ↔ l.Disjoint l₁ ∧ l.Disjoint l₂
state_after: no goals
tactic: simp [disjoint_comm]
Theorem: essSup_le_of_ae_le
File: Mathlib/MeasureTheory/Function/EssSup.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
inst✝ : CompleteLattice β
f : α → β
c : β
hf : f ≤ᶠ[ae μ] fun x => c
⊢ IsCoboundedUnder (fun x x_1 => x ≤ x_1) (ae μ) f
state_after: no goals
tactic: isBoundedDefault
Theorem: CategoryTheory.Idempotents.Karoubi.comp_p
File: Mathlib/CategoryTheory/Idempotents/Karoubi.lean

Proof steps:
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
P Q : Karoubi C
f : P.Hom Q
⊢ f.f ≫ Q.p = f.f
state_after: no goals
tactic: rw [f.comm, assoc, assoc, Q.idem]
Theorem: IsAddUnit.add_val_neg
File: Mathlib/Algebra/Group/Units.lean

Proof steps:
state_before: α : Type u
M : Type u_1
N : Type u_2
inst✝ : Monoid M
a b c : M
h : IsUnit a
⊢ a * ↑h.unit⁻¹ = 1
state_after: α : Type u
M : Type u_1
N : Type u_2
inst✝ : Monoid M
a b c : M
h : IsUnit a
⊢ a * ↑h.unit⁻¹ = ↑h.unit * ↑h.unit⁻¹
tactic: rw [← h.unit.mul_inv]
state_before: α : Type u
M : Type u_1
N : Type u_2
inst✝ : Monoid M
a b c : M
h : IsUnit a
⊢ a * ↑h.unit⁻¹ = ↑h.unit * ↑h.unit⁻¹
state_after: no goals
tactic: congr
Theorem: Liouville.exists_one_le_pow_mul_dist
File: Mathlib/NumberTheory/Liouville/Basic.lean

Proof steps:
state_before: Z : Type u_1
N : Type u_2
R : Type u_3
inst✝ : PseudoMetricSpace R
d : N → ℝ
j : Z → N → R
f : R → R
α : R
ε M : ℝ
d0 : ∀ (a : N), 1 ≤ d a
e0 : 0 < ε
B : ∀ ⦃y : R⦄, y ∈ closedBall α ε → dist (f α) (f y) ≤ dist α y * M
L : ∀ ⦃z : Z⦄ ⦃a : N⦄, j z a ∈ closedBall α ε → 1 ≤ d a * dist (f α) (f (j z a))
⊢ ∃ A, 0 < A ∧ ∀ (z : Z) (a : N), 1 ≤ d a * (dist α (j z a) * A)
state_after: Z : Type u_1
N : Type u_2
R : Type u_3
inst✝ : PseudoMetricSpace R
d : N → ℝ
j : Z → N → R
f : R → R
α : R
ε M : ℝ
d0 : ∀ (a : N), 1 ≤ d a
e0 : 0 < ε
B : ∀ ⦃y : R⦄, y ∈ closedBall α ε → dist (f α) (f y) ≤ dist α y * M
L : ∀ ⦃z : Z⦄ ⦃a : N⦄, j z a ∈ closedBall α ε → 1 ≤ d a * dist (f α) (f (j z a))
me0 : 0 < max (1 / ε) M
⊢ ∃ A, 0 < A ∧ ∀ (z : Z) (a : N), 1 ≤ d a * (dist α (j z a) * A)
tactic: have me0 : 0 < max (1 / ε) M := lt_max_iff.mpr (Or.inl (one_div_pos.mpr e0))
state_before: Z : Type u_1
N : Type u_2
R : Type u_3
inst✝ : PseudoMetricSpace R
d : N → ℝ
j : Z → N → R
f : R → R
α : R
ε M : ℝ
d0 : ∀ (a : N), 1 ≤ d a
e0 : 0 < ε
B : ∀ ⦃y : R⦄, y ∈ closedBall α ε → dist (f α) (f y) ≤ dist α y * M
L : ∀ ⦃z : Z⦄ ⦃a : N⦄, j z a ∈ closedBall α ε → 1 ≤ d a * dist (f α) (f (j z a))
me0 : 0 < max (1 / ε) M
⊢ ∃ A, 0 < A ∧ ∀ (z : Z) (a : N), 1 ≤ d a * (dist α (j z a) * A)
state_after: Z : Type u_1
N : Type u_2
R : Type u_3
inst✝ : PseudoMetricSpace R
d : N → ℝ
j : Z → N → R
f : R → R
α : R
ε M : ℝ
d0 : ∀ (a : N), 1 ≤ d a
e0 : 0 < ε
B : ∀ ⦃y : R⦄, y ∈ closedBall α ε → dist (f α) (f y) ≤ dist α y * M
L : ∀ ⦃z : Z⦄ ⦃a : N⦄, j z a ∈ closedBall α ε → 1 ≤ d a * dist (f α) (f (j z a))
me0 : 0 < max (1 / ε) M
z : Z
a : N
⊢ 1 ≤ d a * (dist α (j z a) * max (1 / ε) M)
tactic: refine ⟨max (1 / ε) M, me0, fun z a => ?_⟩
state_before: Z : Type u_1
N : Type u_2
R : Type u_3
inst✝ : PseudoMetricSpace R
d : N → ℝ
j : Z → N → R
f : R → R
α : R
ε M : ℝ
d0 : ∀ (a : N), 1 ≤ d a
e0 : 0 < ε
B : ∀ ⦃y : R⦄, y ∈ closedBall α ε → dist (f α) (f y) ≤ dist α y * M
L : ∀ ⦃z : Z⦄ ⦃a : N⦄, j z a ∈ closedBall α ε → 1 ≤ d a * dist (f α) (f (j z a))
me0 : 0 < max (1 / ε) M
z : Z
a : N
⊢ 1 ≤ d a * (dist α (j z a) * max (1 / ε) M)
state_after: case pos
Z : Type u_1
N : Type u_2
R : Type u_3
inst✝ : PseudoMetricSpace R
d : N → ℝ
j : Z → N → R
f : R → R
α : R
ε M : ℝ
d0 : ∀ (a : N), 1 ≤ d a
e0 : 0 < ε
B : ∀ ⦃y : R⦄, y ∈ closedBall α ε → dist (f α) (f y) ≤ dist α y * M
L : ∀ ⦃z : Z⦄ ⦃a : N⦄, j z a ∈ closedBall α ε → 1 ≤ d a * dist (f α) (f (j z a))
me0 : 0 < max (1 / ε) M
z : Z
a : N
dm1 : 1 ≤ dist α (j z a) * max (1 / ε) M
⊢ 1 ≤ d a * (dist α (j z a) * max (1 / ε) M)

case neg
Z : Type u_1
N : Type u_2
R : Type u_3
inst✝ : PseudoMetricSpace R
d : N → ℝ
j : Z → N → R
f : R → R
α : R
ε M : ℝ
d0 : ∀ (a : N), 1 ≤ d a
e0 : 0 < ε
B : ∀ ⦃y : R⦄, y ∈ closedBall α ε → dist (f α) (f y) ≤ dist α y * M
L : ∀ ⦃z : Z⦄ ⦃a : N⦄, j z a ∈ closedBall α ε → 1 ≤ d a * dist (f α) (f (j z a))
me0 : 0 < max (1 / ε) M
z : Z
a : N
dm1 : ¬1 ≤ dist α (j z a) * max (1 / ε) M
⊢ 1 ≤ d a * (dist α (j z a) * max (1 / ε) M)
tactic: by_cases dm1 : 1 ≤ dist α (j z a) * max (1 / ε) M
Theorem: Polynomial.natDegree_eq_of_degree_eq
File: Mathlib/Algebra/Polynomial/Degree/Definitions.lean

Proof steps:
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝¹ : Semiring R
p q✝ r : R[X]
inst✝ : Semiring S
q : S[X]
h : p.degree = q.degree
⊢ p.natDegree = q.natDegree
state_after: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝¹ : Semiring R
p q✝ r : R[X]
inst✝ : Semiring S
q : S[X]
h : p.degree = q.degree
⊢ WithBot.unbot' 0 p.degree = WithBot.unbot' 0 q.degree
tactic: unfold natDegree
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝¹ : Semiring R
p q✝ r : R[X]
inst✝ : Semiring S
q : S[X]
h : p.degree = q.degree
⊢ WithBot.unbot' 0 p.degree = WithBot.unbot' 0 q.degree
state_after: no goals
tactic: rw [h]
Theorem: dist_sub_right
File: Mathlib/Topology/MetricSpace/IsometricSMul.lean

Proof steps:
state_before: M : Type u
G : Type v
X : Type w
inst✝² : DivInvMonoid M
inst✝¹ : PseudoMetricSpace M
inst✝ : IsometricSMul Mᵐᵒᵖ M
a b c : M
⊢ dist (a / c) (b / c) = dist a b
state_after: no goals
tactic: simp only [div_eq_mul_inv, dist_mul_right]
Theorem: Int.cast_neg_natCast
File: Mathlib/Data/Int/Cast/Field.lean

Proof steps:
state_before: α : Type u_1
R : Type u_2
inst✝ : DivisionRing R
n : ℕ
⊢ ↑(-↑n) = -↑n
state_after: no goals
tactic: simp
Theorem: PowerBasis.adjoin_eq_top_of_gen_mem_adjoin
File: Mathlib/RingTheory/PowerBasis.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
T : Type u_3
inst✝⁷ : CommRing R
inst✝⁶ : Ring S
inst✝⁵ : Algebra R S
A : Type u_4
B✝ : Type u_5
inst✝⁴ : CommRing A
inst✝³ : CommRing B✝
inst✝² : IsDomain B✝
inst✝¹ : Algebra A B✝
K : Type u_6
inst✝ : Field K
B : PowerBasis R S
x : S
hx : B.gen ∈ adjoin R {x}
⊢ adjoin R {x} = ⊤
state_after: R : Type u_1
S : Type u_2
T : Type u_3
inst✝⁷ : CommRing R
inst✝⁶ : Ring S
inst✝⁵ : Algebra R S
A : Type u_4
B✝ : Type u_5
inst✝⁴ : CommRing A
inst✝³ : CommRing B✝
inst✝² : IsDomain B✝
inst✝¹ : Algebra A B✝
K : Type u_6
inst✝ : Field K
B : PowerBasis R S
x : S
hx : B.gen ∈ adjoin R {x}
⊢ adjoin R {B.gen} ≤ adjoin R {x}
tactic: rw [_root_.eq_top_iff, ← B.adjoin_gen_eq_top]
state_before: R : Type u_1
S : Type u_2
T : Type u_3
inst✝⁷ : CommRing R
inst✝⁶ : Ring S
inst✝⁵ : Algebra R S
A : Type u_4
B✝ : Type u_5
inst✝⁴ : CommRing A
inst✝³ : CommRing B✝
inst✝² : IsDomain B✝
inst✝¹ : Algebra A B✝
K : Type u_6
inst✝ : Field K
B : PowerBasis R S
x : S
hx : B.gen ∈ adjoin R {x}
⊢ adjoin R {B.gen} ≤ adjoin R {x}
state_after: R : Type u_1
S : Type u_2
T : Type u_3
inst✝⁷ : CommRing R
inst✝⁶ : Ring S
inst✝⁵ : Algebra R S
A : Type u_4
B✝ : Type u_5
inst✝⁴ : CommRing A
inst✝³ : CommRing B✝
inst✝² : IsDomain B✝
inst✝¹ : Algebra A B✝
K : Type u_6
inst✝ : Field K
B : PowerBasis R S
x : S
hx : B.gen ∈ adjoin R {x}
⊢ {B.gen} ⊆ ↑(adjoin R {x})
tactic: refine adjoin_le ?_
state_before: R : Type u_1
S : Type u_2
T : Type u_3
inst✝⁷ : CommRing R
inst✝⁶ : Ring S
inst✝⁵ : Algebra R S
A : Type u_4
B✝ : Type u_5
inst✝⁴ : CommRing A
inst✝³ : CommRing B✝
inst✝² : IsDomain B✝
inst✝¹ : Algebra A B✝
K : Type u_6
inst✝ : Field K
B : PowerBasis R S
x : S
hx : B.gen ∈ adjoin R {x}
⊢ {B.gen} ⊆ ↑(adjoin R {x})
state_after: no goals
tactic: simp [hx]
Theorem: MeasureTheory.martingale_const
File: Mathlib/Probability/Martingale/Basic.lean

Proof steps:
state_before: Ω : Type u_1
E : Type u_2
ι : Type u_3
inst✝⁴ : Preorder ι
m0 : MeasurableSpace Ω
μ✝ : Measure Ω
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : CompleteSpace E
f g : ι → Ω → E
ℱ✝ ℱ : Filtration ι m0
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
x : E
i j : ι
x✝ : i ≤ j
⊢ μ[(fun x_1 x_2 => x) j|↑ℱ i] =ᶠ[ae μ] (fun x_1 x_2 => x) i
state_after: no goals
tactic: rw [condexp_const (ℱ.le _)]
Theorem: Polynomial.mirror_natTrailingDegree
File: Mathlib/Algebra/Polynomial/Mirror.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Semiring R
p q : R[X]
⊢ p.mirror.natTrailingDegree = p.natTrailingDegree
state_after: case pos
R : Type u_1
inst✝ : Semiring R
p q : R[X]
hp : p = 0
⊢ p.mirror.natTrailingDegree = p.natTrailingDegree

case neg
R : Type u_1
inst✝ : Semiring R
p q : R[X]
hp : ¬p = 0
⊢ p.mirror.natTrailingDegree = p.natTrailingDegree
tactic: by_cases hp : p = 0
Theorem: CategoryTheory.Subobject.factorThru_mk_self
File: Mathlib/CategoryTheory/Subobject/FactorThru.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
f : X ⟶ Y
inst✝ : Mono f
⊢ (mk f).factorThru f ⋯ = (underlyingIso f).inv
state_after: case h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
f : X ⟶ Y
inst✝ : Mono f
⊢ (mk f).factorThru f ⋯ ≫ (mk f).arrow = (underlyingIso f).inv ≫ (mk f).arrow
tactic: ext
state_before: case h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
f : X ⟶ Y
inst✝ : Mono f
⊢ (mk f).factorThru f ⋯ ≫ (mk f).arrow = (underlyingIso f).inv ≫ (mk f).arrow
state_after: no goals
tactic: simp
Theorem: Set.image_const_sub_uIcc
File: Mathlib/Data/Set/Pointwise/Interval.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a b c d : α
⊢ (fun x => a - x) '' [[b, c]] = [[a - b, a - c]]
state_after: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a b c d : α
this : ∀ (a_1 : Set α), ((fun x => a + x) ∘ fun x => -x) '' a_1 = (fun x => a + x) '' ((fun x => -x) '' a_1)
⊢ (fun x => a - x) '' [[b, c]] = [[a - b, a - c]]
tactic: have := image_comp (fun x => a + x) fun x => -x
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a b c d : α
this : ∀ (a_1 : Set α), ((fun x => a + x) ∘ fun x => -x) '' a_1 = (fun x => a + x) '' ((fun x => -x) '' a_1)
⊢ (fun x => a - x) '' [[b, c]] = [[a - b, a - c]]
state_after: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a b c d : α
this : ∀ (a_1 : Set α), (fun x => a + -x) '' a_1 = (fun x => a + x) '' ((fun x => -x) '' a_1)
⊢ (fun x => a - x) '' [[b, c]] = [[a - b, a - c]]
tactic: dsimp [Function.comp_def] at this
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a b c d : α
this : ∀ (a_1 : Set α), (fun x => a + -x) '' a_1 = (fun x => a + x) '' ((fun x => -x) '' a_1)
⊢ (fun x => a - x) '' [[b, c]] = [[a - b, a - c]]
state_after: no goals
tactic: simp [sub_eq_add_neg, this, add_comm]
Theorem: Finset.centerMass_smul_left
File: Mathlib/Analysis/Convex/Combination.lean

Proof steps:
state_before: R : Type u_1
R' : Type u_2
E : Type u_3
F : Type u_4
ι : Type u_5
ι' : Type u_6
α : Type u_7
inst✝¹⁴ : LinearOrderedField R
inst✝¹³ : LinearOrderedField R'
inst✝¹² : AddCommGroup E
inst✝¹¹ : AddCommGroup F
inst✝¹⁰ : LinearOrderedAddCommGroup α
inst✝⁹ : Module R E
inst✝⁸ : Module R F
inst✝⁷ : Module R α
inst✝⁶ : OrderedSMul R α
s : Set E
i j : ι
c✝ : R
t : Finset ι
w : ι → R
z : ι → E
c : R'
inst✝⁵ : Module R' R
inst✝⁴ : Module R' E
inst✝³ : SMulCommClass R' R R
inst✝² : IsScalarTower R' R R
inst✝¹ : SMulCommClass R R' E
inst✝ : IsScalarTower R' R E
hc : c ≠ 0
⊢ t.centerMass (c • w) z = t.centerMass w z
state_after: no goals
tactic: simp [centerMass, -smul_assoc, smul_assoc c, ← smul_sum, smul_inv₀, smul_smul_smul_comm, hc]
Theorem: Set.sep_eq_empty_iff_mem_false
File: Mathlib/Data/Set/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
p q : α → Prop
x : α
⊢ {x | x ∈ s ∧ p x} = ∅ ↔ ∀ x ∈ s, ¬p x
state_after: no goals
tactic: simp_rw [Set.ext_iff, mem_sep_iff, mem_empty_iff_false, iff_false_iff, not_and]
Theorem: vsub_vadd_eq_vsub_sub
File: Mathlib/Algebra/AddTorsor.lean

Proof steps:
state_before: G : Type u_1
P : Type u_2
inst✝ : AddGroup G
T : AddTorsor G P
p₁ p₂ : P
g : G
⊢ p₁ -ᵥ (g +ᵥ p₂) = p₁ -ᵥ p₂ - g
state_after: no goals
tactic: rw [← add_right_inj (p₂ -ᵥ p₁ : G), vsub_add_vsub_cancel, ← neg_vsub_eq_vsub_rev, vadd_vsub, ←
    add_sub_assoc, ← neg_vsub_eq_vsub_rev, neg_add_self, zero_sub]
Theorem: RegularExpression.mul_rmatch_iff
File: Mathlib/Computability/RegularExpressions.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a b : α
P Q : RegularExpression α
x : List α
⊢ (P * Q).rmatch x = true ↔ ∃ t u, x = t ++ u ∧ P.rmatch t = true ∧ Q.rmatch u = true
state_after: case nil
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a b : α
P Q : RegularExpression α
⊢ (P * Q).rmatch [] = true ↔ ∃ t u, [] = t ++ u ∧ P.rmatch t = true ∧ Q.rmatch u = true

case cons
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a✝ b a : α
x : List α
ih : ∀ (P Q : RegularExpression α), (P * Q).rmatch x = true ↔ ∃ t u, x = t ++ u ∧ P.rmatch t = true ∧ Q.rmatch u = true
P Q : RegularExpression α
⊢ (P * Q).rmatch (a :: x) = true ↔ ∃ t u, a :: x = t ++ u ∧ P.rmatch t = true ∧ Q.rmatch u = true
tactic: induction' x with a x ih generalizing P Q
Theorem: Submonoid.val_inv_unitsTypeEquivIsUnitSubmonoid_symm_apply
File: Mathlib/Algebra/Group/Submonoid/Operations.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝⁴ : MulOneClass M
inst✝³ : MulOneClass N
inst✝² : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝¹ : SetLike A M
hA : SubmonoidClass A M
S' : A
inst✝ : Monoid M
x : ↥(IsUnit.submonoid M)
⊢ (fun x => ⟨↑x, ⋯⟩) ((fun x => IsUnit.unit ⋯) x) = x
state_after: no goals
tactic: simp_rw [IsUnit.unit_spec]
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝⁴ : MulOneClass M
inst✝³ : MulOneClass N
inst✝² : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝¹ : SetLike A M
hA : SubmonoidClass A M
S' : A
inst✝ : Monoid M
x y : Mˣ
⊢ { toFun := fun x => ⟨↑x, ⋯⟩, invFun := fun x => IsUnit.unit ⋯, left_inv := ⋯, right_inv := ⋯ }.toFun (x * y) =
    { toFun := fun x => ⟨↑x, ⋯⟩, invFun := fun x => IsUnit.unit ⋯, left_inv := ⋯, right_inv := ⋯ }.toFun x *
      { toFun := fun x => ⟨↑x, ⋯⟩, invFun := fun x => IsUnit.unit ⋯, left_inv := ⋯, right_inv := ⋯ }.toFun y
state_after: M : Type u_1
N : Type u_2
P : Type u_3
inst✝⁴ : MulOneClass M
inst✝³ : MulOneClass N
inst✝² : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝¹ : SetLike A M
hA : SubmonoidClass A M
S' : A
inst✝ : Monoid M
x y : Mˣ
⊢ ⟨↑x * ↑y, ⋯⟩ = ⟨↑x, ⋯⟩ * ⟨↑y, ⋯⟩
tactic: simp_rw [Units.val_mul]
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝⁴ : MulOneClass M
inst✝³ : MulOneClass N
inst✝² : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝¹ : SetLike A M
hA : SubmonoidClass A M
S' : A
inst✝ : Monoid M
x y : Mˣ
⊢ ⟨↑x * ↑y, ⋯⟩ = ⟨↑x, ⋯⟩ * ⟨↑y, ⋯⟩
state_after: no goals
tactic: rfl
Theorem: Monoid.CoprodI.Word.mem_equivPair_tail_iff
File: Mathlib/GroupTheory/CoprodI.lean

Proof steps:
state_before: ι : Type u_1
M : ι → Type u_2
inst✝³ : (i : ι) → Monoid (M i)
N : Type u_3
inst✝² : Monoid N
inst✝¹ : (i : ι) → DecidableEq (M i)
inst✝ : DecidableEq ι
i j : ι
w : Word M
m : M i
⊢ ⟨i, m⟩ ∈ ((equivPair j) w).tail.toList ↔
    ⟨i, m⟩ ∈ w.toList.tail ∨ i ≠ j ∧ ∃ (h : w.toList ≠ []), w.toList.head h = ⟨i, m⟩
state_after: ι : Type u_1
M : ι → Type u_2
inst✝³ : (i : ι) → Monoid (M i)
N : Type u_3
inst✝² : Monoid N
inst✝¹ : (i : ι) → DecidableEq (M i)
inst✝ : DecidableEq ι
i j : ι
w : Word M
m : M i
⊢ ⟨i, m⟩ ∈
      (↑(consRecOn w ⟨{ head := 1, tail := empty, fstIdx_ne := ⋯ }, ⋯⟩ fun j_1 m w h1 h2 x =>
              if ij : j = j_1 then ⟨{ head := ⋯ ▸ m, tail := w, fstIdx_ne := ⋯ }, ⋯⟩
              else ⟨{ head := 1, tail := cons m w h1 h2, fstIdx_ne := ⋯ }, ⋯⟩)).tail.toList ↔
    ⟨i, m⟩ ∈ w.toList.tail ∨ ¬i = j ∧ ∃ (h : ¬w.toList = []), w.toList.head h = ⟨i, m⟩
tactic: simp only [equivPair, equivPairAux, ne_eq, Equiv.coe_fn_mk]
Theorem: IsLocalDiffeomorphAt.contMDiffAt
File: Mathlib/Geometry/Manifold/LocalDiffeomorph.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace 𝕜 F
H : Type u_4
inst✝⁵ : TopologicalSpace H
G : Type u_5
inst✝⁴ : TopologicalSpace G
I : ModelWithCorners 𝕜 E H
J : ModelWithCorners 𝕜 F G
M : Type u_6
inst✝³ : TopologicalSpace M
inst✝² : ChartedSpace H M
N : Type u_7
inst✝¹ : TopologicalSpace N
inst✝ : ChartedSpace G N
n : ℕ∞
f : M → N
s : Set M
x : M
hf : IsLocalDiffeomorphAt I J n f x
⊢ ContMDiffAt I J n f x
state_after: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace 𝕜 F
H : Type u_4
inst✝⁵ : TopologicalSpace H
G : Type u_5
inst✝⁴ : TopologicalSpace G
I : ModelWithCorners 𝕜 E H
J : ModelWithCorners 𝕜 F G
M : Type u_6
inst✝³ : TopologicalSpace M
inst✝² : ChartedSpace H M
N : Type u_7
inst✝¹ : TopologicalSpace N
inst✝ : ChartedSpace G N
n : ℕ∞
f : M → N
s : Set M
x : M
Φ : PartialDiffeomorph I J M N n
hx : x ∈ Φ.source
heq : EqOn f (↑Φ.toPartialEquiv) Φ.source
⊢ ContMDiffAt I J n f x
tactic: choose Φ hx heq using hf
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace 𝕜 F
H : Type u_4
inst✝⁵ : TopologicalSpace H
G : Type u_5
inst✝⁴ : TopologicalSpace G
I : ModelWithCorners 𝕜 E H
J : ModelWithCorners 𝕜 F G
M : Type u_6
inst✝³ : TopologicalSpace M
inst✝² : ChartedSpace H M
N : Type u_7
inst✝¹ : TopologicalSpace N
inst✝ : ChartedSpace G N
n : ℕ∞
f : M → N
s : Set M
x : M
Φ : PartialDiffeomorph I J M N n
hx : x ∈ Φ.source
heq : EqOn f (↑Φ.toPartialEquiv) Φ.source
⊢ ContMDiffAt I J n f x
state_after: no goals
tactic: exact ((Φ.contMDiffOn_toFun).congr heq).contMDiffAt (Φ.open_source.mem_nhds hx)
Theorem: Set.inv_singleton
File: Mathlib/Data/Set/Pointwise/Basic.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : InvolutiveInv α
s t : Set α
a✝ a : α
⊢ {a}⁻¹ = {a⁻¹}
state_after: no goals
tactic: rw [← image_inv, image_singleton]
Theorem: Real.Gamma_two
File: Mathlib/Analysis/SpecialFunctions/Gamma/BohrMollerup.lean

Proof steps:
state_before: ⊢ Gamma 2 = 1
state_after: no goals
tactic: simp [Nat.factorial_one]
Theorem: MeasureTheory.integral_add_left_eq_self
File: Mathlib/MeasureTheory/Group/Integral.lean

Proof steps:
state_before: 𝕜 : Type u_1
M : Type u_2
α : Type u_3
G : Type u_4
E : Type u_5
F : Type u_6
inst✝⁷ : MeasurableSpace G
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
μ : Measure G
f✝ : G → E
g✝ : G
inst✝² : Group G
inst✝¹ : MeasurableMul G
inst✝ : μ.IsMulLeftInvariant
f : G → E
g : G
⊢ ∫ (x : G), f (g * x) ∂μ = ∫ (x : G), f x ∂μ
state_after: 𝕜 : Type u_1
M : Type u_2
α : Type u_3
G : Type u_4
E : Type u_5
F : Type u_6
inst✝⁷ : MeasurableSpace G
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
μ : Measure G
f✝ : G → E
g✝ : G
inst✝² : Group G
inst✝¹ : MeasurableMul G
inst✝ : μ.IsMulLeftInvariant
f : G → E
g : G
h_mul : MeasurableEmbedding fun x => g * x
⊢ ∫ (x : G), f (g * x) ∂μ = ∫ (x : G), f x ∂μ
tactic: have h_mul : MeasurableEmbedding fun x => g * x := (MeasurableEquiv.mulLeft g).measurableEmbedding
state_before: 𝕜 : Type u_1
M : Type u_2
α : Type u_3
G : Type u_4
E : Type u_5
F : Type u_6
inst✝⁷ : MeasurableSpace G
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
μ : Measure G
f✝ : G → E
g✝ : G
inst✝² : Group G
inst✝¹ : MeasurableMul G
inst✝ : μ.IsMulLeftInvariant
f : G → E
g : G
h_mul : MeasurableEmbedding fun x => g * x
⊢ ∫ (x : G), f (g * x) ∂μ = ∫ (x : G), f x ∂μ
state_after: no goals
tactic: rw [← h_mul.integral_map, map_mul_left_eq_self]
Theorem: EReal.image_coe_Ioo
File: Mathlib/Data/Real/EReal.lean

Proof steps:
state_before: x y : ℝ
⊢ Real.toEReal '' Ioo x y = Ioo ↑x ↑y
state_after: x y : ℝ
⊢ WithBot.some '' (WithTop.some '' Ioo x y) = Ioo ↑x ↑y
tactic: refine (image_comp WithBot.some WithTop.some _).trans ?_
state_before: x y : ℝ
⊢ WithBot.some '' (WithTop.some '' Ioo x y) = Ioo ↑x ↑y
state_after: x y : ℝ
⊢ Ioo ↑↑x ↑↑y = Ioo ↑x ↑y
tactic: rw [WithTop.image_coe_Ioo, WithBot.image_coe_Ioo]
state_before: x y : ℝ
⊢ Ioo ↑↑x ↑↑y = Ioo ↑x ↑y
state_after: no goals
tactic: rfl
Theorem: SemiconjBy.inv_symm_left_iff₀
File: Mathlib/Algebra/GroupWithZero/Semiconj.lean

Proof steps:
state_before: α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝ : GroupWithZero G₀
a x y x' y' : G₀
ha : a = 0
⊢ SemiconjBy a⁻¹ x y ↔ SemiconjBy a y x
state_after: no goals
tactic: simp only [ha, inv_zero, SemiconjBy.zero_left]