ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CategoryTheory.Limits.Fork.condition
File: Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : C
f g : X ⟶ Y
t : Fork f g
⊢ t.ι ≫ f = t.ι ≫ g
state_after: no goals
tactic: rw [← t.app_one_eq_ι_comp_left, ← t.app_one_eq_ι_comp_right]
Theorem: Matroid.base_restrict_iff'
File: Mathlib/Data/Matroid/Restrict.lean

Proof steps:
state_before: α : Type u_1
M : Matroid α
R I J X Y : Set α
⊢ (M ↾ X).Base I ↔ M.Basis' I X
state_after: no goals
tactic: simp_rw [Basis', base_iff_maximal_indep, mem_maximals_setOf_iff, restrict_indep_iff]
Theorem: PNat.le_find_iff
File: Mathlib/Data/PNat/Find.lean

Proof steps:
state_before: p q : ℕ+ → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
h : ∃ n, p n
n✝ m n : ℕ+
⊢ n ≤ PNat.find h ↔ ∀ m < n, ¬p m
state_after: no goals
tactic: simp only [← not_lt, find_lt_iff, not_exists, not_and]
Theorem: Computation.liftRel_pure
File: Mathlib/Data/Seq/Computation.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
a : α
b : β
⊢ LiftRel R (pure a) (pure b) ↔ R a b
state_after: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
a : α
b : β
⊢ (∃ b_1, b_1 ∈ pure b ∧ R a b_1) ↔ R a b
tactic: rw [liftRel_pure_left]
state_before: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
a : α
b : β
⊢ (∃ b_1, b_1 ∈ pure b ∧ R a b_1) ↔ R a b
state_after: no goals
tactic: exact ⟨fun ⟨b', mb', ab'⟩ => by rwa [eq_of_pure_mem mb'] at ab', fun ab => ⟨_, ret_mem _, ab⟩⟩
Theorem: Set.preimage_boolIndicator
File: Mathlib/Data/Set/BoolIndicator.lean

Proof steps:
state_before: α : Type u_1
s : Set α
t : Set Bool
⊢ s.boolIndicator ⁻¹' t = univ ∨ s.boolIndicator ⁻¹' t = s ∨ s.boolIndicator ⁻¹' t = sᶜ ∨ s.boolIndicator ⁻¹' t = ∅
state_after: α : Type u_1
s : Set α
t : Set Bool
⊢ ((if true ∈ t then s else ∅) ∪ if false ∈ t then sᶜ else ∅) = univ ∨
    ((if true ∈ t then s else ∅) ∪ if false ∈ t then sᶜ else ∅) = s ∨
      ((if true ∈ t then s else ∅) ∪ if false ∈ t then sᶜ else ∅) = sᶜ ∨
        ((if true ∈ t then s else ∅) ∪ if false ∈ t then sᶜ else ∅) = ∅
tactic: simp only [preimage_boolIndicator_eq_union]
state_before: α : Type u_1
s : Set α
t : Set Bool
⊢ ((if true ∈ t then s else ∅) ∪ if false ∈ t then sᶜ else ∅) = univ ∨
    ((if true ∈ t then s else ∅) ∪ if false ∈ t then sᶜ else ∅) = s ∨
      ((if true ∈ t then s else ∅) ∪ if false ∈ t then sᶜ else ∅) = sᶜ ∨
        ((if true ∈ t then s else ∅) ∪ if false ∈ t then sᶜ else ∅) = ∅
state_after: no goals
tactic: split_ifs <;> simp [s.union_compl_self]
Theorem: IsSemisimpleModule.sSup_simples_eq_top
File: Mathlib/RingTheory/SimpleModule.lean

Proof steps:
state_before: ι : Type u_1
R : Type u_2
S : Type u_3
inst✝⁶ : Ring R
inst✝⁵ : Ring S
M : Type u_4
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
m : Submodule R M
N : Type u_5
inst✝² : AddCommGroup N
inst✝¹ : Module R N
inst✝ : IsSemisimpleModule R M
⊢ sSup {m | IsSimpleModule R ↥m} = ⊤
state_after: no goals
tactic: simpa only [isSimpleModule_iff_isAtom] using sSup_atoms_eq_top
Theorem: Hindman.FP.mul
File: Mathlib/Combinatorics/Hindman.lean

