ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: addLeftEmbedding_eq_addRightEmbedding
File: Mathlib/Algebra/Group/Embedding.lean

Proof steps:
state_before: G : Type u_1
inst✝¹ : CommSemigroup G
inst✝ : IsCancelMul G
g : G
⊢ mulLeftEmbedding g = mulRightEmbedding g
state_after: case h
G : Type u_1
inst✝¹ : CommSemigroup G
inst✝ : IsCancelMul G
g x✝ : G
⊢ (mulLeftEmbedding g) x✝ = (mulRightEmbedding g) x✝
tactic: ext
state_before: case h
G : Type u_1
inst✝¹ : CommSemigroup G
inst✝ : IsCancelMul G
g x✝ : G
⊢ (mulLeftEmbedding g) x✝ = (mulRightEmbedding g) x✝
state_after: no goals
tactic: exact mul_comm _ _
Theorem: Equiv.Perm.VectorsProdEqOne.vectorEquiv_apply_coe
File: Mathlib/GroupTheory/Perm/Cycle/Type.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : Fintype α
G : Type u_2
inst✝ : Group G
n : ℕ
v : Vector G n
⊢ v.toList.prod⁻¹ ::ᵥ v ∈ vectorsProdEqOne G (n + 1)
state_after: no goals
tactic: rw [mem_iff, Vector.toList_cons, List.prod_cons, inv_mul_self]
state_before: α : Type u_1
inst✝¹ : Fintype α
G : Type u_2
inst✝ : Group G
n : ℕ
v : ↑(vectorsProdEqOne G (n + 1))
⊢ (↑v).head * (↑v).tail.toList.prod = 1
state_after: α : Type u_1
inst✝¹ : Fintype α
G : Type u_2
inst✝ : Group G
n : ℕ
v : ↑(vectorsProdEqOne G (n + 1))
⊢ (↑v).toList.prod = 1
tactic: rw [← List.prod_cons, ← Vector.toList_cons, v.1.cons_head_tail]
state_before: α : Type u_1
inst✝¹ : Fintype α
G : Type u_2
inst✝ : Group G
n : ℕ
v : ↑(vectorsProdEqOne G (n + 1))
⊢ (↑v).toList.prod = 1
state_after: no goals
tactic: exact v.2
Theorem: CategoryTheory.ShortComplex.Splitting.epi_g
File: Mathlib/Algebra/Homology/ShortComplex/Exact.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝³ : Category.{u_3, u_1} C
inst✝² : Category.{?u.80198, u_2} D
inst✝¹ : Preadditive C
inst✝ : Preadditive D
S : ShortComplex C
s : S.Splitting
⊢ Epi S.g
state_after: C : Type u_1
D : Type u_2
inst✝³ : Category.{u_3, u_1} C
inst✝² : Category.{?u.80198, u_2} D
inst✝¹ : Preadditive C
inst✝ : Preadditive D
S : ShortComplex C
s : S.Splitting
this : IsSplitEpi S.g
⊢ Epi S.g
tactic: have := s.isSplitEpi_g
state_before: C : Type u_1
D : Type u_2
inst✝³ : Category.{u_3, u_1} C
inst✝² : Category.{?u.80198, u_2} D
inst✝¹ : Preadditive C
inst✝ : Preadditive D
S : ShortComplex C
s : S.Splitting
this : IsSplitEpi S.g
⊢ Epi S.g
state_after: no goals
tactic: infer_instance
Theorem: MulChar.equivToUnitHom_mul_apply
File: Mathlib/NumberTheory/MulChar/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝¹ : CommMonoid R
R' : Type u_2
inst✝ : CommMonoidWithZero R'
χ₁ χ₂ : MulChar R R'
a : Rˣ
⊢ (equivToUnitHom (χ₁ * χ₂)) a = (equivToUnitHom χ₁) a * (equivToUnitHom χ₂) a
state_after: R : Type u_1
inst✝¹ : CommMonoid R
R' : Type u_2
inst✝ : CommMonoidWithZero R'
χ₁ χ₂ : MulChar R R'
a : Rˣ
⊢ ↑((equivToUnitHom (χ₁ * χ₂)) a) = ↑((equivToUnitHom χ₁) a * (equivToUnitHom χ₂) a)
tactic: apply_fun ((↑) : R'ˣ → R') using Units.ext
state_before: R : Type u_1
inst✝¹ : CommMonoid R
R' : Type u_2
inst✝ : CommMonoidWithZero R'
χ₁ χ₂ : MulChar R R'
a : Rˣ
⊢ ↑((equivToUnitHom (χ₁ * χ₂)) a) = ↑((equivToUnitHom χ₁) a * (equivToUnitHom χ₂) a)
state_after: R : Type u_1
inst✝¹ : CommMonoid R
R' : Type u_2
inst✝ : CommMonoidWithZero R'
χ₁ χ₂ : MulChar R R'
a : Rˣ
⊢ ↑((equivToUnitHom (χ₁ * χ₂)) a) = ↑((equivToUnitHom χ₁) a) * ↑((equivToUnitHom χ₂) a)
tactic: push_cast
state_before: R : Type u_1
inst✝¹ : CommMonoid R
R' : Type u_2
inst✝ : CommMonoidWithZero R'
χ₁ χ₂ : MulChar R R'
a : Rˣ
⊢ ↑((equivToUnitHom (χ₁ * χ₂)) a) = ↑((equivToUnitHom χ₁) a) * ↑((equivToUnitHom χ₂) a)
state_after: no goals
tactic: simp_rw [coe_equivToUnitHom, coeToFun_mul, Pi.mul_apply]
Theorem: Matrix.det_mul_right_comm
File: Mathlib/LinearAlgebra/Matrix/Determinant/Basic.lean

