ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CategoryTheory.Limits.MultispanIndex.toSigmaCoforkFunctor_map_hom
File: Mathlib/CategoryTheory/Limits/Shapes/Multiequalizer.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
I : MultispanIndex C
inst✝¹ : HasCoproduct I.left
inst✝ : HasCoproduct I.right
K₁ K₂ : Multicofork I
f : K₁ ⟶ K₂
⊢ ∀ (j : WalkingParallelPair), K₁.toSigmaCofork.ι.app j ≫ f.hom = K₂.toSigmaCofork.ι.app j
state_after: case zero
C : Type u
inst✝² : Category.{v, u} C
I : MultispanIndex C
inst✝¹ : HasCoproduct I.left
inst✝ : HasCoproduct I.right
K₁ K₂ : Multicofork I
f : K₁ ⟶ K₂
⊢ K₁.toSigmaCofork.ι.app WalkingParallelPair.zero ≫ f.hom = K₂.toSigmaCofork.ι.app WalkingParallelPair.zero

case one
C : Type u
inst✝² : Category.{v, u} C
I : MultispanIndex C
inst✝¹ : HasCoproduct I.left
inst✝ : HasCoproduct I.right
K₁ K₂ : Multicofork I
f : K₁ ⟶ K₂
⊢ K₁.toSigmaCofork.ι.app WalkingParallelPair.one ≫ f.hom = K₂.toSigmaCofork.ι.app WalkingParallelPair.one
tactic: rintro (_|_)
state_before: case zero
C : Type u
inst✝² : Category.{v, u} C
I : MultispanIndex C
inst✝¹ : HasCoproduct I.left
inst✝ : HasCoproduct I.right
K₁ K₂ : Multicofork I
f : K₁ ⟶ K₂
⊢ K₁.toSigmaCofork.ι.app WalkingParallelPair.zero ≫ f.hom = K₂.toSigmaCofork.ι.app WalkingParallelPair.zero

case one
C : Type u
inst✝² : Category.{v, u} C
I : MultispanIndex C
inst✝¹ : HasCoproduct I.left
inst✝ : HasCoproduct I.right
K₁ K₂ : Multicofork I
f : K₁ ⟶ K₂
⊢ K₁.toSigmaCofork.ι.app WalkingParallelPair.one ≫ f.hom = K₂.toSigmaCofork.ι.app WalkingParallelPair.one
state_after: no goals
tactic: all_goals {
        apply colimit.hom_ext
        rintro ⟨j⟩
        simp }
Theorem: Finset.mulDysonETransform.card
File: Mathlib/Combinatorics/Additive/ETransform.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : CommGroup α
e : α
x : Finset α × Finset α
⊢ (mulDysonETransform e x).1.card + (mulDysonETransform e x).2.card = x.1.card + x.2.card
state_after: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : CommGroup α
e : α
x : Finset α × Finset α
⊢ (x.1 ∪ e • x.2).card + (x.2 ∩ e⁻¹ • x.1).card = x.1.card + x.2.card
tactic: dsimp
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : CommGroup α
e : α
x : Finset α × Finset α
⊢ (x.1 ∪ e • x.2).card + (x.2 ∩ e⁻¹ • x.1).card = x.1.card + x.2.card
state_after: no goals
tactic: rw [← card_smul_finset e (_ ∩ _), smul_finset_inter, smul_inv_smul, inter_comm,
    card_union_add_card_inter, card_smul_finset]
Theorem: Nat.sub_sub_sub_cancel_right
File: Mathlib/Data/Nat/Defs.lean