Proof steps:
state_before: M : Type u_1
inst✝ : Semigroup M
a : Stream' M
m : M
hm : m ∈ FP a
⊢ ∃ n, ∀ m' ∈ FP (Stream'.drop n a), m * m' ∈ FP a
state_after: case head
M : Type u_1
inst✝ : Semigroup M
a✝ : Stream' M
m : M
a : Stream' M
⊢ ∃ n, ∀ m' ∈ FP (Stream'.drop n a), a.head * m' ∈ FP a

case tail
M : Type u_1
inst✝ : Semigroup M
a✝ : Stream' M
m✝ : M
a : Stream' M
m : M
hm : FP a.tail m
ih : ∃ n, ∀ m' ∈ FP (Stream'.drop n a.tail), m * m' ∈ FP a.tail
⊢ ∃ n, ∀ m' ∈ FP (Stream'.drop n a), m * m' ∈ FP a

case cons
M : Type u_1
inst✝ : Semigroup M
a✝ : Stream' M
m✝ : M
a : Stream' M
m : M
hm : FP a.tail m
ih : ∃ n, ∀ m' ∈ FP (Stream'.drop n a.tail), m * m' ∈ FP a.tail
⊢ ∃ n, ∀ m' ∈ FP (Stream'.drop n a), a.head * m * m' ∈ FP a
tactic: induction' hm with a a m hm ih a m hm ih
Theorem: Submodule.map_id
File: Mathlib/Algebra/Module/Submodule/Map.lean

Proof steps:
state_before: R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
M : Type u_5
M₁ : Type u_6
M₂ : Type u_7
M₃ : Type u_8
inst✝¹² : Semiring R
inst✝¹¹ : Semiring R₂
inst✝¹⁰ : Semiring R₃
inst✝⁹ : AddCommMonoid M
inst✝⁸ : AddCommMonoid M₂
inst✝⁷ : AddCommMonoid M₃
inst✝⁶ : Module R M
inst✝⁵ : Module R₂ M₂
inst✝⁴ : Module R₃ M₃
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
inst✝³ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
p p' : Submodule R M
q q' : Submodule R₂ M₂
x : M
inst✝² : RingHomSurjective σ₁₂
F : Type u_9
inst✝¹ : FunLike F M M₂
inst✝ : SemilinearMapClass F σ₁₂ M M₂
a : M
⊢ a ∈ map LinearMap.id p ↔ a ∈ p
state_after: no goals
tactic: simp
Theorem: Filter.frequently_and_distrib_right
File: Mathlib/Order/Filter/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : Filter α
p : α → Prop
q : Prop
⊢ (∃ᶠ (x : α) in f, p x ∧ q) ↔ (∃ᶠ (x : α) in f, p x) ∧ q
state_after: no goals
tactic: simp only [@and_comm _ q, frequently_and_distrib_left]
Theorem: Function.Antiperiodic.sub
File: Mathlib/Algebra/Periodic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝¹ : AddGroup α
inst✝ : InvolutiveNeg β
h1 : Antiperiodic f c₁
h2 : Antiperiodic f c₂
⊢ Periodic f (c₁ - c₂)
state_after: no goals
tactic: simpa only [sub_eq_add_neg] using h1.add h2.neg
Theorem: CategoryTheory.MonoOver.image_map
File: Mathlib/CategoryTheory/Subobject/MonoOver.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
inst✝ : HasImages C
f g : Over X
k : f ⟶ g
⊢ (fun f => imageMonoOver f.hom) f ⟶ (fun f => imageMonoOver f.hom) g
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : HasImages C
f g : Over X
k : f ⟶ g
⊢ (forget X).obj ((fun f => imageMonoOver f.hom) f) ⟶ (forget X).obj ((fun f => imageMonoOver f.hom) g)
tactic: apply (forget X).preimage _
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : HasImages C
f g : Over X
k : f ⟶ g
⊢ (forget X).obj ((fun f => imageMonoOver f.hom) f) ⟶ (forget X).obj ((fun f => imageMonoOver f.hom) g)
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : HasImages C
f g : Over X
k : f ⟶ g
⊢ ((forget X).obj ((fun f => imageMonoOver f.hom) f)).left ⟶ ((forget X).obj ((fun f => imageMonoOver f.hom) g)).left

C : Type u₁
inst✝² : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : HasImages C
f g : Over X
k : f ⟶ g
⊢ ?m.153502 ≫ ((forget X).obj ((fun f => imageMonoOver f.hom) g)).hom =
    ((forget X).obj ((fun f => imageMonoOver f.hom) f)).hom
tactic: apply Over.homMk _ _
Theorem: Wbtw.swap_left_iff
File: Mathlib/Analysis/Convex/Between.lean