Proof steps:
state_before: m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
M N P : Matrix m m R
⊢ (M * N * P).det = (M * P * N).det
state_after: no goals
tactic: rw [Matrix.mul_assoc, Matrix.mul_assoc, det_mul, det_mul_comm N P, ← det_mul]
Theorem: UniqueMul.mulHom_map_iff
File: Mathlib/Algebra/Group/UniqueProds.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A B : Finset G
a0 b0 : G
f : G ↪ H
mul : ∀ (x y : G), f (x * y) = f x * f y
⊢ UniqueMul (Finset.map f A) (Finset.map f B) (f a0) (f b0) ↔ UniqueMul A B a0 b0
state_after: no goals
tactic: classical simp_rw [← mulHom_image_iff ⟨f, mul⟩ f.2, Finset.map_eq_image]; rfl
Theorem: SimpleGraph.iSup_adj
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

Proof steps:
state_before: ι : Sort u_1
V : Type u
G : SimpleGraph V
a b c u v w : V
e : Sym2 V
f : ι → SimpleGraph V
⊢ (⨆ i, f i).Adj a b ↔ ∃ i, (f i).Adj a b
state_after: no goals
tactic: simp [iSup]
Theorem: Real.pi_le_four
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

Proof steps:
state_before: ⊢ 0 < 2
state_after: no goals
tactic: norm_num
state_before: ⊢ 2 = 4 / 2
state_after: no goals
tactic: norm_num
Theorem: Orientation.oangle_sub_right
File: Mathlib/Geometry/Euclidean/Angle/Oriented/Basic.lean