Proof steps:
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
h : c ≤ b
⊢ a - c - (b - c) = a - b
state_after: no goals
tactic: omega
Theorem: CochainComplex.HomComplex.Cochain.neg_comp
File: Mathlib/Algebra/Homology/HomotopyCategory/HomComplex.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m n₁ n₂ n₁₂ : ℤ
z₁ : Cochain F G n₁
z₂ : Cochain G K n₂
h : n₁ + n₂ = n₁₂
⊢ (-z₁).comp z₂ h = -z₁.comp z₂ h
state_after: case h
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m n₁ n₂ n₁₂ : ℤ
z₁ : Cochain F G n₁
z₂ : Cochain G K n₂
h : n₁ + n₂ = n₁₂
p q : ℤ
hpq : p + n₁₂ = q
⊢ ((-z₁).comp z₂ h).v p q hpq = (-z₁.comp z₂ h).v p q hpq
tactic: ext p q hpq
state_before: case h
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m n₁ n₂ n₁₂ : ℤ
z₁ : Cochain F G n₁
z₂ : Cochain G K n₂
h : n₁ + n₂ = n₁₂
p q : ℤ
hpq : p + n₁₂ = q
⊢ ((-z₁).comp z₂ h).v p q hpq = (-z₁.comp z₂ h).v p q hpq
state_after: no goals
tactic: simp only [comp_v _ _ h p _ q rfl (by omega), neg_v, neg_comp]
Theorem: Stream'.mem_of_mem_odd
File: Mathlib/Data/Stream/Init.lean

Proof steps:
state_before: α : Type u
β : Type v
δ : Type w
a : α
s : Stream' α
x✝ : a ∈ s.odd
n : ℕ
h : (fun b => a = b) (s.odd.get n)
⊢ (fun b => a = b) (s.get (2 * n + 1))
state_after: no goals
tactic: rw [h, get_odd]
Theorem: List.findIdx_eq
File: Mathlib/Data/List/Indexes.lean

Proof steps:
state_before: α : Type u
β : Type v
p : α → Bool
xs : List α
i : ℕ
h : i < xs.length
⊢ findIdx p xs = i ↔ p (xs.get ⟨i, h⟩) = true ∧ ∀ (j : ℕ) (hji : j < i), ¬p (xs.get ⟨j, ⋯⟩) = true
state_after: α : Type u
β : Type v
p : α → Bool
xs : List α
i : ℕ
h : i < xs.length
x✝ : p (xs.get ⟨i, h⟩) = true ∧ ∀ (j : ℕ) (hji : j < i), ¬p (xs.get ⟨j, ⋯⟩) = true
h1 : p (xs.get ⟨i, h⟩) = true
h2 : ∀ (j : ℕ) (hji : j < i), ¬p (xs.get ⟨j, ⋯⟩) = true
⊢ findIdx p xs = i
tactic: refine ⟨fun f ↦ ⟨f ▸ (@findIdx_get _ p xs (f ▸ h)), fun _ hji ↦ not_of_lt_findIdx (f ▸ hji)⟩,
    fun ⟨h1, h2⟩ ↦ ?_⟩