Proof steps:
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁷ : OrderedRing R
inst✝⁶ : AddCommGroup V
inst✝⁵ : Module R V
inst✝⁴ : AddTorsor V P
inst✝³ : AddCommGroup V'
inst✝² : Module R V'
inst✝¹ : AddTorsor V' P'
inst✝ : NoZeroSMulDivisors R V
x y z : P
h : Wbtw R x y z
⊢ Wbtw R y x z ↔ x = y
state_after: no goals
tactic: rw [← wbtw_swap_left_iff R z, and_iff_right h]
Theorem: Function.Commute.iterate_pos_lt_of_map_lt
File: Mathlib/Order/Iterate.lean

Proof steps:
state_before: α : Type u_1
inst✝ : Preorder α
f g : α → α
h : Commute f g
hf : Monotone f
hg : StrictMono g
x : α
hx : f x < g x
n : ℕ
hn : 0 < n
⊢ f^[n] x < g^[n] x
state_after: case h₀
α : Type u_1
inst✝ : Preorder α
f g : α → α
h : Commute f g
hf : Monotone f
hg : StrictMono g
x : α
hx : f x < g x
n : ℕ
hn : 0 < n
⊢ f^[0] x ≤ g^[0] x

case hx
α : Type u_1
inst✝ : Preorder α
f g : α → α
h : Commute f g
hf : Monotone f
hg : StrictMono g
x : α
hx : f x < g x
n : ℕ
hn : 0 < n
⊢ ∀ (k : ℕ), k < n → f^[k + 1] x ≤ f (f^[k] x)

case hy
α : Type u_1
inst✝ : Preorder α
f g : α → α
h : Commute f g
hf : Monotone f
hg : StrictMono g
x : α
hx : f x < g x
n : ℕ
hn : 0 < n
⊢ ∀ (k : ℕ), k < n → f (g^[k] x) < g^[k + 1] x
tactic: apply hf.seq_pos_lt_seq_of_le_of_lt hn
Theorem: Rel.leftDual_mem_rightFixedPoint
File: Mathlib/Order/Rel/GaloisConnection.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
R : Rel α β
J : Set α
⊢ R.leftDual J ∈ R.rightFixedPoints
state_after: case a
α : Type u_1
β : Type u_2
R : Rel α β
J : Set α
⊢ R.leftDual (R.rightDual (R.leftDual J)) ≤ R.leftDual J

case a
α : Type u_1
β : Type u_2
R : Rel α β
J : Set α
⊢ R.leftDual J ≤ R.leftDual (R.rightDual (R.leftDual J))
tactic: apply le_antisymm
Theorem: Finset.prod_antidiagonal_pow_choose_succ
File: Mathlib/Data/Nat/Choose/Sum.lean

Proof steps:
state_before: R✝ : Type u_1
M✝ : Type u_2
R : Type u_3
inst✝² : CommMonoid M✝
inst✝¹ : NonAssocSemiring R
M : Type u_4
inst✝ : CommMonoid M
f : ℕ → ℕ → M
n : ℕ
⊢ ∏ ij ∈ antidiagonal (n + 1), f ij.1 ij.2 ^ (n + 1).choose ij.1 =
    (∏ ij ∈ antidiagonal n, f ij.1 (ij.2 + 1) ^ n.choose ij.1) *
      ∏ ij ∈ antidiagonal n, f (ij.1 + 1) ij.2 ^ n.choose ij.2
state_after: R✝ : Type u_1
M✝ : Type u_2
R : Type u_3
inst✝² : CommMonoid M✝
inst✝¹ : NonAssocSemiring R
M : Type u_4
inst✝ : CommMonoid M
f : ℕ → ℕ → M
n : ℕ
⊢ (∏ i ∈ range (n + 1), f i (n + 1 - i) ^ n.choose i) * ∏ i ∈ range (n + 1), f (i + 1) (n - i) ^ n.choose i =
    (∏ x ∈ range n.succ, f x (n - x + 1) ^ n.choose x) * ∏ x ∈ range n.succ, f (x + 1) (n - x) ^ n.choose (n - x)
