ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CategoryTheory.Idempotents.KaroubiFunctorCategoryEmbedding.obj_map_f
File: Mathlib/CategoryTheory/Idempotents/FunctorCategories.lean

Proof steps:
state_before: J : Type u_1
C : Type u_2
inst✝¹ : Category.{?u.43805, u_1} J
inst✝ : Category.{?u.43809, u_2} C
P✝ Q : Karoubi (J ⥤ C)
f : P✝ ⟶ Q
X : J
P : Karoubi (J ⥤ C)
j j' : J
φ : j ⟶ j'
⊢ P.p.app j ≫ P.X.map φ =
    ((fun j => { X := P.X.obj j, p := P.p.app j, idem := ⋯ }) j).p ≫
      (P.p.app j ≫ P.X.map φ) ≫ ((fun j => { X := P.X.obj j, p := P.p.app j, idem := ⋯ }) j').p
state_after: J : Type u_1
C : Type u_2
inst✝¹ : Category.{?u.43805, u_1} J
inst✝ : Category.{?u.43809, u_2} C
P✝ Q : Karoubi (J ⥤ C)
f : P✝ ⟶ Q
X : J
P : Karoubi (J ⥤ C)
j j' : J
φ : j ⟶ j'
⊢ P.p.app j ≫ P.X.map φ = P.p.app j ≫ P.p.app j ≫ P.p.app j ≫ P.X.map φ
tactic: simp only [NatTrans.naturality, assoc]
state_before: J : Type u_1
C : Type u_2
inst✝¹ : Category.{?u.43805, u_1} J
inst✝ : Category.{?u.43809, u_2} C
P✝ Q : Karoubi (J ⥤ C)
f : P✝ ⟶ Q
X : J
P : Karoubi (J ⥤ C)
j j' : J
φ : j ⟶ j'
⊢ P.p.app j ≫ P.X.map φ = P.p.app j ≫ P.p.app j ≫ P.p.app j ≫ P.X.map φ
state_after: J : Type u_1
C : Type u_2
inst✝¹ : Category.{?u.43805, u_1} J
inst✝ : Category.{?u.43809, u_2} C
P✝ Q : Karoubi (J ⥤ C)
f : P✝ ⟶ Q
X : J
P : Karoubi (J ⥤ C)
j j' : J
φ : j ⟶ j'
h : (P.p ≫ P.p).app j = P.p.app j
⊢ P.p.app j ≫ P.X.map φ = P.p.app j ≫ P.p.app j ≫ P.p.app j ≫ P.X.map φ
tactic: have h := congr_app P.idem j
state_before: J : Type u_1
C : Type u_2
inst✝¹ : Category.{?u.43805, u_1} J
inst✝ : Category.{?u.43809, u_2} C
P✝ Q : Karoubi (J ⥤ C)
f : P✝ ⟶ Q
X : J
P : Karoubi (J ⥤ C)
j j' : J
φ : j ⟶ j'
h : (P.p ≫ P.p).app j = P.p.app j
⊢ P.p.app j ≫ P.X.map φ = P.p.app j ≫ P.p.app j ≫ P.p.app j ≫ P.X.map φ
state_after: J : Type u_1
C : Type u_2
inst✝¹ : Category.{?u.43805, u_1} J
inst✝ : Category.{?u.43809, u_2} C
P✝ Q : Karoubi (J ⥤ C)
f : P✝ ⟶ Q
X : J
P : Karoubi (J ⥤ C)
j j' : J
φ : j ⟶ j'
h : P.p.app j ≫ P.p.app j = P.p.app j
⊢ P.p.app j ≫ P.X.map φ = P.p.app j ≫ P.p.app j ≫ P.p.app j ≫ P.X.map φ
tactic: rw [NatTrans.comp_app] at h
state_before: J : Type u_1
C : Type u_2
inst✝¹ : Category.{?u.43805, u_1} J
inst✝ : Category.{?u.43809, u_2} C
P✝ Q : Karoubi (J ⥤ C)
f : P✝ ⟶ Q
X : J
P : Karoubi (J ⥤ C)
j j' : J
φ : j ⟶ j'
h : P.p.app j ≫ P.p.app j = P.p.app j
⊢ P.p.app j ≫ P.X.map φ = P.p.app j ≫ P.p.app j ≫ P.p.app j ≫ P.X.map φ
state_after: no goals
tactic: erw [reassoc_of% h, reassoc_of% h]
Theorem: NNReal.rpow_inv_le_iff
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

Proof steps:
state_before: w x✝ y✝ z✝ : ℝ
x y : ℝ≥0
z : ℝ
hz : 0 < z
⊢ x ^ z⁻¹ ≤ y ↔ x ≤ y ^ z
state_after: no goals
tactic: rw [← rpow_le_rpow_iff hz, ← one_div, rpow_self_rpow_inv hz.ne']
Theorem: Complex.cos_pi_div_two
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

Proof steps:
state_before: ⊢ cos (↑π / 2) = ↑(Real.cos (π / 2))
state_after: ⊢ cos (↑π / 2) = cos ↑(π / 2)
tactic: rw [ofReal_cos]
state_before: ⊢ cos (↑π / 2) = cos ↑(π / 2)
state_after: no goals
tactic: simp
state_before: ⊢ ↑(Real.cos (π / 2)) = 0
state_after: no goals
tactic: simp
Theorem: rightCoset_mem_rightCoset
File: Mathlib/GroupTheory/Coset.lean

Proof steps:
state_before: α : Type u_1
inst✝ : Group α
s : Subgroup α
a : α
ha : a ∈ s
b : α
⊢ b ∈ op a • ↑s ↔ b ∈ ↑s
state_after: no goals
tactic: simp [mem_rightCoset_iff, mul_mem_cancel_right (s.inv_mem ha)]
Theorem: Associates.FactorSet.coe_add
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

Proof steps:
state_before: α : Type u_1
inst✝ : CancelCommMonoidWithZero α
a b : Multiset { a // Irreducible a }
⊢ ↑(a + b) = ↑a + ↑b
state_after: no goals
tactic: norm_cast
Theorem: norm_multiset_prod_le
File: Mathlib/Analysis/Normed/Group/Basic.lean

Proof steps:
state_before: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
m : Multiset E
⊢ ‖m.prod‖ ≤ (Multiset.map (fun x => ‖x‖) m).sum
state_after: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
m : Multiset E
⊢ Multiplicative.ofAdd ‖m.prod‖ ≤ (Multiset.map (⇑Multiplicative.ofAdd ∘ fun x => ‖x‖) m).prod
tactic: rw [← Multiplicative.ofAdd_le, ofAdd_multiset_prod, Multiset.map_map]
state_before: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
m : Multiset E
⊢ Multiplicative.ofAdd ‖m.prod‖ ≤ (Multiset.map (⇑Multiplicative.ofAdd ∘ fun x => ‖x‖) m).prod
state_after: case refine_1
𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
m : Multiset E
⊢ (⇑Multiplicative.ofAdd ∘ norm) 1 = 1

case refine_2
𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
m : Multiset E
x y : E
⊢ (⇑Multiplicative.ofAdd ∘ norm) (x * y) ≤ (⇑Multiplicative.ofAdd ∘ norm) x * (⇑Multiplicative.ofAdd ∘ norm) y
tactic: refine Multiset.le_prod_of_submultiplicative (Multiplicative.ofAdd ∘ norm) ?_ (fun x y => ?_) _
Theorem: UniformFun.uniformContinuous_toFun
File: Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
⊢ UniformContinuous ⇑toFun
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
⊢ ∀ (i : α), UniformContinuous fun x => toFun x i
tactic: rw [uniformContinuous_pi]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
⊢ ∀ (i : α), UniformContinuous fun x => toFun x i
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
s s' : Set α
x✝ : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
x : α
⊢ UniformContinuous fun x_1 => toFun x_1 x
tactic: intro x
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
s s' : Set α
x✝ : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
x : α
⊢ UniformContinuous fun x_1 => toFun x_1 x
state_after: no goals
tactic: exact uniformContinuous_eval β x
Theorem: AddEquiv.comp_right_injective
File: Mathlib/Algebra/Group/Equiv/Basic.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
A : Type u_4
B : Type u_5
M : Type u_6
N : Type u_7
P : Type u_8
Q : Type u_9
G : Type u_10
H : Type u_11
inst✝³ : EquivLike F α β
inst✝² : MulOneClass M
inst✝¹ : MulOneClass N
inst✝ : MulOneClass P
e : M ≃* N
f : P →* M
⊢ (↑e.symm).comp ((↑e).comp f) = f
state_after: no goals
tactic: simp [← MonoidHom.comp_assoc]
Theorem: Mathlib.Tactic.Ring.add_pf_add_zero
File: Mathlib/Tactic/Ring/Basic.lean

Proof steps:
state_before: u✝ : Lean.Level
arg : Q(Type u✝)
sα✝ : Q(CommSemiring «$arg»)
u : Lean.Level
α : Q(Type u)
sα : Q(CommSemiring «$α»)
R : Type u_1
inst✝ : CommSemiring R
a✝ a' a₁ a₂ a₃ b b' b₁ b₂ b₃ c c₁ c₂ a : R
⊢ a + 0 = a
state_after: no goals
tactic: simp
Theorem: Polynomial.degree_C_mul
File: Mathlib/Algebra/Polynomial/Degree/Lemmas.lean

Proof steps:
state_before: R : Type u
S : Type v
ι : Type w
a✝ b : R
m n : ℕ
inst✝¹ : Semiring R
inst✝ : NoZeroDivisors R
p q : R[X]
a : R
a0 : a ≠ 0
⊢ (C a * p).degree = p.degree
state_after: no goals
tactic: rw [degree_mul, degree_C a0, zero_add]
Theorem: SetTheory.PGame.insertRight_numeric
File: Mathlib/SetTheory/Surreal/Basic.lean

Proof steps:
state_before: x x' : PGame
x_num : x.Numeric
x'_num : x'.Numeric
h : x ≤ x'
⊢ (x.insertRight x').Numeric
state_after: x x' : PGame
x_num : x.Numeric
x'_num : x'.Numeric
h : x ≤ x'
⊢ (-(-x).insertLeft (-x')).Numeric
tactic: rw [← neg_neg (x.insertRight x'), ← neg_insertLeft_neg]
state_before: x x' : PGame
x_num : x.Numeric
x'_num : x'.Numeric
h : x ≤ x'
⊢ (-(-x).insertLeft (-x')).Numeric
state_after: case x
x x' : PGame
x_num : x.Numeric
x'_num : x'.Numeric
h : x ≤ x'
⊢ ((-x).insertLeft (-x')).Numeric
tactic: apply Numeric.neg
state_before: case x
x x' : PGame
x_num : x.Numeric
x'_num : x'.Numeric
h : x ≤ x'
⊢ ((-x).insertLeft (-x')).Numeric
state_after: no goals
tactic: exact insertLeft_numeric (Numeric.neg x_num) (Numeric.neg x'_num) (neg_le_neg_iff.mpr h)
Theorem: List.mem_mem_ranges_iff_lt_sum
File: Mathlib/Algebra/BigOperators/Group/List.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
l : List ℕ
n : ℕ
⊢ (∃ s ∈ l.ranges, n ∈ s) ↔ n < l.sum
state_after: no goals
tactic: simp [mem_mem_ranges_iff_lt_natSum]
Theorem: Submodule.isOrtho_sSup_right
File: Mathlib/Analysis/InnerProductSpace/Orthogonal.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
U : Submodule 𝕜 E
V : Set (Submodule 𝕜 E)
⊢ (∀ Uᵢ ∈ V, Uᵢ ⟂ U) ↔ ∀ Vᵢ ∈ V, U ⟂ Vᵢ
state_after: no goals
tactic: simp_rw [isOrtho_comm]
Theorem: IsOrderConnected.neg_trans
File: Mathlib/Order/RelClasses.lean

Proof steps:
state_before: α : Type u
β : Type v
r✝ : α → α → Prop
s : β → β → Prop
r : α → α → Prop
inst✝ : IsOrderConnected α r
a b c : α
h₁ : ¬r a b
h₂ : ¬r b c
⊢ ¬(r a b ∨ r b c)
state_after: no goals
tactic: simp [h₁, h₂]
Theorem: DirichletCharacter.changeLevel_self_toUnitHom
File: Mathlib/NumberTheory/DirichletCharacter/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝ : CommMonoidWithZero R
n : ℕ
χ : DirichletCharacter R n
⊢ toUnitHom ((changeLevel ⋯) χ) = toUnitHom χ
state_after: no goals
tactic: rw [changeLevel_self]
Theorem: WellFounded.wellFounded_iff_has_min
File: Mathlib/Order/WellFounded.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r✝ r' r : α → α → Prop
⊢ WellFounded r ↔ ∀ (s : Set α), s.Nonempty → ∃ m ∈ s, ∀ x ∈ s, ¬r x m
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
r✝ r' r : α → α → Prop
h : ∀ (s : Set α), s.Nonempty → ∃ m ∈ s, ∀ x ∈ s, ¬r x m
x : α
⊢ Acc r x
tactic: refine ⟨fun h => h.has_min, fun h => ⟨fun x => ?_⟩⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r✝ r' r : α → α → Prop
h : ∀ (s : Set α), s.Nonempty → ∃ m ∈ s, ∀ x ∈ s, ¬r x m
x : α
⊢ Acc r x
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
r✝ r' r : α → α → Prop
h : ∀ (s : Set α), s.Nonempty → ∃ m ∈ s, ∀ x ∈ s, ¬r x m
x : α
hx : ¬Acc r x
⊢ False
tactic: by_contra hx
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r✝ r' r : α → α → Prop
h : ∀ (s : Set α), s.Nonempty → ∃ m ∈ s, ∀ x ∈ s, ¬r x m
x : α
hx : ¬Acc r x
⊢ False
state_after: case intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
r✝ r' r : α → α → Prop
h : ∀ (s : Set α), s.Nonempty → ∃ m ∈ s, ∀ x ∈ s, ¬r x m
x : α
hx : ¬Acc r x
m : α
hm : m ∈ {x | ¬Acc r x}
hm' : ∀ x ∈ {x | ¬Acc r x}, ¬r x m
⊢ False
tactic: obtain ⟨m, hm, hm'⟩ := h {x | ¬Acc r x} ⟨x, hx⟩
state_before: case intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
r✝ r' r : α → α → Prop
h : ∀ (s : Set α), s.Nonempty → ∃ m ∈ s, ∀ x ∈ s, ¬r x m
x : α
hx : ¬Acc r x
m : α
hm : m ∈ {x | ¬Acc r x}
hm' : ∀ x ∈ {x | ¬Acc r x}, ¬r x m
⊢ False
state_after: case intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
r✝ r' r : α → α → Prop
h : ∀ (s : Set α), s.Nonempty → ∃ m ∈ s, ∀ x ∈ s, ¬r x m
x : α
hx : ¬Acc r x
m : α
hm : m ∈ {x | ¬Acc r x}
hm' : ∀ x ∈ {x | ¬Acc r x}, ¬r x m
y : α
hy : r y m
⊢ Acc r y
tactic: refine hm ⟨_, fun y hy => ?_⟩
state_before: case intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
r✝ r' r : α → α → Prop
h : ∀ (s : Set α), s.Nonempty → ∃ m ∈ s, ∀ x ∈ s, ¬r x m
x : α
hx : ¬Acc r x
m : α
hm : m ∈ {x | ¬Acc r x}
hm' : ∀ x ∈ {x | ¬Acc r x}, ¬r x m
y : α
hy : r y m
⊢ Acc r y
state_after: case intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
r✝ r' r : α → α → Prop
h : ∀ (s : Set α), s.Nonempty → ∃ m ∈ s, ∀ x ∈ s, ¬r x m
x : α
hx : ¬Acc r x
m : α
hm : m ∈ {x | ¬Acc r x}
hm' : ∀ x ∈ {x | ¬Acc r x}, ¬r x m
y : α
hy : r y m
hy' : ¬Acc r y
⊢ False
tactic: by_contra hy'
state_before: case intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
r✝ r' r : α → α → Prop
h : ∀ (s : Set α), s.Nonempty → ∃ m ∈ s, ∀ x ∈ s, ¬r x m
x : α
hx : ¬Acc r x
m : α
hm : m ∈ {x | ¬Acc r x}
hm' : ∀ x ∈ {x | ¬Acc r x}, ¬r x m
y : α
hy : r y m
hy' : ¬Acc r y
⊢ False
state_after: no goals
tactic: exact hm' y hy' hy
Theorem: Nat.evenOddRec_even
File: Mathlib/Data/Nat/EvenOddRec.lean

Proof steps:
state_before: P : ℕ → Sort u_1
h0 : P 0
h_even : (i : ℕ) → P i → P (2 * i)
h_odd : (i : ℕ) → P i → P (2 * i + 1)
H : h_even 0 h0 = h0
n : ℕ
⊢ evenOddRec h0 h_even h_odd (2 * n) = h_even n (evenOddRec h0 h_even h_odd n)
state_after: P : ℕ → Sort u_1
h0 : P 0
h_even : (i : ℕ) → P i → P (2 * i)
h_odd : (i : ℕ) → P i → P (2 * i + 1)
H : h_even 0 h0 = h0
n : ℕ
⊢ (match false, 0, h0 with
      | false, i, hi => h_even i hi
      | true, i, hi => h_odd i hi) =
      h0 ∨
    (n = 0 → false = true)
tactic: apply binaryRec_eq' false n
state_before: P : ℕ → Sort u_1
h0 : P 0
h_even : (i : ℕ) → P i → P (2 * i)
h_odd : (i : ℕ) → P i → P (2 * i + 1)
H : h_even 0 h0 = h0
n : ℕ
⊢ (match false, 0, h0 with
      | false, i, hi => h_even i hi
      | true, i, hi => h_odd i hi) =
      h0 ∨
    (n = 0 → false = true)
state_after: no goals
tactic: simp [H]
Theorem: WeierstrassCurve.coeff_Φ
File: Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Degree.lean

Proof steps:
state_before: R : Type u
inst✝ : CommRing R
W : WeierstrassCurve R
n : ℤ
⊢ (W.Φ n).coeff (n.natAbs ^ 2) = 1
state_after: no goals
tactic: induction n using Int.negInduction with
  | nat n => exact (W.natDegree_coeff_Φ_ofNat n).right
  | neg => rwa [Φ_neg, Int.natAbs_neg]
Theorem: Subgroup.mem_iInf
File: Mathlib/Algebra/Group/Subgroup/Basic.lean

Proof steps:
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝³ : Group G
inst✝² : Group G'
inst✝¹ : Group G''
A : Type u_4
inst✝ : AddGroup A
H K : Subgroup G
ι : Sort u_5
S : ι → Subgroup G
x : G
⊢ x ∈ ⨅ i, S i ↔ ∀ (i : ι), x ∈ S i
state_after: no goals
tactic: simp only [iInf, mem_sInf, Set.forall_mem_range]
Theorem: Multiset.mem_of_mem_toEnumFinset
File: Mathlib/Data/Multiset/Fintype.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
m : Multiset α
p : α × ℕ
h : p ∈ m.toEnumFinset
this : p.2 < count p.1 m
⊢ 0 < count p.1 m
state_after: no goals
tactic: omega
Theorem: Path.trans_range
File: Mathlib/Topology/Connected/PathConnected.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
γ : Path x y
a b c : X
γ₁ : Path a b
γ₂ : Path b c
⊢ range ⇑(γ₁.trans γ₂) = range ⇑γ₁ ∪ range ⇑γ₂
state_after: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
γ : Path x y
a b c : X
γ₁ : Path a b
γ₂ : Path b c
⊢ range
      ⇑{ toFun := (fun t => if t ≤ 1 / 2 then γ₁.extend (2 * t) else γ₂.extend (2 * t - 1)) ∘ Subtype.val,
          continuous_toFun := ⋯, source' := ⋯, target' := ⋯ } =
    range ⇑γ₁ ∪ range ⇑γ₂
tactic: rw [Path.trans]
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
γ : Path x y
a b c : X
γ₁ : Path a b
γ₂ : Path b c
⊢ range
      ⇑{ toFun := (fun t => if t ≤ 1 / 2 then γ₁.extend (2 * t) else γ₂.extend (2 * t - 1)) ∘ Subtype.val,
          continuous_toFun := ⋯, source' := ⋯, target' := ⋯ } =
    range ⇑γ₁ ∪ range ⇑γ₂
state_after: case a
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
γ : Path x y
a b c : X
γ₁ : Path a b
γ₂ : Path b c
⊢ range
      ⇑{ toFun := (fun t => if t ≤ 1 / 2 then γ₁.extend (2 * t) else γ₂.extend (2 * t - 1)) ∘ Subtype.val,
          continuous_toFun := ⋯, source' := ⋯, target' := ⋯ } ⊆
    range ⇑γ₁ ∪ range ⇑γ₂

case a
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
γ : Path x y
a b c : X
γ₁ : Path a b
γ₂ : Path b c
⊢ range ⇑γ₁ ∪ range ⇑γ₂ ⊆
    range
      ⇑{ toFun := (fun t => if t ≤ 1 / 2 then γ₁.extend (2 * t) else γ₂.extend (2 * t - 1)) ∘ Subtype.val,
          continuous_toFun := ⋯, source' := ⋯, target' := ⋯ }
tactic: apply eq_of_subset_of_subset
Theorem: CategoryTheory.MonoidalCategory.whiskerLeft_inv_hom'
File: Mathlib/CategoryTheory/Monoidal/Category.lean

Proof steps:
state_before: C : Type u
𝒞 : Category.{v, u} C
inst✝¹ : MonoidalCategory C
X Y Z : C
f : Y ⟶ Z
inst✝ : IsIso f
⊢ X ◁ inv f ≫ X ◁ f = 𝟙 (X ⊗ Z)
state_after: no goals
tactic: rw [← whiskerLeft_comp, IsIso.inv_hom_id, whiskerLeft_id]
Theorem: Units.divp_add
File: Mathlib/Algebra/Ring/Units.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝ : Ring α
a✝ b✝ a b : α
u : αˣ
⊢ a /ₚ u + b = (a + b * ↑u) /ₚ u
state_after: no goals
tactic: simp only [divp, add_mul, Units.mul_inv_cancel_right]
Theorem: Polynomial.mirror_eq_zero
File: Mathlib/Algebra/Polynomial/Mirror.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Semiring R
p q : R[X]
h : p.mirror = 0
⊢ p = 0
state_after: no goals
tactic: rw [← p.mirror_mirror, h, mirror_zero]
state_before: R : Type u_1
inst✝ : Semiring R
p q : R[X]
h : p = 0
⊢ p.mirror = 0
state_after: no goals
tactic: rw [h, mirror_zero]
Theorem: Matrix.toLin_apply
File: Mathlib/LinearAlgebra/Matrix/ToLin.lean

Proof steps:
state_before: R : Type u_1
inst✝⁷ : CommSemiring R
l : Type u_2
m : Type u_3
n : Type u_4
inst✝⁶ : Fintype n
inst✝⁵ : Fintype m
inst✝⁴ : DecidableEq n
M₁ : Type u_5
M₂ : Type u_6
inst✝³ : AddCommMonoid M₁
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M₁
inst✝ : Module R M₂
v₁ : Basis n R M₁
v₂ : Basis m R M₂
M : Matrix m n R
v : M₁
⊢ v₂.equivFun.symm ((toLin' M) ⇑(v₁.repr v)) = ∑ j : m, (M *ᵥ ⇑(v₁.repr v)) j • v₂ j
state_after: no goals
tactic: rw [Matrix.toLin'_apply, v₂.equivFun_symm_apply]
Theorem: variationOnFromTo.add
File: Mathlib/Analysis/BoundedVariation.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : LinearOrder α
E : Type u_2
inst✝ : PseudoEMetricSpace E
f✝ : α → E
s✝ : Set α
f : α → E
s : Set α
hf : LocallyBoundedVariationOn f s
a b c : α
ha : a ∈ s
hb : b ∈ s
hc : c ∈ s
⊢ variationOnFromTo f s a b + variationOnFromTo f s b c = variationOnFromTo f s a c
state_after: α : Type u_1
inst✝¹ : LinearOrder α
E : Type u_2
inst✝ : PseudoEMetricSpace E
f✝ : α → E
s✝ : Set α
f : α → E
s : Set α
hf : LocallyBoundedVariationOn f s
a b c : α
ha : a ∈ s
hb : b ∈ s
hc : c ∈ s
⊢ variationOnFromTo f s a c = variationOnFromTo f s a b + variationOnFromTo f s b c
tactic: symm
Theorem: Nat.Ioc_filter_modEq_cast
File: Mathlib/Data/Int/CardIntervalMod.lean

Proof steps:
state_before: a b r : ℕ
hr : 0 < r
v : ℕ
⊢ map castEmbedding (filter (fun x => x ≡ v [MOD r]) (Ioc a b)) = filter (fun x => x ≡ ↑v [ZMOD ↑r]) (Ioc ↑a ↑b)
state_after: case a
a b r : ℕ
hr : 0 < r
v : ℕ
x : ℤ
⊢ x ∈ map castEmbedding (filter (fun x => x ≡ v [MOD r]) (Ioc a b)) ↔ x ∈ filter (fun x => x ≡ ↑v [ZMOD ↑r]) (Ioc ↑a ↑b)
tactic: ext x
state_before: case a
a b r : ℕ
hr : 0 < r
v : ℕ
x : ℤ
⊢ x ∈ map castEmbedding (filter (fun x => x ≡ v [MOD r]) (Ioc a b)) ↔ x ∈ filter (fun x => x ≡ ↑v [ZMOD ↑r]) (Ioc ↑a ↑b)
state_after: case a
a b r : ℕ
hr : 0 < r
v : ℕ
x : ℤ
⊢ (∃ a_1, ((a < a_1 ∧ a_1 ≤ b) ∧ a_1 ≡ v [MOD r]) ∧ ↑a_1 = x) ↔ (↑a < x ∧ x ≤ ↑b) ∧ x ≡ ↑v [ZMOD ↑r]
tactic: simp only [mem_map, mem_filter, mem_Ioc, castEmbedding_apply]
state_before: case a
a b r : ℕ
hr : 0 < r
v : ℕ
x : ℤ
⊢ (∃ a_1, ((a < a_1 ∧ a_1 ≤ b) ∧ a_1 ≡ v [MOD r]) ∧ ↑a_1 = x) ↔ (↑a < x ∧ x ≤ ↑b) ∧ x ≡ ↑v [ZMOD ↑r]
state_after: case a.mp
a b r : ℕ
hr : 0 < r
v : ℕ
x : ℤ
⊢ (∃ a_1, ((a < a_1 ∧ a_1 ≤ b) ∧ a_1 ≡ v [MOD r]) ∧ ↑a_1 = x) → (↑a < x ∧ x ≤ ↑b) ∧ x ≡ ↑v [ZMOD ↑r]

case a.mpr
a b r : ℕ
hr : 0 < r
v : ℕ
x : ℤ
⊢ (↑a < x ∧ x ≤ ↑b) ∧ x ≡ ↑v [ZMOD ↑r] → ∃ a_2, ((a < a_2 ∧ a_2 ≤ b) ∧ a_2 ≡ v [MOD r]) ∧ ↑a_2 = x
tactic: constructor
Theorem: toIcoMod_eventuallyEq_toIocMod
File: Mathlib/Topology/Instances/AddCircle.lean

Proof steps:
state_before: 𝕜 : Type u_1
B : Type u_2
inst✝³ : LinearOrderedAddCommGroup 𝕜
inst✝² : Archimedean 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
p : 𝕜
hp : 0 < p
a x : 𝕜
hx : ↑x ≠ ↑a
⊢ IsOpen {x | (fun x => toIcoMod hp a x = toIocMod hp a x) x}
state_after: 𝕜 : Type u_1
B : Type u_2
inst✝³ : LinearOrderedAddCommGroup 𝕜
inst✝² : Archimedean 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
p : 𝕜
hp : 0 < p
a x : 𝕜
hx : ↑x ≠ ↑a
⊢ IsOpen (⋃ z, Ioo (a + z • p) (a + p + z • p))
tactic: rw [Ico_eq_locus_Ioc_eq_iUnion_Ioo]
state_before: 𝕜 : Type u_1
B : Type u_2
inst✝³ : LinearOrderedAddCommGroup 𝕜
inst✝² : Archimedean 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
p : 𝕜
hp : 0 < p
a x : 𝕜
hx : ↑x ≠ ↑a
⊢ IsOpen (⋃ z, Ioo (a + z • p) (a + p + z • p))
state_after: no goals
tactic: exact isOpen_iUnion fun i => isOpen_Ioo
Theorem: Field.exists_primitive_element_of_finite_intermediateField
File: Mathlib/FieldTheory/PrimitiveElement.lean

Proof steps:
state_before: F : Type u_1
E : Type u_2
inst✝³ : Field F
inst✝² : Field E
inst✝¹ : Algebra F E
inst✝ : Finite (IntermediateField F E)
K : IntermediateField F E
⊢ ∃ α, F⟮α⟯ = K
state_after: F : Type u_1
E : Type u_2
inst✝³ : Field F
inst✝² : Field E
inst✝¹ : Algebra F E
inst✝ : Finite (IntermediateField F E)
K : IntermediateField F E
this : FiniteDimensional F E
⊢ ∃ α, F⟮α⟯ = K
tactic: haveI := FiniteDimensional.of_finite_intermediateField F E
state_before: F : Type u_1
E : Type u_2
inst✝³ : Field F
inst✝² : Field E
inst✝¹ : Algebra F E
inst✝ : Finite (IntermediateField F E)
K : IntermediateField F E
this : FiniteDimensional F E
⊢ ∃ α, F⟮α⟯ = K
state_after: case inl
F : Type u_1
E : Type u_2
inst✝³ : Field F
inst✝² : Field E
inst✝¹ : Algebra F E
inst✝ : Finite (IntermediateField F E)
K : IntermediateField F E
this : FiniteDimensional F E
h✝ : Finite F
⊢ ∃ α, F⟮α⟯ = K

case inr
F : Type u_1
E : Type u_2
inst✝³ : Field F
inst✝² : Field E
inst✝¹ : Algebra F E
inst✝ : Finite (IntermediateField F E)
K : IntermediateField F E
this : FiniteDimensional F E
h✝ : Infinite F
⊢ ∃ α, F⟮α⟯ = K
tactic: rcases finite_or_infinite F with (_ | _)
Theorem: Finset.sum_powerset_neg_one_pow_card
File: Mathlib/Data/Nat/Choose/Sum.lean

Proof steps:
state_before: R : Type u_1
α : Type u_2
inst✝ : DecidableEq α
x : Finset α
⊢ ∑ m ∈ x.powerset, (-1) ^ m.card = if x = ∅ then 1 else 0
state_after: R : Type u_1
α : Type u_2
inst✝ : DecidableEq α
x : Finset α
⊢ ∑ m ∈ range (x.card + 1), x.card.choose m • (-1) ^ m = if x = ∅ then 1 else 0
tactic: rw [sum_powerset_apply_card]
state_before: R : Type u_1
α : Type u_2
inst✝ : DecidableEq α
x : Finset α
⊢ ∑ m ∈ range (x.card + 1), x.card.choose m • (-1) ^ m = if x = ∅ then 1 else 0
state_after: no goals
tactic: simp only [nsmul_eq_mul', ← card_eq_zero, Int.alternating_sum_range_choose]
Theorem: Nat.triangle_succ
File: Mathlib/Data/Nat/Choose/Basic.lean

Proof steps:
state_before: n : ℕ
⊢ (n + 1) * (n + 1 - 1) / 2 = n * (n - 1) / 2 + n
state_after: n : ℕ
⊢ n * (n + 1) / 2 = n * (n - 1 + 2) / 2

case H
n : ℕ
⊢ 0 < 2
tactic: rw [← add_mul_div_left, Nat.mul_comm 2 n, ← Nat.mul_add, Nat.add_sub_cancel, Nat.mul_comm]
state_before: n : ℕ
⊢ n * (n + 1) / 2 = n * (n - 1 + 2) / 2

case H
n : ℕ
⊢ 0 < 2
state_after: case H
n : ℕ
⊢ 0 < 2
tactic: cases n <;> rfl
state_before: case H
n : ℕ
⊢ 0 < 2
state_after: no goals
tactic: apply zero_lt_succ
Theorem: Polynomial.hermite_one
File: Mathlib/RingTheory/Polynomial/Hermite/Basic.lean

Proof steps:
state_before: ⊢ hermite 1 = X
state_after: ⊢ X * C 1 - derivative (C 1) = X
tactic: rw [hermite_succ, hermite_zero]
state_before: ⊢ X * C 1 - derivative (C 1) = X
state_after: no goals
tactic: simp only [map_one, mul_one, derivative_one, sub_zero]