Proof steps:
state_before: V : Type u_1
V' : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : NormedAddCommGroup V'
inst✝³ : InnerProductSpace ℝ V
inst✝² : InnerProductSpace ℝ V'
inst✝¹ : Fact (finrank ℝ V = 2)
inst✝ : Fact (finrank ℝ V' = 2)
o : Orientation ℝ V (Fin 2)
x y z : V
hx : x ≠ 0
hy : y ≠ 0
hz : z ≠ 0
⊢ o.oangle x z - o.oangle y z = o.oangle x y
state_after: no goals
tactic: rw [sub_eq_iff_eq_add, o.oangle_add hx hy hz]
Theorem: _private.Mathlib.RingTheory.Polynomial.Basic.0.MvPolynomial.uniqueFactorizationMonoid_of_fintype
File: Mathlib/RingTheory/Polynomial/Basic.lean

Proof steps:
state_before: R : Type u
S : Type u_1
σ : Type v
M : Type w
inst✝⁷ : CommRing R
inst✝⁶ : CommRing S
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
D : Type u
inst✝³ : CommRing D
inst✝² : IsDomain D
inst✝¹ : UniqueFactorizationMonoid D
d : ℕ
inst✝ : Fintype σ
⊢ UniqueFactorizationMonoid (MvPolynomial (Fin (Fintype.card σ)) D)
state_after: case zero
R : Type u
S : Type u_1
σ : Type v
M : Type w
inst✝⁷ : CommRing R
inst✝⁶ : CommRing S
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
D : Type u
inst✝³ : CommRing D
inst✝² : IsDomain D
inst✝¹ : UniqueFactorizationMonoid D
d : ℕ
inst✝ : Fintype σ
⊢ UniqueFactorizationMonoid (MvPolynomial (Fin 0) D)

case succ
R : Type u
S : Type u_1
σ : Type v
M : Type w
inst✝⁷ : CommRing R
inst✝⁶ : CommRing S
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
D : Type u
inst✝³ : CommRing D
inst✝² : IsDomain D
inst✝¹ : UniqueFactorizationMonoid D
d✝ : ℕ
inst✝ : Fintype σ
d : ℕ
hd : UniqueFactorizationMonoid (MvPolynomial (Fin d) D)
⊢ UniqueFactorizationMonoid (MvPolynomial (Fin (d + 1)) D)
tactic: induction' Fintype.card σ with d hd
Theorem: SetTheory.PGame.bddBelow_of_small
File: Mathlib/SetTheory/Game/PGame.lean

Proof steps:
state_before: xl xr : Type u
s : Set PGame
inst✝ : Small.{u, u + 1} ↑s
⊢ BddBelow s
state_after: no goals
tactic: simpa using bddBelow_range_of_small (Subtype.val : s → PGame.{u})
Theorem: convex_iff_pointwise_add_subset
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✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : SMul 𝕜 E
inst✝ : SMul 𝕜 F
s : Set E
x : E
⊢ Convex 𝕜 s → ∀ ⦃a b : 𝕜⦄, 0 ≤ a → 0 ≤ b → a + b = 1 → a • s + b • s ⊆ s
state_after: case intro.intro.intro.intro.intro.intro.intro.intro
𝕜 : Type u_1
E : Type u_2
F : Type u_3
β : Type u_4
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : SMul 𝕜 E
inst✝ : SMul 𝕜 F
s : Set E
x : E
hA : Convex 𝕜 s
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
u : E
hu : u ∈ s
v : E
hv : v ∈ s
⊢ (fun x x_1 => x + x_1) ((fun x => a • x) u) ((fun x => b • x) v) ∈ s
tactic: rintro hA a b ha hb hab w ⟨au, ⟨u, hu, rfl⟩, bv, ⟨v, hv, rfl⟩, rfl⟩
state_before: case intro.intro.intro.intro.intro.intro.intro.intro
𝕜 : Type u_1
E : Type u_2
F : Type u_3
β : Type u_4
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : SMul 𝕜 E
inst✝ : SMul 𝕜 F
s : Set E
x : E
hA : Convex 𝕜 s
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
u : E
hu : u ∈ s
v : E
hv : v ∈ s
⊢ (fun x x_1 => x + x_1) ((fun x => a • x) u) ((fun x => b • x) v) ∈ s
state_after: no goals
tactic: exact hA hu hv ha hb hab
Theorem: div_lt_div_iff_left
File: Mathlib/Algebra/Order/Group/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u
inst✝³ : Group α
inst✝² : LT α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x < x_1
a✝ b c a : α
⊢ a / b < a / c ↔ c < b
state_after: no goals
tactic: rw [div_eq_mul_inv, div_eq_mul_inv, ← mul_lt_mul_iff_left a⁻¹, inv_mul_cancel_left,
    inv_mul_cancel_left, inv_lt_inv_iff]
Theorem: CategoryTheory.Adjunction.localization_unit_app
File: Mathlib/CategoryTheory/Localization/Adjunction.lean

Proof steps:
state_before: C₁ : Type u_1
C₂ : Type u_2
D₁ : Type u_3
D₂ : Type u_4
inst✝⁷ : Category.{u_6, u_1} C₁
inst✝⁶ : Category.{u_8, u_2} C₂
inst✝⁵ : Category.{u_5, u_3} D₁
inst✝⁴ : Category.{u_7, u_4} D₂
G : C₁ ⥤ C₂
F : C₂ ⥤ C₁
adj : G ⊣ F
L₁ : C₁ ⥤ D₁
W₁ : MorphismProperty C₁
inst✝³ : L₁.IsLocalization W₁
L₂ : C₂ ⥤ D₂
W₂ : MorphismProperty C₂
inst✝² : L₂.IsLocalization W₂
G' : D₁ ⥤ D₂
F' : D₂ ⥤ D₁
inst✝¹ : CatCommSq G L₁ L₂ G'
inst✝ : CatCommSq F L₂ L₁ F'
X₁ : C₁
⊢ (adj.localization L₁ W₁ L₂ W₂ G' F').unit.app (L₁.obj X₁) =
    L₁.map (adj.unit.app X₁) ≫
      (CatCommSq.iso F L₂ L₁ F').hom.app (G.obj X₁) ≫ F'.map ((CatCommSq.iso G L₁ L₂ G').hom.app X₁)
state_after: no goals
tactic: apply Localization.ε_app
Theorem: HasProd.update'
File: Mathlib/Topology/Algebra/InfiniteSum/Basic.lean

Proof steps:
state_before: α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁷ : CommMonoid α✝
inst✝⁶ : TopologicalSpace α✝
f✝ g : β✝ → α✝
a✝ b✝ : α✝
s : Finset β✝
inst✝⁵ : ContinuousMul α✝
α : Type u_5
β : Type u_6
inst✝⁴ : TopologicalSpace α
inst✝³ : CommMonoid α
inst✝² : T2Space α
inst✝¹ : ContinuousMul α
inst✝ : DecidableEq β
f : β → α
a a' : α
hf : HasProd f a
b : β
x : α
hf' : HasProd (update f b x) a'
this : ∀ (b' : β), (f b' * if b' = b then x else 1) = update f b x b' * if b' = b then f b else 1
⊢ a * x = a' * f b
state_after: α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁷ : CommMonoid α✝
inst✝⁶ : TopologicalSpace α✝
f✝ g : β✝ → α✝
a✝ b✝ : α✝
s : Finset β✝
inst✝⁵ : ContinuousMul α✝
α : Type u_5
β : Type u_6
inst✝⁴ : TopologicalSpace α
inst✝³ : CommMonoid α
inst✝² : T2Space α
inst✝¹ : ContinuousMul α
inst✝ : DecidableEq β
f : β → α
a a' : α
hf : HasProd f a
b : β
x : α
hf' : HasProd (update f b x) a'
this : ∀ (b' : β), (f b' * if b' = b then x else 1) = update f b x b' * if b' = b then f b else 1
h : HasProd (fun b_1 => f b_1 * if b_1 = b then x else 1) (a * x)
⊢ a * x = a' * f b
tactic: have h := hf.mul (hasProd_ite_eq b x)
state_before: α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁷ : CommMonoid α✝
inst✝⁶ : TopologicalSpace α✝
f✝ g : β✝ → α✝
a✝ b✝ : α✝
s : Finset β✝
inst✝⁵ : ContinuousMul α✝
α : Type u_5
β : Type u_6
inst✝⁴ : TopologicalSpace α
inst✝³ : CommMonoid α
inst✝² : T2Space α
inst✝¹ : ContinuousMul α
inst✝ : DecidableEq β
f : β → α
a a' : α
hf : HasProd f a
b : β
x : α
hf' : HasProd (update f b x) a'
this : ∀ (b' : β), (f b' * if b' = b then x else 1) = update f b x b' * if b' = b then f b else 1
h : HasProd (fun b_1 => f b_1 * if b_1 = b then x else 1) (a * x)
⊢ a * x = a' * f b
state_after: α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁷ : CommMonoid α✝
inst✝⁶ : TopologicalSpace α✝
f✝ g : β✝ → α✝
a✝ b✝ : α✝
s : Finset β✝
inst✝⁵ : ContinuousMul α✝
α : Type u_5
β : Type u_6
inst✝⁴ : TopologicalSpace α
inst✝³ : CommMonoid α
inst✝² : T2Space α
inst✝¹ : ContinuousMul α
inst✝ : DecidableEq β
f : β → α
a a' : α
hf : HasProd f a
b : β
x : α
hf' : HasProd (update f b x) a'
this : ∀ (b' : β), (f b' * if b' = b then x else 1) = update f b x b' * if b' = b then f b else 1
h : HasProd (fun b_1 => update f b x b_1 * if b_1 = b then f b else 1) (a * x)
⊢ a * x = a' * f b
tactic: simp_rw [this] at h
state_before: α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁷ : CommMonoid α✝
inst✝⁶ : TopologicalSpace α✝
f✝ g : β✝ → α✝
a✝ b✝ : α✝
s : Finset β✝
inst✝⁵ : ContinuousMul α✝
α : Type u_5
β : Type u_6
inst✝⁴ : TopologicalSpace α
inst✝³ : CommMonoid α
inst✝² : T2Space α
inst✝¹ : ContinuousMul α
inst✝ : DecidableEq β
f : β → α
a a' : α
hf : HasProd f a
b : β
x : α
hf' : HasProd (update f b x) a'
this : ∀ (b' : β), (f b' * if b' = b then x else 1) = update f b x b' * if b' = b then f b else 1
h : HasProd (fun b_1 => update f b x b_1 * if b_1 = b then f b else 1) (a * x)
⊢ a * x = a' * f b
state_after: no goals
tactic: exact HasProd.unique h (hf'.mul (hasProd_ite_eq b (f b)))
Theorem: Batteries.DList.toList_empty
File: Mathlib/Data/DList/Defs.lean

Proof steps:
state_before: α : Type u
⊢ empty.toList = []
state_after: no goals
tactic: simp
Theorem: quadraticCharFun_zero
File: Mathlib/NumberTheory/LegendreSymbol/QuadraticChar/Basic.lean

Proof steps:
state_before: F : Type u_1
inst✝² : Field F
inst✝¹ : Fintype F
inst✝ : DecidableEq F
⊢ quadraticCharFun F 0 = 0
state_after: no goals
tactic: simp only [quadraticCharFun, if_true]
Theorem: Nat.ofDigits_div_eq_ofDigits_tail
File: Mathlib/Data/Nat/Digits.lean

Proof steps:
state_before: n p : ℕ
hpos : 0 < p
digits : List ℕ
w₁ : ∀ l ∈ digits, l < p
⊢ ofDigits p digits / p = ofDigits p digits.tail
state_after: case nil
n p : ℕ
hpos : 0 < p
w₁ : ∀ l ∈ [], l < p
⊢ ofDigits p [] / p = ofDigits p [].tail

case cons
n p : ℕ
hpos : 0 < p
hd : ℕ
tl : List ℕ
tail_ih✝ : (∀ l ∈ tl, l < p) → ofDigits p tl / p = ofDigits p tl.tail
w₁ : ∀ l ∈ hd :: tl, l < p
⊢ ofDigits p (hd :: tl) / p = ofDigits p (hd :: tl).tail
tactic: induction' digits with hd tl
Theorem: HurwitzKernelBounds.F_int_eq_of_mem_Icc
File: Mathlib/NumberTheory/ModularForms/JacobiTheta/Bounds.lean

Proof steps:
state_before: k : ℕ
a : ℝ
ha : a ∈ Icc 0 1
t : ℝ
ht : 0 < t
⊢ F_int k (↑a) t = F_nat k a t + F_nat k (1 - a) t
state_after: k : ℕ
a : ℝ
ha : a ∈ Icc 0 1
t : ℝ
ht : 0 < t
⊢ ∑' (n : ℤ), f_int k a t n = ∑' (n : ℕ), f_nat k a t n + ∑' (n : ℕ), f_nat k (1 - a) t n
tactic: simp only [F_int, F_nat, Function.Periodic.lift_coe]
state_before: k : ℕ
a : ℝ
ha : a ∈ Icc 0 1
t : ℝ
ht : 0 < t
⊢ ∑' (n : ℤ), f_int k a t n = ∑' (n : ℕ), f_nat k a t n + ∑' (n : ℕ), f_nat k (1 - a) t n
state_after: case h.e'_2.h.e'_5.h
k : ℕ
a : ℝ
ha : a ∈ Icc 0 1
t : ℝ
ht : 0 < t
n : ℤ
⊢ f_int k a t n = Int.rec (f_nat k a t) (f_nat k (1 - a) t) n
tactic: convert ((summable_f_nat k a ht).hasSum.int_rec (summable_f_nat k (1 - a) ht).hasSum).tsum_eq
    using 3 with n
state_before: case h.e'_2.h.e'_5.h
k : ℕ
a : ℝ
ha : a ∈ Icc 0 1
t : ℝ
ht : 0 < t
n : ℤ
⊢ f_int k a t n = Int.rec (f_nat k a t) (f_nat k (1 - a) t) n
state_after: case h.e'_2.h.e'_5.h.ofNat
k : ℕ
a : ℝ
ha : a ∈ Icc 0 1
t : ℝ
ht : 0 < t
m : ℕ
⊢ f_int k a t (Int.ofNat m) = Int.rec (f_nat k a t) (f_nat k (1 - a) t) (Int.ofNat m)

case h.e'_2.h.e'_5.h.negSucc
k : ℕ
a : ℝ
ha : a ∈ Icc 0 1
t : ℝ
ht : 0 < t
m : ℕ
⊢ f_int k a t (Int.negSucc m) = Int.rec (f_nat k a t) (f_nat k (1 - a) t) (Int.negSucc m)
tactic: cases' n with m m
Theorem: Polynomial.mapAlgHom_eq_eval₂AlgHom'_CAlgHom
File: Mathlib/Algebra/Polynomial/AlgebraMap.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
A : Type z
A' : Type u_1
B : Type u_2
a b : R
n : ℕ
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Semiring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
p q r : R[X]
f : A →ₐ[R] B
⊢ mapAlgHom f = eval₂AlgHom' (CAlgHom.comp f) X ⋯
state_after: case H
R : Type u
S : Type v
T : Type w
A : Type z
A' : Type u_1
B : Type u_2
a b : R
n : ℕ
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Semiring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
p q r : R[X]
f : A →ₐ[R] B
⊢ ∀ (x : A[X]), (mapAlgHom f) x = (eval₂AlgHom' (CAlgHom.comp f) X ⋯) x
tactic: apply AlgHom.ext
state_before: case H
R : Type u
S : Type v
T : Type w
A : Type z
A' : Type u_1
B : Type u_2
a b : R
n : ℕ
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Semiring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
p q r : R[X]
f : A →ₐ[R] B
⊢ ∀ (x : A[X]), (mapAlgHom f) x = (eval₂AlgHom' (CAlgHom.comp f) X ⋯) x
state_after: case H
R : Type u
S : Type v
T : Type w
A : Type z
A' : Type u_1
B : Type u_2
a b : R
n : ℕ
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Semiring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
p q r : R[X]
f : A →ₐ[R] B
x : A[X]
⊢ (mapAlgHom f) x = (eval₂AlgHom' (CAlgHom.comp f) X ⋯) x
tactic: intro x
state_before: case H
R : Type u
S : Type v
T : Type w
A : Type z
A' : Type u_1
B : Type u_2
a b : R
n : ℕ
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Semiring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
p q r : R[X]
f : A →ₐ[R] B
x : A[X]
⊢ (mapAlgHom f) x = (eval₂AlgHom' (CAlgHom.comp f) X ⋯) x
state_after: no goals
tactic: congr
Theorem: List.lookmap_cons_none
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : α → Option α
a : α
l : List α
h : f a = none
⊢ lookmap f (a :: l) = a :: lookmap f l
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : α → Option α
a : α
l : List α
h : f a = none
⊢ (match f a with
    | some b => b :: l
    | none => lookmap.go f l (#[].push a)) =
    a :: lookmap.go f l #[]
tactic: simp only [lookmap, lookmap.go, Array.toListAppend_eq, Array.data_toArray, nil_append]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : α → Option α
a : α
l : List α
h : f a = none
⊢ (match f a with
    | some b => b :: l
    | none => lookmap.go f l (#[].push a)) =
    a :: lookmap.go f l #[]
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : α → Option α
a : α
l : List α
h : f a = none
⊢ (match none with
    | some b => b :: l
    | none => (#[].push a).toListAppend (lookmap f l)) =
    a :: lookmap.go f l #[]
tactic: rw [lookmap.go_append, h]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : α → Option α
a : α
l : List α
h : f a = none
⊢ (match none with
    | some b => b :: l
    | none => (#[].push a).toListAppend (lookmap f l)) =
    a :: lookmap.go f l #[]
state_after: no goals
tactic: rfl
Theorem: AddSubgroup.map_eq_comap_of_inverse
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
N : Type u_5
inst✝ : Group N
f✝ f : G →* N
g : N →* G
hl : LeftInverse ⇑g ⇑f
hr : Function.RightInverse ⇑g ⇑f
H : Subgroup G
⊢ ↑(map f H) = ↑(comap g H)
state_after: no goals
tactic: rw [coe_map, coe_comap, Set.image_eq_preimage_of_inverse hl hr]
Theorem: List.rotate_injective
File: Mathlib/Data/List/Rotate.lean

Proof steps:
state_before: α : Type u
n : ℕ
⊢ Injective fun l => l.rotate n
state_after: α : Type u
n : ℕ
l l' : List α
h : l.rotate n = l'.rotate n
⊢ l = l'
tactic: rintro l l' (h : l.rotate n = l'.rotate n)
state_before: α : Type u
n : ℕ
l l' : List α
h : l.rotate n = l'.rotate n
⊢ l = l'
state_after: α : Type u
n : ℕ
l l' : List α
h : l.rotate n = l'.rotate n
hle : l.length = l'.length
⊢ l = l'
tactic: have hle : l.length = l'.length := (l.length_rotate n).symm.trans (h.symm ▸ l'.length_rotate n)
state_before: α : Type u
n : ℕ
l l' : List α
h : l.rotate n = l'.rotate n
hle : l.length = l'.length
⊢ l = l'
state_after: α : Type u
n : ℕ
l l' : List α
h : drop (n % l.length) l ++ take (n % l.length) l = drop (n % l'.length) l' ++ take (n % l'.length) l'
hle : l.length = l'.length
⊢ l = l'
tactic: rw [rotate_eq_drop_append_take_mod, rotate_eq_drop_append_take_mod] at h
state_before: α : Type u
n : ℕ
l l' : List α
h : drop (n % l.length) l ++ take (n % l.length) l = drop (n % l'.length) l' ++ take (n % l'.length) l'
hle : l.length = l'.length
⊢ l = l'
state_after: case intro
α : Type u
n : ℕ
l l' : List α
h : drop (n % l.length) l ++ take (n % l.length) l = drop (n % l'.length) l' ++ take (n % l'.length) l'
hle : l.length = l'.length
hd : drop (n % l.length) l = drop (n % l'.length) l'
ht : take (n % l.length) l = take (n % l'.length) l'
⊢ l = l'
tactic: obtain ⟨hd, ht⟩ := append_inj h (by simp_all)
state_before: case intro
α : Type u
n : ℕ
l l' : List α
h : drop (n % l.length) l ++ take (n % l.length) l = drop (n % l'.length) l' ++ take (n % l'.length) l'
hle : l.length = l'.length
hd : drop (n % l.length) l = drop (n % l'.length) l'
ht : take (n % l.length) l = take (n % l'.length) l'
⊢ l = l'
state_after: no goals
tactic: rw [← take_append_drop _ l, ht, hd, take_append_drop]
Theorem: List.length_eraseIdx_add_one
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
inst✝ : DecidableEq α
l : List ι
i : ℕ
h : i < l.length
⊢ (l.eraseIdx i).length + 1 = (take i l ++ drop (i + 1) l).length + 1
state_after: no goals
tactic: rw [eraseIdx_eq_take_drop_succ]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
inst✝ : DecidableEq α
l : List ι
i : ℕ
h : i < l.length
⊢ (take i l ++ drop (i + 1) l).length + 1 = (take i l).length + (drop (i + 1) l).length + 1
state_after: no goals
tactic: rw [length_append]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
inst✝ : DecidableEq α
l : List ι
i : ℕ
h : i < l.length
⊢ (take i l).length + (drop (i + 1) l).length + 1 = i + (drop (i + 1) l).length + 1
state_after: no goals
tactic: rw [length_take_of_le (le_of_lt h)]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
inst✝ : DecidableEq α
l : List ι
i : ℕ
h : i < l.length
⊢ i + (drop (i + 1) l).length + 1 = i + (l.length - (i + 1)) + 1
state_after: no goals
tactic: rw [length_drop]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
inst✝ : DecidableEq α
l : List ι
i : ℕ
h : i < l.length
⊢ i + (l.length - (i + 1)) + 1 = i + 1 + (l.length - (i + 1))
state_after: no goals
tactic: omega
Theorem: _private.Mathlib.NumberTheory.Padics.Hensel.0.newton_seq_succ_dist
File: Mathlib/NumberTheory/Padics/Hensel.lean

Proof steps:
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
a : ℤ_[p]
hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (Polynomial.derivative F)‖ ^ 2
hnsol : Polynomial.eval a F ≠ 0
n : ℕ
⊢ ‖Polynomial.eval (newton_seq n) F‖ / ‖Polynomial.eval (newton_seq n) (Polynomial.derivative F)‖ =
    ‖Polynomial.eval (newton_seq n) F‖ / ‖Polynomial.eval a (Polynomial.derivative F)‖
state_after: no goals
tactic: rw [newton_seq_deriv_norm]