tactic: simp only [Nat.prod_antidiagonal_eq_prod_range_succ_mk, prod_pow_choose_succ]
state_before: R✝ : Type u_1
M✝ : Type u_2
R : Type u_3
inst✝² : CommMonoid M✝
inst✝¹ : NonAssocSemiring R
M : Type u_4
inst✝ : CommMonoid M
f : ℕ → ℕ → M
n : ℕ
⊢ (∏ i ∈ range (n + 1), f i (n + 1 - i) ^ n.choose i) * ∏ i ∈ range (n + 1), f (i + 1) (n - i) ^ n.choose i =
    (∏ x ∈ range n.succ, f x (n - x + 1) ^ n.choose x) * ∏ x ∈ range n.succ, f (x + 1) (n - x) ^ n.choose (n - x)
state_after: R✝ : Type u_1
M✝ : Type u_2
R : Type u_3
inst✝² : CommMonoid M✝
inst✝¹ : NonAssocSemiring R
M : Type u_4
inst✝ : CommMonoid M
f : ℕ → ℕ → M
n : ℕ
this : ∀ i ∈ range (n + 1), i ≤ n
⊢ (∏ i ∈ range (n + 1), f i (n + 1 - i) ^ n.choose i) * ∏ i ∈ range (n + 1), f (i + 1) (n - i) ^ n.choose i =
    (∏ x ∈ range n.succ, f x (n - x + 1) ^ n.choose x) * ∏ x ∈ range n.succ, f (x + 1) (n - x) ^ n.choose (n - x)
tactic: have : ∀ i ∈ range (n + 1), i ≤ n := fun i hi ↦ by simpa [Nat.lt_succ_iff] using hi
state_before: R✝ : Type u_1
M✝ : Type u_2
R : Type u_3
inst✝² : CommMonoid M✝
inst✝¹ : NonAssocSemiring R
M : Type u_4
inst✝ : CommMonoid M
f : ℕ → ℕ → M
n : ℕ
this : ∀ i ∈ range (n + 1), i ≤ n
⊢ (∏ i ∈ range (n + 1), f i (n + 1 - i) ^ n.choose i) * ∏ i ∈ range (n + 1), f (i + 1) (n - i) ^ n.choose i =
    (∏ x ∈ range n.succ, f x (n - x + 1) ^ n.choose x) * ∏ x ∈ range n.succ, f (x + 1) (n - x) ^ n.choose (n - x)
state_after: case e_a
R✝ : Type u_1
M✝ : Type u_2
R : Type u_3
inst✝² : CommMonoid M✝
inst✝¹ : NonAssocSemiring R
M : Type u_4
inst✝ : CommMonoid M
f : ℕ → ℕ → M
n : ℕ
this : ∀ i ∈ range (n + 1), i ≤ n
⊢ ∏ i ∈ range (n + 1), f i (n + 1 - i) ^ n.choose i = ∏ x ∈ range n.succ, f x (n - x + 1) ^ n.choose x

case e_a
R✝ : Type u_1
M✝ : Type u_2
R : Type u_3
inst✝² : CommMonoid M✝
inst✝¹ : NonAssocSemiring R
M : Type u_4
inst✝ : CommMonoid M
f : ℕ → ℕ → M
n : ℕ
this : ∀ i ∈ range (n + 1), i ≤ n
⊢ ∏ i ∈ range (n + 1), f (i + 1) (n - i) ^ n.choose i = ∏ x ∈ range n.succ, f (x + 1) (n - x) ^ n.choose (n - x)
tactic: congr 1
Theorem: ExistsContDiffBumpBase.u_compact_support
File: Mathlib/Analysis/Calculus/BumpFunction/FiniteDimension.lean

Proof steps:
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : FiniteDimensional ℝ E
⊢ HasCompactSupport u
state_after: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : FiniteDimensional ℝ E
⊢ IsCompact (closedBall 0 1)
tactic: rw [hasCompactSupport_def, u_support, closure_ball (0 : E) one_ne_zero]
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : FiniteDimensional ℝ E
⊢ IsCompact (closedBall 0 1)
state_after: no goals
tactic: exact isCompact_closedBall _ _
Theorem: Real.log_le_sub_one_of_pos
File: Mathlib/Analysis/SpecialFunctions/Log/Basic.lean