state_before: α : Type u
β : Type v
p : α → Bool
xs : List α
i : ℕ
h : i < xs.length
x✝ : p (xs.get ⟨i, h⟩) = true ∧ ∀ (j : ℕ) (hji : j < i), ¬p (xs.get ⟨j, ⋯⟩) = true
h1 : p (xs.get ⟨i, h⟩) = true
h2 : ∀ (j : ℕ) (hji : j < i), ¬p (xs.get ⟨j, ⋯⟩) = true
⊢ findIdx p xs = i
state_after: α : Type u
β : Type v
p : α → Bool
xs : List α
i : ℕ
h : i < xs.length
x✝ : p (xs.get ⟨i, h⟩) = true ∧ ∀ (j : ℕ) (hji : j < i), ¬p (xs.get ⟨j, ⋯⟩) = true
h1 : p (xs.get ⟨i, h⟩) = true
h2 : ∀ (j : ℕ) (hji : j < i), ¬p (xs.get ⟨j, ⋯⟩) = true
⊢ findIdx p xs ≤ i
tactic: apply Nat.le_antisymm _ (le_findIdx_of_not h h2)
state_before: α : Type u
β : Type v
p : α → Bool
xs : List α
i : ℕ
h : i < xs.length
x✝ : p (xs.get ⟨i, h⟩) = true ∧ ∀ (j : ℕ) (hji : j < i), ¬p (xs.get ⟨j, ⋯⟩) = true
h1 : p (xs.get ⟨i, h⟩) = true
h2 : ∀ (j : ℕ) (hji : j < i), ¬p (xs.get ⟨j, ⋯⟩) = true
⊢ findIdx p xs ≤ i
state_after: α : Type u
β : Type v
p : α → Bool
xs : List α
i : ℕ
h : i < xs.length
x✝ : p (xs.get ⟨i, h⟩) = true ∧ ∀ (j : ℕ) (hji : j < i), ¬p (xs.get ⟨j, ⋯⟩) = true
h2 : ∀ (j : ℕ) (hji : j < i), ¬p (xs.get ⟨j, ⋯⟩) = true
h1 : i < findIdx p xs
⊢ p (xs.get ⟨i, h⟩) ≠ true
tactic: contrapose! h1
state_before: α : Type u
β : Type v
p : α → Bool
xs : List α
i : ℕ
h : i < xs.length
x✝ : p (xs.get ⟨i, h⟩) = true ∧ ∀ (j : ℕ) (hji : j < i), ¬p (xs.get ⟨j, ⋯⟩) = true
h2 : ∀ (j : ℕ) (hji : j < i), ¬p (xs.get ⟨j, ⋯⟩) = true
h1 : i < findIdx p xs
⊢ p (xs.get ⟨i, h⟩) ≠ true
state_after: no goals
tactic: exact not_of_lt_findIdx h1
Theorem: Inducing.isClosed_iff'
File: Mathlib/Topology/Maps/Basic.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
ι : Type u_4
f : X → Y
g : Y → Z
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
hf : Inducing f
s : Set X
⊢ IsClosed s ↔ ∀ (x : X), f x ∈ closure (f '' s) → x ∈ s
state_after: no goals
tactic: rw [hf.induced, isClosed_induced_iff']
Theorem: intrinsicInterior_singleton
File: Mathlib/Analysis/Convex/Intrinsic.lean

Proof steps:
state_before: 𝕜 : Type u_1
V : Type u_2
W : Type u_3
Q : Type u_4
P : Type u_5
inst✝⁴ : Ring 𝕜
inst✝³ : AddCommGroup V
inst✝² : Module 𝕜 V
inst✝¹ : TopologicalSpace P
inst✝ : AddTorsor V P
s t : Set P
x✝ x : P
⊢ intrinsicInterior 𝕜 {x} = {x}
state_after: no goals
tactic: simpa only [intrinsicInterior, preimage_coe_affineSpan_singleton, interior_univ, image_univ,
    Subtype.range_coe] using coe_affineSpan_singleton _ _ _
Theorem: ne_one_of_nnnorm_ne_zero
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✝³ : SeminormedGroup E
inst✝² : SeminormedGroup F
inst✝¹ : SeminormedGroup G
s : Set E
a✝ a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
inst✝ : FunLike 𝓕 E F
a : E
⊢ a = 1 → ‖a‖₊ = 0
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✝³ : SeminormedGroup E
inst✝² : SeminormedGroup F
inst✝¹ : SeminormedGroup G
s : Set E
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
inst✝ : FunLike 𝓕 E F
⊢ ‖1‖₊ = 0
tactic: rintro rfl
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✝³ : SeminormedGroup E
inst✝² : SeminormedGroup F
inst✝¹ : SeminormedGroup G
s : Set E
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
inst✝ : FunLike 𝓕 E F
⊢ ‖1‖₊ = 0
state_after: no goals
tactic: exact nnnorm_one'
Theorem: Set.finite_prod
File: Mathlib/Data/Set/Finite.lean

Proof steps:
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s : Set α
t : Set β
⊢ (s ×ˢ t).Finite ↔ (s.Finite ∨ t = ∅) ∧ (t.Finite ∨ s = ∅)
state_after: no goals
tactic: simp only [← not_infinite, Set.infinite_prod, not_or, not_and_or, not_nonempty_iff_eq_empty]
Theorem: Filter.tendsto_iff_rtendsto'
File: Mathlib/Order/Filter/Partial.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
l₁ : Filter α
l₂ : Filter β
f : α → β
⊢ Tendsto f l₁ l₂ ↔ RTendsto' (Function.graph f) l₁ l₂
state_after: no goals
tactic: simp [tendsto_def, Function.graph, rtendsto'_def, Rel.preimage_def, Set.preimage]
Theorem: Cardinal.lift_two
File: Mathlib/SetTheory/Cardinal/Basic.lean

Proof steps:
state_before: α β : Type u
⊢ lift.{u, v} 2 = 2
state_after: no goals
tactic: simp [← one_add_one_eq_two]
Theorem: Real.Angle.two_nsmul_eq_zero_iff
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

Proof steps:
state_before: θ : Angle
⊢ 2 • θ = 0 ↔ θ = 0 ∨ θ = ↑π
state_after: no goals
tactic: convert two_nsmul_eq_iff <;> simp
Theorem: Lagrange.sum_nodalWeight_mul_inv_sub_ne_zero
File: Mathlib/LinearAlgebra/Lagrange.lean

Proof steps:
state_before: F : Type u_1
inst✝¹ : Field F
ι : Type u_2
inst✝ : DecidableEq ι
s : Finset ι
v r : ι → F
i : ι
x : F
hvs : Set.InjOn v ↑s
hx : ∀ i ∈ s, x ≠ v i
hs : s.Nonempty
⊢ eval x (nodal s v) * ∑ i ∈ s, nodalWeight s v i * (x - v i)⁻¹ = 1
state_after: no goals
tactic: simpa only [Pi.one_apply, interpolate_one hvs hs, eval_one, mul_one] using
      (eval_interpolate_not_at_node 1 hx).symm
Theorem: pi_norm_le_iff_of_nonempty'
File: Mathlib/Analysis/Normed/Group/Constructions.lean

Proof steps:
state_before: ι : Type u_1
E : Type u_2
F : Type u_3
π : ι → Type u_4
inst✝³ : Fintype ι
inst✝² : (i : ι) → SeminormedGroup (π i)
inst✝¹ : SeminormedGroup E
f x : (i : ι) → π i
r : ℝ
inst✝ : Nonempty ι
⊢ ‖f‖ ≤ r ↔ ∀ (b : ι), ‖f b‖ ≤ r
state_after: case pos
ι : Type u_1
E : Type u_2
F : Type u_3
π : ι → Type u_4
inst✝³ : Fintype ι
inst✝² : (i : ι) → SeminormedGroup (π i)
inst✝¹ : SeminormedGroup E
f x : (i : ι) → π i
r : ℝ
inst✝ : Nonempty ι
hr : 0 ≤ r
⊢ ‖f‖ ≤ r ↔ ∀ (b : ι), ‖f b‖ ≤ r

case neg
ι : Type u_1
E : Type u_2
F : Type u_3
π : ι → Type u_4
inst✝³ : Fintype ι
inst✝² : (i : ι) → SeminormedGroup (π i)
inst✝¹ : SeminormedGroup E
f x : (i : ι) → π i
r : ℝ
inst✝ : Nonempty ι
hr : ¬0 ≤ r
⊢ ‖f‖ ≤ r ↔ ∀ (b : ι), ‖f b‖ ≤ r
tactic: by_cases hr : 0 ≤ r
Theorem: CategoryTheory.ShortComplex.RightHomologyData.ofIsLimitKernelFork_ι
File: Mathlib/Algebra/Homology/ShortComplex/RightHomology.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{?u.19876, u_1} C
inst✝ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
h : S.RightHomologyData
A : C
hf : S.f = 0
c : KernelFork S.g
hc : IsLimit c
⊢ S.f ≫ 𝟙 S.X₂ = 0
state_after: no goals
tactic: rw [comp_id, hf]
state_before: C : Type u_1
inst✝¹ : Category.{?u.19876, u_1} C
inst✝ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
h : S.RightHomologyData
A : C
hf : S.f = 0
c : KernelFork S.g
hc : IsLimit c
⊢ (Iso.refl c.pt).hom ≫ Fork.ι (KernelFork.ofι (Fork.ι c) ⋯) = Fork.ι c
state_after: no goals
tactic: aesop_cat
Theorem: le_mul_self
File: Mathlib/Algebra/Order/Monoid/Canonical/Defs.lean

Proof steps:
state_before: α : Type u
inst✝ : CanonicallyOrderedCommMonoid α
a b c d : α
⊢ a ≤ b * a
state_after: α : Type u
inst✝ : CanonicallyOrderedCommMonoid α
a b c d : α
⊢ a ≤ a * b
tactic: rw [mul_comm]
state_before: α : Type u
inst✝ : CanonicallyOrderedCommMonoid α
a b c d : α
⊢ a ≤ a * b
state_after: no goals
tactic: exact le_self_mul
Theorem: Orientation.oangle_sub_left_eq_arccos_of_oangle_eq_pi_div_two
File: Mathlib/Geometry/Euclidean/Angle/Oriented/RightAngle.lean

Proof steps:
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
hd2 : Fact (finrank ℝ V = 2)
o : Orientation ℝ V (Fin 2)
x y : V
h : o.oangle x y = ↑(π / 2)
⊢ o.oangle (x - y) x = ↑(Real.arccos (‖x‖ / ‖x - y‖))
state_after: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
hd2 : Fact (finrank ℝ V = 2)
o : Orientation ℝ V (Fin 2)
x y : V
h : (-o).oangle y x = ↑(π / 2)
⊢ (-o).oangle x (x - y) = ↑(Real.arccos (‖x‖ / ‖x - y‖))
tactic: rw [← neg_inj, oangle_rev, ← oangle_neg_orientation_eq_neg, neg_inj] at h ⊢
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
hd2 : Fact (finrank ℝ V = 2)
o : Orientation ℝ V (Fin 2)
x y : V
h : (-o).oangle y x = ↑(π / 2)
⊢ (-o).oangle x (x - y) = ↑(Real.arccos (‖x‖ / ‖x - y‖))
state_after: no goals
tactic: exact (-o).oangle_sub_right_eq_arccos_of_oangle_eq_pi_div_two h
Theorem: qrSign.neg_one_pow
File: Mathlib/NumberTheory/LegendreSymbol/JacobiSymbol.lean

Proof steps:
state_before: m n : ℕ
hm : Odd m
hn : Odd n
⊢ qrSign m n = (-1) ^ (m / 2 * (n / 2))
state_after: m n : ℕ
hm : Odd m
hn : Odd n
⊢ J(χ₄ ↑m | n) = χ₄ ↑m ^ (n / 2)
tactic: rw [qrSign, pow_mul, ← χ₄_eq_neg_one_pow (odd_iff.mp hm)]
state_before: m n : ℕ
hm : Odd m
hn : Odd n
⊢ J(χ₄ ↑m | n) = χ₄ ↑m ^ (n / 2)
state_after: case inl
m n : ℕ
hm : Odd m
hn : Odd n
h : m % 4 = 1
⊢ J(χ₄ ↑m | n) = χ₄ ↑m ^ (n / 2)

case inr
m n : ℕ
hm : Odd m
hn : Odd n
h : m % 4 = 3
⊢ J(χ₄ ↑m | n) = χ₄ ↑m ^ (n / 2)
tactic: cases' odd_mod_four_iff.mp (odd_iff.mp hm) with h h
Theorem: CommRingCat.Colimits.quot_neg
File: Mathlib/Algebra/Category/Ring/Colimits.lean

Proof steps:
state_before: J : Type v
inst✝ : SmallCategory J
F : J ⥤ CommRingCat
x : Prequotient F
⊢ ColimitType F
state_after: no goals
tactic: exact Quot.mk Setoid.r (neg x)
state_before: J : Type v
inst✝ : SmallCategory J
F : J ⥤ CommRingCat
x : Prequotient F
⊢ ColimitType F
state_after: no goals
tactic: exact Quot.mk Setoid.r x
Theorem: LinearEquiv.coord_self
File: Mathlib/LinearAlgebra/Span.lean

Proof steps:
state_before: R : Type u_1
R₂ : Type u_2
K : Type u_3
M : Type u_4
M₂ : Type u_5
V : Type u_6
S : Type u_7
inst✝³ : Ring R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : NoZeroSMulDivisors R M
x : M
h : x ≠ 0
⊢ (coord R M x h) ⟨x, ⋯⟩ = 1
state_after: no goals
tactic: rw [← toSpanNonzeroSingleton_one R M x h, LinearEquiv.symm_apply_apply]
Theorem: IsAdjoinRoot.apply_eq_lift
File: Mathlib/RingTheory/IsAdjoinRoot.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝³ : CommRing R
inst✝² : Ring S
f : R[X]
inst✝¹ : Algebra R S
T : Type u_1
inst✝ : CommRing T
i : R →+* T
x : T
hx : eval₂ i x f = 0
h : IsAdjoinRoot S f
g : S →+* T
hmap : ∀ (a : R), g ((algebraMap R S) a) = i a
hroot : g h.root = x
a : S
⊢ g a = (lift i x hx h) a
state_after: R : Type u
S : Type v
inst✝³ : CommRing R
inst✝² : Ring S
f : R[X]
inst✝¹ : Algebra R S
T : Type u_1
inst✝ : CommRing T
i : R →+* T
x : T
hx : eval₂ i x f = 0
h : IsAdjoinRoot S f
g : S →+* T
hmap : ∀ (a : R), g ((algebraMap R S) a) = i a
hroot : g h.root = x
a : S
⊢ g (h.map (∑ i ∈ Finset.range ((h.repr a).natDegree + 1), C ((h.repr a).coeff i) * X ^ i)) =
    (lift i x hx h) (h.map (∑ i ∈ Finset.range ((h.repr a).natDegree + 1), C ((h.repr a).coeff i) * X ^ i))
tactic: rw [← h.map_repr a, Polynomial.as_sum_range_C_mul_X_pow (h.repr a)]
state_before: R : Type u
S : Type v
inst✝³ : CommRing R
inst✝² : Ring S
f : R[X]
inst✝¹ : Algebra R S
T : Type u_1
inst✝ : CommRing T
i : R →+* T
x : T
hx : eval₂ i x f = 0
h : IsAdjoinRoot S f
g : S →+* T
hmap : ∀ (a : R), g ((algebraMap R S) a) = i a
hroot : g h.root = x
a : S
⊢ g (h.map (∑ i ∈ Finset.range ((h.repr a).natDegree + 1), C ((h.repr a).coeff i) * X ^ i)) =
    (lift i x hx h) (h.map (∑ i ∈ Finset.range ((h.repr a).natDegree + 1), C ((h.repr a).coeff i) * X ^ i))
state_after: no goals
tactic: simp only [map_sum, map_mul, map_pow, h.map_X, hroot, ← h.algebraMap_apply, hmap, lift_root,
    lift_algebraMap]
Theorem: Rat.sqrt_intCast
File: Mathlib/Data/Rat/Sqrt.lean

Proof steps:
state_before: z : ℤ
⊢ sqrt ↑z = ↑(Int.sqrt z)
state_after: no goals
tactic: simp only [sqrt, num_intCast, den_intCast, Nat.sqrt_one, mkRat_one]
Theorem: Polynomial.eraseLead_X_pow
File: Mathlib/Algebra/Polynomial/EraseLead.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Semiring R
f : R[X]
n : ℕ
⊢ (X ^ n).eraseLead = 0
state_after: no goals
tactic: rw [X_pow_eq_monomial, eraseLead_monomial]
Theorem: Combinatorics.Subspace.reindex_apply
File: Mathlib/Combinatorics/HalesJewett.lean

Proof steps:
state_before: η✝ : Type u_1
α✝ : Type u_2
ι✝ : Type u_3
κ✝ : Type u_4
η : Type u_5
α : Type u_6
ι : Type u_7
κ : Type u_8
l✝ : Subspace η α ι
x✝ : η → α
i✝ : ι
a : α
e : η
η' : Type u_9
α' : Type u_10
ι' : Type u_11
l : Subspace η α ι
eη : η ≃ η'
eα : α ≃ α'
eι : ι ≃ ι'
x : η' → α'
i : ι'
⊢ ↑(l.reindex eη eα eι) x i = eα (↑l (⇑eα.symm ∘ x ∘ ⇑eη) (eι.symm i))
state_after: no goals
tactic: cases h : l.idxFun (eι.symm i) <;> simp [h, reindex, coe_apply]
Theorem: MeasureTheory.ProbabilityMeasure.prod_apply
File: Mathlib/MeasureTheory/Measure/FiniteMeasureProd.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : MeasurableSpace α
β : Type u_2
inst✝ : MeasurableSpace β
μ : ProbabilityMeasure α
ν : ProbabilityMeasure β
s : Set (α × β)
s_mble : MeasurableSet s
⊢ (μ.prod ν) s = (∫⁻ (x : α), ↑ν (Prod.mk x ⁻¹' s) ∂↑μ).toNNReal
state_after: no goals
tactic: simp [coeFn_def, Measure.prod_apply s_mble]
Theorem: List.leftpad_suffix
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: α : Type u_1
n : Nat
a : α
l : List α
⊢ l <:+ leftpad n a l
state_after: α : Type u_1
n : Nat
a : α
l : List α
⊢ ∃ t, t ++ l = replicate (n - l.length) a ++ l
tactic: simp only [IsSuffix, leftpad]
state_before: α : Type u_1
n : Nat
a : α
l : List α
⊢ ∃ t, t ++ l = replicate (n - l.length) a ++ l
state_after: no goals
tactic: exact Exists.intro (replicate (n - length l) a) rfl
Theorem: AddSubgroup.mem_normalizer_iff''
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
g : G
⊢ g ∈ H.normalizer ↔ ∀ (h : G), h ∈ H ↔ g⁻¹ * h * g ∈ H
state_after: no goals
tactic: rw [← inv_mem_iff (x := g), mem_normalizer_iff, inv_inv]
Theorem: DFinsupp.erase_add
File: Mathlib/Data/DFinsupp/Basic.lean

Proof steps:
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → AddZeroClass (β i)
i : ι
f₁ f₂ : Π₀ (i : ι), β i
x✝ : ι
⊢ (erase i (f₁ + f₂)) x✝ = (erase i f₁ + erase i f₂) x✝
state_after: no goals
tactic: simp [ite_zero_add]
Theorem: Set.directedOn_iUnion
File: Mathlib/Data/Set/Lattice.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
r : α → α → Prop
f : ι → Set α
hd : Directed (fun x x_1 => x ⊆ x_1) f
h : ∀ (x : ι), DirectedOn r (f x)
⊢ DirectedOn r (⋃ x, f x)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
r : α → α → Prop
f : ι → Set α
hd : Directed (fun x x_1 => x ⊆ x_1) f
h : ∀ (x : ι), DirectedOn r (f x)
⊢ ∀ (x : α) (x_1 : ι), x ∈ f x_1 → ∀ (y : α) (x_2 : ι), y ∈ f x_2 → ∃ z, (∃ i, z ∈ f i) ∧ r x z ∧ r y z
tactic: simp only [DirectedOn, exists_prop, mem_iUnion, exists_imp]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
r : α → α → Prop
f : ι → Set α
hd : Directed (fun x x_1 => x ⊆ x_1) f
h : ∀ (x : ι), DirectedOn r (f x)
⊢ ∀ (x : α) (x_1 : ι), x ∈ f x_1 → ∀ (y : α) (x_2 : ι), y ∈ f x_2 → ∃ z, (∃ i, z ∈ f i) ∧ r x z ∧ r y z
state_after: no goals
tactic: exact fun a₁ b₁ fb₁ a₂ b₂ fb₂ =>
    let ⟨z, zb₁, zb₂⟩ := hd b₁ b₂
    let ⟨x, xf, xa₁, xa₂⟩ := h z a₁ (zb₁ fb₁) a₂ (zb₂ fb₂)
    ⟨x, ⟨z, xf⟩, xa₁, xa₂⟩
Theorem: sup_lt_of_lt_sdiff_right
File: Mathlib/Order/BooleanAlgebra.lean

Proof steps:
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
h : x < z \ y
hyz : y ≤ z
⊢ x ⊔ y < z
state_after: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
h : x < z \ y
hyz : y ≤ z
⊢ x ⊔ y < z \ y ⊔ y
tactic: rw [← sdiff_sup_cancel hyz]
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
h : x < z \ y
hyz : y ≤ z
⊢ x ⊔ y < z \ y ⊔ y
state_after: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
h : x < z \ y
hyz : y ≤ z
h' : z \ y ⊔ y ≤ x ⊔ y
⊢ z \ y ≤ x
tactic: refine (sup_le_sup_right h.le _).lt_of_not_le fun h' => h.not_le ?_
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
h : x < z \ y
hyz : y ≤ z
h' : z \ y ⊔ y ≤ x ⊔ y
⊢ z \ y ≤ x
state_after: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
h : x < z \ y
hyz : y ≤ z
h' : z \ y ⊔ y ≤ x ⊔ y
⊢ (z \ y) \ y ≤ x
tactic: rw [← sdiff_idem]
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
h : x < z \ y
hyz : y ≤ z
h' : z \ y ⊔ y ≤ x ⊔ y
⊢ (z \ y) \ y ≤ x
state_after: no goals
tactic: exact (sdiff_le_sdiff_of_sup_le_sup_right h').trans sdiff_le
Theorem: Finset.centerMass_empty
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
⊢ ∅.centerMass w z = 0
state_after: no goals
tactic: simp only [centerMass, sum_empty, smul_zero]
Theorem: Set.comp_rangeSplitting
File: Mathlib/Data/Set/Defs.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
f : α → β
⊢ f ∘ rangeSplitting f = Subtype.val
state_after: case h
α : Type u
β : Type v
γ : Type w
f : α → β
x✝ : ↑(range f)
⊢ (f ∘ rangeSplitting f) x✝ = ↑x✝
tactic: ext
state_before: case h
α : Type u
β : Type v
γ : Type w
f : α → β
x✝ : ↑(range f)
⊢ (f ∘ rangeSplitting f) x✝ = ↑x✝
state_after: case h
α : Type u
β : Type v
γ : Type w
f : α → β
x✝ : ↑(range f)
⊢ f (rangeSplitting f x✝) = ↑x✝
tactic: simp only [Function.comp_apply]
state_before: case h
α : Type u
β : Type v
γ : Type w
f : α → β
x✝ : ↑(range f)
⊢ f (rangeSplitting f x✝) = ↑x✝
state_after: no goals
tactic: apply apply_rangeSplitting
Theorem: IsAddGroupHom.neg_ker_zero
File: Mathlib/Deprecated/Subgroup.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a✝ a₁ a₂ b✝ c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
a b : G
h : f a = f b
⊢ f (a * b⁻¹) = 1
state_after: G : Type u_1
H : Type u_2
A : Type u_3
a✝ a₁ a₂ b✝ c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
a b : G
h : f a = f b
this : f a * (f b)⁻¹ = 1
⊢ f (a * b⁻¹) = 1
tactic: have : f a * (f b)⁻¹ = 1 := by rw [h, mul_right_inv]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a✝ a₁ a₂ b✝ c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
a b : G
h : f a = f b
this : f a * (f b)⁻¹ = 1
⊢ f (a * b⁻¹) = 1
state_after: no goals
tactic: rwa [← hf.map_inv, ← hf.map_mul] at this
Theorem: AlgHom.mem_resolventSet_apply
File: Mathlib/Algebra/Algebra/Spectrum.lean

Proof steps:
state_before: F : Type u_1
R : Type u_2
A : Type u_3
B : Type u_4
inst✝⁶ : CommSemiring R
inst✝⁵ : Ring A
inst✝⁴ : Algebra R A
inst✝³ : Ring B
inst✝² : Algebra R B
inst✝¹ : FunLike F A B
inst✝ : AlgHomClass F R A B
φ : F
a : A
r : R
h : r ∈ resolventSet R a
⊢ r ∈ resolventSet R (φ a)
state_after: no goals
tactic: simpa only [map_sub, AlgHomClass.commutes] using h.map φ