Proof steps:
state_before: x✝ y x : ℝ
hx : 0 < x
⊢ log x ≤ x - 1
state_after: x✝ y x : ℝ
hx : 0 < x
⊢ log x + 1 ≤ x
tactic: rw [le_sub_iff_add_le]
state_before: x✝ y x : ℝ
hx : 0 < x
⊢ log x + 1 ≤ x
state_after: case h.e'_4
x✝ y x : ℝ
hx : 0 < x
⊢ x = rexp (log x)
tactic: convert add_one_le_exp (log x)
state_before: case h.e'_4
x✝ y x : ℝ
hx : 0 < x
⊢ x = rexp (log x)
state_after: no goals
tactic: rw [exp_log hx]
Theorem: Convex.smul_mem_of_zero_mem
File: Mathlib/Analysis/Convex/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
β : Type u_4
inst✝⁴ : OrderedRing 𝕜
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s t✝ : Set E
hs : Convex 𝕜 s
x : E
zero_mem : 0 ∈ s
hx : x ∈ s
t : 𝕜
ht : t ∈ Icc 0 1
⊢ t • x ∈ s
state_after: no goals
tactic: simpa using hs.add_smul_mem zero_mem (by simpa using hx) ht
Theorem: Real.cos_sq
File: Mathlib/Data/Complex/Exponential.lean

Proof steps:
state_before: x y : ℝ
⊢ ↑(cos x ^ 2) = ↑(1 / 2 + cos (2 * x) / 2)
state_after: no goals
tactic: simp [cos_sq]
Theorem: MeasureTheory.Measure.toENNRealVectorMeasure_apply
File: Mathlib/MeasureTheory/Measure/VectorMeasure.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ : Measure α
⊢ (fun i => if MeasurableSet i then μ i else 0) ∅ = 0
state_after: no goals
tactic: simp [μ.empty]
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ : Measure α
x✝ : ℕ → Set α
hf₁ : ∀ (i : ℕ), MeasurableSet (x✝ i)
hf₂ : Pairwise (Disjoint on x✝)
⊢ HasSum (fun i => (fun i => if MeasurableSet i then μ i else 0) (x✝ i))
    ((fun i => if MeasurableSet i then μ i else 0) (⋃ i, x✝ i))
state_after: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ : Measure α
x✝ : ℕ → Set α
hf₁ : ∀ (i : ℕ), MeasurableSet (x✝ i)
hf₂ : Pairwise (Disjoint on x✝)
⊢ HasSum (fun i => if MeasurableSet (x✝ i) then μ (x✝ i) else 0)
    (if MeasurableSet (⋃ i, x✝ i) then μ (⋃ i, x✝ i) else 0)
tactic: simp only
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ : Measure α
x✝ : ℕ → Set α
hf₁ : ∀ (i : ℕ), MeasurableSet (x✝ i)
hf₂ : Pairwise (Disjoint on x✝)
⊢ HasSum (fun i => if MeasurableSet (x✝ i) then μ (x✝ i) else 0)
    (if MeasurableSet (⋃ i, x✝ i) then μ (⋃ i, x✝ i) else 0)
state_after: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ : Measure α
x✝ : ℕ → Set α
hf₁ : ∀ (i : ℕ), MeasurableSet (x✝ i)
hf₂ : Pairwise (Disjoint on x✝)
⊢ (∑' (b : ℕ), if MeasurableSet (x✝ b) then μ (x✝ b) else 0) = ∑' (i : ℕ), μ (x✝ i)
tactic: rw [Summable.hasSum_iff ENNReal.summable, if_pos (MeasurableSet.iUnion hf₁),
      MeasureTheory.measure_iUnion hf₂ hf₁]
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ : Measure α
x✝ : ℕ → Set α
hf₁ : ∀ (i : ℕ), MeasurableSet (x✝ i)
hf₂ : Pairwise (Disjoint on x✝)
⊢ (∑' (b : ℕ), if MeasurableSet (x✝ b) then μ (x✝ b) else 0) = ∑' (i : ℕ), μ (x✝ i)
state_after: no goals
tactic: exact tsum_congr fun n => if_pos (hf₁ n)
Theorem: Complex.continuous_normSq
File: Mathlib/Analysis/Complex/Basic.lean

Proof steps:
state_before: z : ℂ
E : Type u_1
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℂ E
⊢ Continuous ⇑normSq
state_after: no goals
tactic: simpa [← normSq_eq_abs] using continuous_abs.pow 2
Theorem: AlgebraicGeometry.Scheme.restrictFunctor_map_left
File: Mathlib/AlgebraicGeometry/Restrict.lean

Proof steps:
state_before: C : Type u₁
inst✝ : Category.{v, u₁} C
X : Scheme
U✝ U V : X.Opens
i : U ⟶ V
⊢ Set.range ⇑U.ι.val.base ⊆ Set.range ⇑V.ι.val.base
state_after: no goals
tactic: simpa using i.le
Theorem: Surreal.Multiplication.mulOption_lt_iff_P1
File: Mathlib/SetTheory/Surreal/Multiplication.lean

Proof steps:
state_before: x x₁ x₂ x₃ x' y y₁ y₂ y₃ y' : PGame
i j : x.LeftMoves
k : y.LeftMoves
l : (-y).LeftMoves
⊢ ⟦x.mulOption y i k⟧ < -⟦x.mulOption (-y) j l⟧ ↔ P1 (x.moveLeft i) x (x.moveLeft j) y (y.moveLeft k) (-(-y).moveLeft l)
state_after: x x₁ x₂ x₃ x' y y₁ y₂ y₃ y' : PGame
i j : x.LeftMoves
k : y.LeftMoves
l : (-y).LeftMoves
⊢ ⟦x.moveLeft i * y⟧ + ⟦x * y.moveLeft k⟧ - ⟦x.moveLeft i * y.moveLeft k⟧ <
      -(⟦x.moveLeft j * -y⟧ + ⟦x * (-y).moveLeft l⟧ - ⟦x.moveLeft j * (-y).moveLeft l⟧) ↔
    ⟦x.moveLeft i * y⟧ + ⟦x * y.moveLeft k⟧ - ⟦x.moveLeft i * y.moveLeft k⟧ <
      ⟦x.moveLeft j * y⟧ + ⟦x * -(-y).moveLeft l⟧ - ⟦x.moveLeft j * -(-y).moveLeft l⟧
tactic: dsimp only [P1, mulOption, quot_sub, quot_add]
state_before: x x₁ x₂ x₃ x' y y₁ y₂ y₃ y' : PGame
i j : x.LeftMoves
k : y.LeftMoves
l : (-y).LeftMoves
⊢ ⟦x.moveLeft i * y⟧ + ⟦x * y.moveLeft k⟧ - ⟦x.moveLeft i * y.moveLeft k⟧ <
      -(⟦x.moveLeft j * -y⟧ + ⟦x * (-y).moveLeft l⟧ - ⟦x.moveLeft j * (-y).moveLeft l⟧) ↔
    ⟦x.moveLeft i * y⟧ + ⟦x * y.moveLeft k⟧ - ⟦x.moveLeft i * y.moveLeft k⟧ <
      ⟦x.moveLeft j * y⟧ + ⟦x * -(-y).moveLeft l⟧ - ⟦x.moveLeft j * -(-y).moveLeft l⟧
state_after: no goals
tactic: simp_rw [neg_sub', neg_add, quot_mul_neg, neg_neg]
Theorem: MeasureTheory.eventually_mul_left_iff
File: Mathlib/MeasureTheory/Group/Measure.lean

Proof steps:
state_before: 𝕜 : Type u_1
G : Type u_2
H : Type u_3
inst✝⁴ : MeasurableSpace G
inst✝³ : MeasurableSpace H
inst✝² : Group G
inst✝¹ : MeasurableMul G
μ : Measure G
inst✝ : μ.IsMulLeftInvariant
t : G
p : G → Prop
⊢ (∀ᵐ (x : G) ∂μ, p (t * x)) ↔ ∀ᵐ (x : G) ∂μ, p x
state_after: 𝕜 : Type u_1
G : Type u_2
H : Type u_3
inst✝⁴ : MeasurableSpace G
inst✝³ : MeasurableSpace H
inst✝² : Group G
inst✝¹ : MeasurableMul G
μ : Measure G
inst✝ : μ.IsMulLeftInvariant
t : G
p : G → Prop
⊢ (∀ᵐ (x : G) ∂μ, p (t * x)) ↔ {x | p x} ∈ Filter.map (fun h => t * h) (ae μ)
tactic: conv_rhs => rw [Filter.Eventually, ← map_mul_left_ae μ t]
state_before: 𝕜 : Type u_1
G : Type u_2
H : Type u_3
inst✝⁴ : MeasurableSpace G
inst✝³ : MeasurableSpace H
inst✝² : Group G
inst✝¹ : MeasurableMul G
μ : Measure G
inst✝ : μ.IsMulLeftInvariant
t : G
p : G → Prop
⊢ (∀ᵐ (x : G) ∂μ, p (t * x)) ↔ {x | p x} ∈ Filter.map (fun h => t * h) (ae μ)
state_after: no goals
tactic: rfl
Theorem: ZMod.val_cast_eq_val_of_lt
File: Mathlib/Data/ZMod/Basic.lean

Proof steps:
state_before: m✝ n✝ m n : ℕ
nzm : NeZero m
a : ZMod m
h : a.val < n
⊢ a.cast.val = a.val
state_after: m✝ n✝ m n : ℕ
nzm : NeZero m
a : ZMod m
h : a.val < n
nzn : NeZero n
⊢ a.cast.val = a.val
tactic: have nzn : NeZero n := by constructor; rintro rfl; simp at h
state_before: m✝ n✝ m n : ℕ
nzm : NeZero m
a : ZMod m
h : a.val < n
nzn : NeZero n
⊢ a.cast.val = a.val
state_after: no goals
tactic: cases m with
  | zero => cases nzm; simp_all
  | succ m =>
    cases n with
    | zero => cases nzn; simp_all
    | succ n => exact Fin.val_cast_of_lt h
Theorem: CommRingCat.Colimits.cocone_naturality_components
File: Mathlib/Algebra/Category/Ring/Colimits.lean

Proof steps:
state_before: J : Type v
inst✝ : SmallCategory J
F : J ⥤ CommRingCat
j j' : J
f : j ⟶ j'
x : ↑(F.obj j)
⊢ (coconeMorphism F j') ((F.map f) x) = (coconeMorphism F j) x
state_after: no goals
tactic: rw [← cocone_naturality F f, comp_apply]
Theorem: inv_gold
File: Mathlib/Data/Real/GoldenRatio.lean

Proof steps:
state_before: ⊢ φ⁻¹ = -ψ
state_after: this : 1 + √5 ≠ 0
⊢ φ⁻¹ = -ψ
tactic: have : 1 + √5 ≠ 0 := ne_of_gt (add_pos (by norm_num) <| Real.sqrt_pos.mpr (by norm_num))
state_before: this : 1 + √5 ≠ 0
⊢ φ⁻¹ = -ψ
state_after: this : 1 + √5 ≠ 0
⊢ 2 * 2 = 5 - 1
tactic: field_simp [sub_mul, mul_add]
state_before: this : 1 + √5 ≠ 0
⊢ 2 * 2 = 5 - 1
state_after: no goals
tactic: norm_num
Theorem: IsAddUnit.nsmul
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 : M
n : ℕ
⊢ IsUnit a → IsUnit (a ^ n)
state_after: case intro
α : Type u
M : Type u_1
N : Type u_2
inst✝ : Monoid M
b : M
n : ℕ
u : Mˣ
⊢ IsUnit (↑u ^ n)
tactic: rintro ⟨u, rfl⟩
state_before: case intro
α : Type u
M : Type u_1
N : Type u_2
inst✝ : Monoid M
b : M
n : ℕ
u : Mˣ
⊢ IsUnit (↑u ^ n)
state_after: no goals
tactic: exact ⟨u ^ n, rfl⟩
Theorem: Set.subset_range_enumerate
File: Mathlib/Data/Set/Countable.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
s : Set α
h : s.Countable
default x : α
hx : x ∈ s
⊢ enumerateCountable h default (encode ⟨x, hx⟩) = x
state_after: α : Type u
β : Type v
γ : Type w
ι : Sort x
s : Set α
h : s.Countable
default x : α
hx : x ∈ s
this : Encodable ↑s := h.toEncodable
⊢ enumerateCountable h default (encode ⟨x, hx⟩) = x
tactic: letI := h.toEncodable
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
s : Set α
h : s.Countable
default x : α
hx : x ∈ s
this : Encodable ↑s := h.toEncodable
⊢ enumerateCountable h default (encode ⟨x, hx⟩) = x
state_after: no goals
tactic: simp [enumerateCountable, Encodable.encodek]
Theorem: AddConstMapClass.map_add_nat'
File: Mathlib/Algebra/AddConstMap/Basic.lean

Proof steps:
state_before: F : Type u_1
G : Type u_2
H : Type u_3
inst✝³ : FunLike F G H
a : G
b : H
inst✝² : AddMonoidWithOne G
inst✝¹ : AddMonoid H
inst✝ : AddConstMapClass F G H 1 b
f : F
x : G
n : ℕ
⊢ f (x + ↑n) = f x + n • b
state_after: no goals
tactic: simp [← map_add_nsmul]
Theorem: CategoryTheory.CategoryOfElements.from_toCostructuredArrow_eq
File: Mathlib/CategoryTheory/Elements.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
F✝ : C ⥤ Type w
F : Cᵒᵖ ⥤ Type v
⊢ (toCostructuredArrow F).rightOp ⋙ fromCostructuredArrow F = 𝟭 F.Elements
state_after: case refine_1
C : Type u
inst✝ : Category.{v, u} C
F✝ : C ⥤ Type w
F : Cᵒᵖ ⥤ Type v
⊢ ∀ (X : F.Elements), ((toCostructuredArrow F).rightOp ⋙ fromCostructuredArrow F).obj X = (𝟭 F.Elements).obj X

case refine_2
C : Type u
inst✝ : Category.{v, u} C
F✝ : C ⥤ Type w
F : Cᵒᵖ ⥤ Type v
⊢ ∀ (X Y : F.Elements) (f : X ⟶ Y),
    ((toCostructuredArrow F).rightOp ⋙ fromCostructuredArrow F).map f = eqToHom ⋯ ≫ (𝟭 F.Elements).map f ≫ eqToHom ⋯
tactic: refine Functor.ext ?_ ?_
Theorem: CategoryTheory.Limits.kernelSubobject_arrow'
File: Mathlib/CategoryTheory/Subobject/Limits.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
X Y Z : C
inst✝¹ : HasZeroMorphisms C
f : X ⟶ Y
inst✝ : HasKernel f
⊢ (kernelSubobjectIso f).inv ≫ (kernelSubobject f).arrow = kernel.ι f
state_after: no goals
tactic: simp [kernelSubobjectIso]
Theorem: two_mul_card_alternatingGroup
File: Mathlib/GroupTheory/SpecificGroups/Alternating.lean

Proof steps:
state_before: α : Type u_1
inst✝² : Fintype α
inst✝¹ : DecidableEq α
inst✝ : Nontrivial α
⊢ 2 * card ↥(alternatingGroup α) = card (Perm α)
state_after: α : Type u_1
inst✝² : Fintype α
inst✝¹ : DecidableEq α
inst✝ : Nontrivial α
this : Perm α ⧸ sign.ker ≃ ℤˣ := (QuotientGroup.quotientKerEquivOfSurjective sign ⋯).toEquiv
⊢ 2 * card ↥(alternatingGroup α) = card (Perm α)
tactic: let this := (QuotientGroup.quotientKerEquivOfSurjective _ (sign_surjective α)).toEquiv
state_before: α : Type u_1
inst✝² : Fintype α
inst✝¹ : DecidableEq α
inst✝ : Nontrivial α
this : Perm α ⧸ sign.ker ≃ ℤˣ := (QuotientGroup.quotientKerEquivOfSurjective sign ⋯).toEquiv
⊢ 2 * card ↥(alternatingGroup α) = card (Perm α)
state_after: α : Type u_1
inst✝² : Fintype α
inst✝¹ : DecidableEq α
inst✝ : Nontrivial α
this : Perm α ⧸ sign.ker ≃ ℤˣ := (QuotientGroup.quotientKerEquivOfSurjective sign ⋯).toEquiv
⊢ card (Perm α ⧸ sign.ker) * card ↥(alternatingGroup α) = card (Perm α)
tactic: rw [← Fintype.card_units_int, ← Fintype.card_congr this]
state_before: α : Type u_1
inst✝² : Fintype α
inst✝¹ : DecidableEq α
inst✝ : Nontrivial α
this : Perm α ⧸ sign.ker ≃ ℤˣ := (QuotientGroup.quotientKerEquivOfSurjective sign ⋯).toEquiv
⊢ card (Perm α ⧸ sign.ker) * card ↥(alternatingGroup α) = card (Perm α)
state_after: α : Type u_1
inst✝² : Fintype α
inst✝¹ : DecidableEq α
inst✝ : Nontrivial α
this : Perm α ⧸ sign.ker ≃ ℤˣ := (QuotientGroup.quotientKerEquivOfSurjective sign ⋯).toEquiv
⊢ Nat.card (Perm α ⧸ sign.ker) * Nat.card ↥(alternatingGroup α) = Nat.card (Perm α)
tactic: simp only [← Nat.card_eq_fintype_card]
state_before: α : Type u_1
inst✝² : Fintype α
inst✝¹ : DecidableEq α
inst✝ : Nontrivial α
this : Perm α ⧸ sign.ker ≃ ℤˣ := (QuotientGroup.quotientKerEquivOfSurjective sign ⋯).toEquiv
⊢ Nat.card (Perm α ⧸ sign.ker) * Nat.card ↥(alternatingGroup α) = Nat.card (Perm α)
state_after: no goals
tactic: apply (Subgroup.card_eq_card_quotient_mul_card_subgroup _).symm