ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: MulAction.aestabilizer_congr
File: Mathlib/MeasureTheory/Group/AEStabilizer.lean

Proof steps:
state_before: G : Type u_1
α : Type u_2
inst✝² : Group G
inst✝¹ : MulAction G α
x✝ : MeasurableSpace α
μ : Measure α
inst✝ : SMulInvariantMeasure G α μ
g : G
s t : Set α
h : s =ᶠ[ae μ] t
⊢ aestabilizer G μ s = aestabilizer G μ t
state_after: case h
G : Type u_1
α : Type u_2
inst✝² : Group G
inst✝¹ : MulAction G α
x✝ : MeasurableSpace α
μ : Measure α
inst✝ : SMulInvariantMeasure G α μ
g✝ : G
s t : Set α
h : s =ᶠ[ae μ] t
g : G
⊢ g ∈ aestabilizer G μ s ↔ g ∈ aestabilizer G μ t
tactic: ext g
state_before: case h
G : Type u_1
α : Type u_2
inst✝² : Group G
inst✝¹ : MulAction G α
x✝ : MeasurableSpace α
μ : Measure α
inst✝ : SMulInvariantMeasure G α μ
g✝ : G
s t : Set α
h : s =ᶠ[ae μ] t
g : G
⊢ g ∈ aestabilizer G μ s ↔ g ∈ aestabilizer G μ t
state_after: no goals
tactic: rw [mem_aestabilizer, mem_aestabilizer, h.congr_right, ((smul_set_ae_eq g).2 h).congr_left]
Theorem: WeierstrassCurve.Jacobian.addY_smul
File: Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean

Proof steps:
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P Q : Fin 3 → R
u v : R
⊢ W'.addY (u • P) (v • Q) = ((u * v) ^ 2) ^ 3 * W'.addY P Q
state_after: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P Q : Fin 3 → R
u v : R
⊢ -(((u * v) ^ 2) ^ 3 * W'.negAddY P Q) - W'.a₁ * (((u * v) ^ 2) ^ 2 * W'.addX P Q) * ((u * v) ^ 2 * addZ P Q) -
      W'.a₃ * ((u * v) ^ 2 * addZ P Q) ^ 3 =
    ((u * v) ^ 2) ^ 3 * (-W'.negAddY P Q - W'.a₁ * W'.addX P Q * addZ P Q - W'.a₃ * addZ P Q ^ 3)
tactic: simp only [addY, negY, addX_smul, negAddY_smul, addZ_smul, fin3_def_ext]
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P Q : Fin 3 → R
u v : R
⊢ -(((u * v) ^ 2) ^ 3 * W'.negAddY P Q) - W'.a₁ * (((u * v) ^ 2) ^ 2 * W'.addX P Q) * ((u * v) ^ 2 * addZ P Q) -
      W'.a₃ * ((u * v) ^ 2 * addZ P Q) ^ 3 =
    ((u * v) ^ 2) ^ 3 * (-W'.negAddY P Q - W'.a₁ * W'.addX P Q * addZ P Q - W'.a₃ * addZ P Q ^ 3)
state_after: no goals
tactic: ring1
Theorem: Finset.sym2_insert
File: Mathlib/Data/Finset/Sym.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
s✝ t : Finset α
a✝ b : α
inst✝ : DecidableEq α
a : α
s : Finset α
⊢ (insert a s).sym2 = image (fun b => s(a, b)) (insert a s) ∪ s.sym2
state_after: case inl
α : Type u_1
β : Type u_2
s✝ t : Finset α
a✝ b : α
inst✝ : DecidableEq α
a : α
s : Finset α
ha : a ∈ s
⊢ (insert a s).sym2 = image (fun b => s(a, b)) (insert a s) ∪ s.sym2

case inr
α : Type u_1
β : Type u_2
s✝ t : Finset α
a✝ b : α
inst✝ : DecidableEq α
a : α
s : Finset α
ha : a ∉ s
⊢ (insert a s).sym2 = image (fun b => s(a, b)) (insert a s) ∪ s.sym2
tactic: obtain ha | ha := Decidable.em (a ∈ s)
Theorem: CliffordAlgebraQuaternion.quaternionBasis_j
File: Mathlib/LinearAlgebra/CliffordAlgebra/Equivs.lean

Proof steps:
state_before: R : Type u_1
inst✝ : CommRing R
c₁ c₂ : R
⊢ (ι (Q c₁ c₂)) (1, 0) * (ι (Q c₁ c₂)) (1, 0) = c₁ • 1
state_after: R : Type u_1
inst✝ : CommRing R
c₁ c₂ : R
⊢ (algebraMap R (CliffordAlgebra (Q c₁ c₂))) (c₁ * ((1, 0).1 * (1, 0).1) + c₂ * ((1, 0).2 * (1, 0).2)) =
    (algebraMap R (CliffordAlgebra (Q c₁ c₂))) c₁
tactic: rw [ι_sq_scalar, Q_apply, ← Algebra.algebraMap_eq_smul_one]
state_before: R : Type u_1
inst✝ : CommRing R
c₁ c₂ : R
⊢ (algebraMap R (CliffordAlgebra (Q c₁ c₂))) (c₁ * ((1, 0).1 * (1, 0).1) + c₂ * ((1, 0).2 * (1, 0).2)) =
    (algebraMap R (CliffordAlgebra (Q c₁ c₂))) c₁
state_after: no goals
tactic: simp
state_before: R : Type u_1
inst✝ : CommRing R
c₁ c₂ : R
⊢ (ι (Q c₁ c₂)) (0, 1) * (ι (Q c₁ c₂)) (0, 1) = c₂ • 1
state_after: R : Type u_1
inst✝ : CommRing R
c₁ c₂ : R
⊢ (algebraMap R (CliffordAlgebra (Q c₁ c₂))) (c₁ * ((0, 1).1 * (0, 1).1) + c₂ * ((0, 1).2 * (0, 1).2)) =
    (algebraMap R (CliffordAlgebra (Q c₁ c₂))) c₂
tactic: rw [ι_sq_scalar, Q_apply, ← Algebra.algebraMap_eq_smul_one]
state_before: R : Type u_1
inst✝ : CommRing R
c₁ c₂ : R
⊢ (algebraMap R (CliffordAlgebra (Q c₁ c₂))) (c₁ * ((0, 1).1 * (0, 1).1) + c₂ * ((0, 1).2 * (0, 1).2)) =
    (algebraMap R (CliffordAlgebra (Q c₁ c₂))) c₂
state_after: no goals
tactic: simp
state_before: R : Type u_1
inst✝ : CommRing R
c₁ c₂ : R
⊢ (ι (Q c₁ c₂)) (0, 1) * (ι (Q c₁ c₂)) (1, 0) = -((ι (Q c₁ c₂)) (1, 0) * (ι (Q c₁ c₂)) (0, 1))
state_after: R : Type u_1
inst✝ : CommRing R
c₁ c₂ : R
⊢ (algebraMap R (CliffordAlgebra (Q c₁ c₂))) ((Q c₁ c₂) ((0, 1) + (1, 0)) - (Q c₁ c₂) (0, 1) - (Q c₁ c₂) (1, 0)) = 0
tactic: rw [eq_neg_iff_add_eq_zero, ι_mul_ι_add_swap, QuadraticMap.polar]
state_before: R : Type u_1
inst✝ : CommRing R
c₁ c₂ : R
⊢ (algebraMap R (CliffordAlgebra (Q c₁ c₂))) ((Q c₁ c₂) ((0, 1) + (1, 0)) - (Q c₁ c₂) (0, 1) - (Q c₁ c₂) (1, 0)) = 0
state_after: no goals
tactic: simp
Theorem: Complex.hasSum_cosh
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Series.lean

Proof steps:
state_before: z : ℂ
⊢ HasSum (fun n => z ^ (2 * n) / ↑(2 * n)!) (cosh z)
state_after: no goals
tactic: simpa [mul_assoc, cos_mul_I] using hasSum_cos' (z * I)
Theorem: Tuple.bubble_sort_induction'
File: Mathlib/Data/Fin/Tuple/BubbleSortInduction.lean

Proof steps:
state_before: n : ℕ
α : Type u_1
inst✝ : LinearOrder α
f : Fin n → α
P : (Fin n → α) → Prop
hf : P f
h :
  ∀ (σ : Equiv.Perm (Fin n)) (i j : Fin n),
    i < j → (f ∘ ⇑σ) j < (f ∘ ⇑σ) i → P (f ∘ ⇑σ) → P (f ∘ ⇑σ ∘ ⇑(Equiv.swap i j))
⊢ P (f ∘ ⇑(sort f))
state_after: n : ℕ
α : Type u_1
inst✝ : LinearOrder α
f : Fin n → α
P : (Fin n → α) → Prop
hf : P f
h :
  ∀ (σ : Equiv.Perm (Fin n)) (i j : Fin n),
    i < j → (f ∘ ⇑σ) j < (f ∘ ⇑σ) i → P (f ∘ ⇑σ) → P (f ∘ ⇑σ ∘ ⇑(Equiv.swap i j))
this : Preorder (Equiv.Perm (Fin n)) := Preorder.lift fun σ => toLex (f ∘ ⇑σ)
⊢ P (f ∘ ⇑(sort f))
tactic: letI := @Preorder.lift _ (Lex (Fin n → α)) _ fun σ : Equiv.Perm (Fin n) => toLex (f ∘ σ)
state_before: n : ℕ
α : Type u_1
inst✝ : LinearOrder α
f : Fin n → α
P : (Fin n → α) → Prop
hf : P f
h :
  ∀ (σ : Equiv.Perm (Fin n)) (i j : Fin n),
    i < j → (f ∘ ⇑σ) j < (f ∘ ⇑σ) i → P (f ∘ ⇑σ) → P (f ∘ ⇑σ ∘ ⇑(Equiv.swap i j))
this : Preorder (Equiv.Perm (Fin n)) := Preorder.lift fun σ => toLex (f ∘ ⇑σ)
σ : Fin n ≃ Fin n
hσ : (fun σ => f ∘ ⇑σ) σ ≠ (fun σ => f ∘ ⇑σ) (sort f)
hfσ : P ((fun σ => f ∘ ⇑σ) σ)
⊢ ∃ c < σ, P ((fun σ => f ∘ ⇑σ) c)
state_after: case intro.intro.intro
n : ℕ
α : Type u_1
inst✝ : LinearOrder α
f : Fin n → α
P : (Fin n → α) → Prop
hf : P f
h :
  ∀ (σ : Equiv.Perm (Fin n)) (i j : Fin n),
    i < j → (f ∘ ⇑σ) j < (f ∘ ⇑σ) i → P (f ∘ ⇑σ) → P (f ∘ ⇑σ ∘ ⇑(Equiv.swap i j))
this : Preorder (Equiv.Perm (Fin n)) := Preorder.lift fun σ => toLex (f ∘ ⇑σ)
σ : Fin n ≃ Fin n
hσ : (fun σ => f ∘ ⇑σ) σ ≠ (fun σ => f ∘ ⇑σ) (sort f)
hfσ : P ((fun σ => f ∘ ⇑σ) σ)
i j : Fin n
hij₁ : i < j
hij₂ : (f ∘ ⇑σ) j < (f ∘ ⇑σ) i
⊢ ∃ c < σ, P ((fun σ => f ∘ ⇑σ) c)
tactic: obtain ⟨i, j, hij₁, hij₂⟩ := antitone_pair_of_not_sorted' hσ
state_before: case intro.intro.intro
n : ℕ
α : Type u_1
inst✝ : LinearOrder α
f : Fin n → α
P : (Fin n → α) → Prop
hf : P f
h :
  ∀ (σ : Equiv.Perm (Fin n)) (i j : Fin n),
    i < j → (f ∘ ⇑σ) j < (f ∘ ⇑σ) i → P (f ∘ ⇑σ) → P (f ∘ ⇑σ ∘ ⇑(Equiv.swap i j))
this : Preorder (Equiv.Perm (Fin n)) := Preorder.lift fun σ => toLex (f ∘ ⇑σ)
σ : Fin n ≃ Fin n
hσ : (fun σ => f ∘ ⇑σ) σ ≠ (fun σ => f ∘ ⇑σ) (sort f)
hfσ : P ((fun σ => f ∘ ⇑σ) σ)
i j : Fin n
hij₁ : i < j
hij₂ : (f ∘ ⇑σ) j < (f ∘ ⇑σ) i
⊢ ∃ c < σ, P ((fun σ => f ∘ ⇑σ) c)
state_after: no goals
tactic: exact ⟨σ * Equiv.swap i j, Pi.lex_desc hij₁.le hij₂, h σ i j hij₁ hij₂ hfσ⟩
Theorem: le_inv_iff_mul_le_one_right
File: Mathlib/Algebra/Order/Group/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u
inst✝² : Group α
inst✝¹ : LE α
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c : α
⊢ a * b ≤ b⁻¹ * b ↔ a * b ≤ 1
state_after: no goals
tactic: rw [inv_mul_self]
Theorem: AddGroup.covariant_swap_iff_contravariant_swap
File: Mathlib/Algebra/Order/Monoid/Unbundled/Defs.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
μ : M → N → N
r : N → N → Prop
inst✝¹ : CovariantClass M N μ r
inst✝ : Group N
⊢ Covariant N N (swap fun x x_1 => x * x_1) r ↔ Contravariant N N (swap fun x x_1 => x * x_1) r
state_after: case refine_1
M : Type u_1
N : Type u_2
μ : M → N → N
r : N → N → Prop
inst✝¹ : CovariantClass M N μ r
inst✝ : Group N
h : Covariant N N (swap fun x x_1 => x * x_1) r
a b c : N
bc : r (swap (fun x x_1 => x * x_1) a b) (swap (fun x x_1 => x * x_1) a c)
⊢ r b c

case refine_2
M : Type u_1
N : Type u_2
μ : M → N → N
r : N → N → Prop
inst✝¹ : CovariantClass M N μ r
inst✝ : Group N
h : Contravariant N N (swap fun x x_1 => x * x_1) r
a b c : N
bc : r b c
⊢ r (swap (fun x x_1 => x * x_1) a b) (swap (fun x x_1 => x * x_1) a c)
tactic: refine ⟨fun h a b c bc ↦ ?_, fun h a b c bc ↦ ?_⟩
Theorem: Polynomial.derivative_expand
File: Mathlib/Algebra/Polynomial/Expand.lean

Proof steps:
state_before: R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
p q : ℕ
f : R[X]
⊢ derivative ((expand R p) f) = (expand R p) (derivative f) * (↑p * X ^ (p - 1))
state_after: no goals
tactic: rw [coe_expand, derivative_eval₂_C, derivative_pow, C_eq_natCast, derivative_X, mul_one]
Theorem: map_mul_inv
File: Mathlib/Algebra/Group/Hom/Defs.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
H : Type u_8
F : Type u_9
inst✝⁶ : MulOneClass M
inst✝⁵ : MulOneClass N
inst✝⁴ : FunLike F M N
inst✝³ : FunLike F G H
inst✝² : Group G
inst✝¹ : DivisionMonoid H
inst✝ : MonoidHomClass F G H
f : F
a b : G
⊢ f (a * b⁻¹) = f a * (f b)⁻¹
state_after: no goals
tactic: rw [map_mul, map_inv]
Theorem: Real.deriv_arcsin
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/InverseDeriv.lean

Proof steps:
state_before: ⊢ deriv arcsin = fun x => 1 / √(1 - x ^ 2)
state_after: case h
x : ℝ
⊢ deriv arcsin x = 1 / √(1 - x ^ 2)
tactic: funext x
state_before: case h
x : ℝ
⊢ deriv arcsin x = 1 / √(1 - x ^ 2)
state_after: case pos
x : ℝ
h : x ≠ -1 ∧ x ≠ 1
⊢ deriv arcsin x = 1 / √(1 - x ^ 2)

case neg
x : ℝ
h : ¬(x ≠ -1 ∧ x ≠ 1)
⊢ deriv arcsin x = 1 / √(1 - x ^ 2)
tactic: by_cases h : x ≠ -1 ∧ x ≠ 1
Theorem: List.nil_bagInter
File: Mathlib/Data/List/Lattice.lean

Proof steps:
state_before: α : Type u_1
l✝ l₁ l₂ : List α
p : α → Prop
a : α
inst✝ : DecidableEq α
l : List α
⊢ [].bagInter l = []
state_after: no goals
tactic: cases l <;> rfl
Theorem: Submonoid.LocalizationMap.mul_inv_right
File: Mathlib/GroupTheory/MonoidLocalization/Basic.lean

Proof steps:
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type u_3
inst✝ : CommMonoid P
f : M →* N
h : ∀ (y : ↥S), IsUnit (f ↑y)
y : ↥S
w z : N
⊢ z = w * ↑((IsUnit.liftRight (f.restrict S) h) y)⁻¹ ↔ z * f ↑y = w
state_after: no goals
tactic: rw [eq_comm, mul_inv_left h, mul_comm, eq_comm]
Theorem: Set.ordConnectedProj_eq
File: Mathlib/Order/Interval/Set/OrdConnectedComponent.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrder α
s t : Set α
x✝ y✝ z : α
x y : ↑s
⊢ s.ordConnectedProj x = s.ordConnectedProj y ↔ [[↑x, ↑y]] ⊆ s
state_after: case mp
α : Type u_1
inst✝ : LinearOrder α
s t : Set α
x✝ y✝ z : α
x y : ↑s
h : s.ordConnectedProj x = s.ordConnectedProj y
⊢ [[↑x, ↑y]] ⊆ s

case mpr
α : Type u_1
inst✝ : LinearOrder α
s t : Set α
x✝ y✝ z : α
x y : ↑s
h : [[↑x, ↑y]] ⊆ s
⊢ s.ordConnectedProj x = s.ordConnectedProj y
tactic: constructor <;> intro h
Theorem: Surreal.bddBelow_of_small
File: Mathlib/SetTheory/Surreal/Basic.lean

Proof steps:
state_before: s : Set Surreal
inst✝ : Small.{u, u + 1} ↑s
⊢ BddBelow s
state_after: no goals
tactic: simpa using bddBelow_range_of_small (Subtype.val : s → Surreal.{u})
Theorem: isometry_iff_nndist_eq
File: Mathlib/Topology/MetricSpace/Isometry.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
f : α → β
⊢ Isometry f ↔ ∀ (x y : α), nndist (f x) (f y) = nndist x y
state_after: no goals
tactic: simp only [Isometry, edist_nndist, ENNReal.coe_inj]
Theorem: CategoryTheory.MorphismProperty.LeftFraction.Localization.homMk_eq
File: Mathlib/CategoryTheory/Localization/CalculusOfFractions.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝² : Category.{u_3, u_1} C
inst✝¹ : Category.{?u.96057, u_2} D
W : MorphismProperty C
inst✝ : W.HasLeftCalculusOfFractions
X Y : C
f : W.LeftFraction X Y
⊢ homMk f = f.map (Q W) ⋯
state_after: C : Type u_1
D : Type u_2
inst✝² : Category.{u_3, u_1} C
inst✝¹ : Category.{?u.96057, u_2} D
W : MorphismProperty C
inst✝ : W.HasLeftCalculusOfFractions
X Y : C
f : W.LeftFraction X Y
this : IsIso ((Q W).map f.s)
⊢ homMk f = f.map (Q W) ⋯
tactic: have := Localization.inverts (Q W) W f.s f.hs
state_before: C : Type u_1
D : Type u_2
inst✝² : Category.{u_3, u_1} C
inst✝¹ : Category.{?u.96057, u_2} D
W : MorphismProperty C
inst✝ : W.HasLeftCalculusOfFractions
X Y : C
f : W.LeftFraction X Y
this : IsIso ((Q W).map f.s)
⊢ homMk f = f.map (Q W) ⋯
state_after: no goals
tactic: rw [← Q_map_comp_Qinv f.f f.s f.hs, ← cancel_mono ((Q W).map f.s),
    assoc, Qiso_inv_hom_id, comp_id, map_comp_map_s]
Theorem: tendsto_nhds_Prop
File: Mathlib/Topology/Order.lean

Proof steps:
state_before: α : Type u_1
inst✝ : TopologicalSpace α
l : Filter α
p : α → Prop
q : Prop
⊢ Tendsto p l (𝓝 q) ↔ q → ∀ᶠ (x : α) in l, p x
state_after: no goals
tactic: by_cases q <;> simp [*]
Theorem: PiNat.iUnion_cylinder_update
File: Mathlib/Topology/MetricSpace/PiNat.lean

Proof steps:
state_before: E : ℕ → Type u_1
x : (n : ℕ) → E n
n : ℕ
⊢ ⋃ k, cylinder (update x n k) (n + 1) = cylinder x n
state_after: case h
E : ℕ → Type u_1
x : (n : ℕ) → E n
n : ℕ
y : (n : ℕ) → E n
⊢ y ∈ ⋃ k, cylinder (update x n k) (n + 1) ↔ y ∈ cylinder x n
tactic: ext y
state_before: case h
E : ℕ → Type u_1
x : (n : ℕ) → E n
n : ℕ
y : (n : ℕ) → E n
⊢ y ∈ ⋃ k, cylinder (update x n k) (n + 1) ↔ y ∈ cylinder x n
state_after: case h
E : ℕ → Type u_1
x : (n : ℕ) → E n
n : ℕ
y : (n : ℕ) → E n
⊢ (∃ i, ∀ i_1 < n + 1, y i_1 = update x n i i_1) ↔ ∀ i < n, y i = x i
tactic: simp only [mem_cylinder_iff, mem_iUnion]
state_before: case h
E : ℕ → Type u_1
x : (n : ℕ) → E n
n : ℕ
y : (n : ℕ) → E n
⊢ (∃ i, ∀ i_1 < n + 1, y i_1 = update x n i i_1) ↔ ∀ i < n, y i = x i
state_after: case h.mp
E : ℕ → Type u_1
x : (n : ℕ) → E n
n : ℕ
y : (n : ℕ) → E n
⊢ (∃ i, ∀ i_1 < n + 1, y i_1 = update x n i i_1) → ∀ i < n, y i = x i

case h.mpr
E : ℕ → Type u_1
x : (n : ℕ) → E n
n : ℕ
y : (n : ℕ) → E n
⊢ (∀ i < n, y i = x i) → ∃ i, ∀ i_1 < n + 1, y i_1 = update x n i i_1
tactic: constructor
Theorem: CategoryTheory.ComposableArrows.homMk_app
File: Mathlib/CategoryTheory/ComposableArrows.lean

Proof steps:
state_before: C : Type u_1
inst✝ : Category.{?u.16313, u_1} C
n m : ℕ
F✝ G✝ F G : ComposableArrows C n
app : (i : Fin (n + 1)) → F.obj i ⟶ G.obj i
w : ∀ (i : ℕ) (hi : i < n), F.map' i (i + 1) ⋯ hi ≫ app ⟨i + 1, ⋯⟩ = app ⟨i, ⋯⟩ ≫ G.map' i (i + 1) ⋯ hi
⊢ ∀ ⦃X Y : Fin (n + 1)⦄ (f : X ⟶ Y), F.map f ≫ app Y = app X ≫ G.map f
state_after: C : Type u_1
inst✝ : Category.{?u.16313, u_1} C
n m : ℕ
F✝ G✝ F G : ComposableArrows C n
app : (i : Fin (n + 1)) → F.obj i ⟶ G.obj i
w : ∀ (i : ℕ) (hi : i < n), F.map' i (i + 1) ⋯ hi ≫ app ⟨i + 1, ⋯⟩ = app ⟨i, ⋯⟩ ≫ G.map' i (i + 1) ⋯ hi
⊢ ∀ (k i j : ℕ) (hj : i + k = j) (hj' : j ≤ n), F.map' i j ⋯ hj' ≫ app ⟨j, ⋯⟩ = app ⟨i, ⋯⟩ ≫ G.map' i j ⋯ hj'
tactic: suffices ∀ (k i j : ℕ) (hj : i + k = j) (hj' : j ≤ n),
        F.map' i j ≫ app _ = app _ ≫ G.map' i j by
      rintro ⟨i, hi⟩ ⟨j, hj⟩ hij
      have hij' := leOfHom hij
      simp only [Fin.mk_le_mk] at hij'
      obtain ⟨k, hk⟩ := Nat.le.dest hij'
      exact this k i j hk (by valid)
state_before: C : Type u_1
inst✝ : Category.{?u.16313, u_1} C
n m : ℕ
F✝ G✝ F G : ComposableArrows C n
app : (i : Fin (n + 1)) → F.obj i ⟶ G.obj i
w : ∀ (i : ℕ) (hi : i < n), F.map' i (i + 1) ⋯ hi ≫ app ⟨i + 1, ⋯⟩ = app ⟨i, ⋯⟩ ≫ G.map' i (i + 1) ⋯ hi
⊢ ∀ (k i j : ℕ) (hj : i + k = j) (hj' : j ≤ n), F.map' i j ⋯ hj' ≫ app ⟨j, ⋯⟩ = app ⟨i, ⋯⟩ ≫ G.map' i j ⋯ hj'
state_after: C : Type u_1
inst✝ : Category.{?u.16313, u_1} C
n m : ℕ
F✝ G✝ F G : ComposableArrows C n
app : (i : Fin (n + 1)) → F.obj i ⟶ G.obj i
w : ∀ (i : ℕ) (hi : i < n), F.map' i (i + 1) ⋯ hi ≫ app ⟨i + 1, ⋯⟩ = app ⟨i, ⋯⟩ ≫ G.map' i (i + 1) ⋯ hi
k : ℕ
⊢ ∀ (i j : ℕ) (hj : i + k = j) (hj' : j ≤ n), F.map' i j ⋯ hj' ≫ app ⟨j, ⋯⟩ = app ⟨i, ⋯⟩ ≫ G.map' i j ⋯ hj'
tactic: intro k
state_before: C : Type u_1
inst✝ : Category.{?u.16313, u_1} C
n m : ℕ
F✝ G✝ F G : ComposableArrows C n
app : (i : Fin (n + 1)) → F.obj i ⟶ G.obj i
w : ∀ (i : ℕ) (hi : i < n), F.map' i (i + 1) ⋯ hi ≫ app ⟨i + 1, ⋯⟩ = app ⟨i, ⋯⟩ ≫ G.map' i (i + 1) ⋯ hi
k : ℕ
⊢ ∀ (i j : ℕ) (hj : i + k = j) (hj' : j ≤ n), F.map' i j ⋯ hj' ≫ app ⟨j, ⋯⟩ = app ⟨i, ⋯⟩ ≫ G.map' i j ⋯ hj'
state_after: case zero
C : Type u_1
inst✝ : Category.{?u.16313, u_1} C
n m : ℕ
F✝ G✝ F G : ComposableArrows C n
app : (i : Fin (n + 1)) → F.obj i ⟶ G.obj i
w : ∀ (i : ℕ) (hi : i < n), F.map' i (i + 1) ⋯ hi ≫ app ⟨i + 1, ⋯⟩ = app ⟨i, ⋯⟩ ≫ G.map' i (i + 1) ⋯ hi
⊢ ∀ (i j : ℕ) (hj : i + 0 = j) (hj' : j ≤ n), F.map' i j ⋯ hj' ≫ app ⟨j, ⋯⟩ = app ⟨i, ⋯⟩ ≫ G.map' i j ⋯ hj'

case succ
C : Type u_1
inst✝ : Category.{?u.16313, u_1} C
n m : ℕ
F✝ G✝ F G : ComposableArrows C n
app : (i : Fin (n + 1)) → F.obj i ⟶ G.obj i
w : ∀ (i : ℕ) (hi : i < n), F.map' i (i + 1) ⋯ hi ≫ app ⟨i + 1, ⋯⟩ = app ⟨i, ⋯⟩ ≫ G.map' i (i + 1) ⋯ hi
k : ℕ
hk : ∀ (i j : ℕ) (hj : i + k = j) (hj' : j ≤ n), F.map' i j ⋯ hj' ≫ app ⟨j, ⋯⟩ = app ⟨i, ⋯⟩ ≫ G.map' i j ⋯ hj'
⊢ ∀ (i j : ℕ) (hj : i + (k + 1) = j) (hj' : j ≤ n), F.map' i j ⋯ hj' ≫ app ⟨j, ⋯⟩ = app ⟨i, ⋯⟩ ≫ G.map' i j ⋯ hj'
tactic: induction' k with k hk
Theorem: Polynomial.support_restriction
File: Mathlib/RingTheory/Polynomial/Basic.lean

Proof steps:
state_before: R : Type u
S : Type u_1
inst✝ : Ring R
p : R[X]
⊢ p.restriction.support = p.support
state_after: case a
R : Type u
S : Type u_1
inst✝ : Ring R
p : R[X]
i : ℕ
⊢ i ∈ p.restriction.support ↔ i ∈ p.support
tactic: ext i
state_before: case a
R : Type u
S : Type u_1
inst✝ : Ring R
p : R[X]
i : ℕ
⊢ i ∈ p.restriction.support ↔ i ∈ p.support
state_after: case a
R : Type u
S : Type u_1
inst✝ : Ring R
p : R[X]
i : ℕ
⊢ p.restriction.coeff i = 0 ↔ p.coeff i = 0
tactic: simp only [mem_support_iff, not_iff_not, Ne]
state_before: case a
R : Type u
S : Type u_1
inst✝ : Ring R
p : R[X]
i : ℕ
⊢ p.restriction.coeff i = 0 ↔ p.coeff i = 0
state_after: case a
R : Type u
S : Type u_1
inst✝ : Ring R
p : R[X]
i : ℕ
⊢ p.restriction.coeff i = 0 ↔ ↑(p.restriction.coeff i) = 0
tactic: conv_rhs => rw [← coeff_restriction]
state_before: case a
R : Type u
S : Type u_1
inst✝ : Ring R
p : R[X]
i : ℕ
⊢ p.restriction.coeff i = 0 ↔ ↑(p.restriction.coeff i) = 0
state_after: no goals
tactic: exact ⟨fun H => by rw [H, ZeroMemClass.coe_zero], fun H => Subtype.coe_injective H⟩
Theorem: FirstOrder.Language.Equiv.self_comp_symm_toEmbedding
File: Mathlib/ModelTheory/Basic.lean

Proof steps:
state_before: L : Language
L' : Language
M : Type w
N : Type w'
inst✝³ : L.Structure M
inst✝² : L.Structure N
P : Type u_1
inst✝¹ : L.Structure P
Q : Type u_2
inst✝ : L.Structure Q
f : M ≃[L] N
⊢ f.toEmbedding.comp f.symm.toEmbedding = Embedding.refl L N
state_after: no goals
tactic: rw [← comp_toEmbedding, self_comp_symm, refl_toEmbedding]
Theorem: ModuleCat.HasLimit.productLimitCone_isLimit_lift
File: Mathlib/Algebra/Category/ModuleCat/Biproducts.lean

Proof steps:
state_before: R : Type u
inst✝ : Ring R
J : Type w
f : J → ModuleCat R
s : Cone (Discrete.functor f)
m : s.pt ⟶ { pt := of R ((j : J) → ↑(f j)), π := Discrete.natTrans fun j => LinearMap.proj j.as }.pt
w :
  ∀ (j : Discrete J),
    m ≫ { pt := of R ((j : J) → ↑(f j)), π := Discrete.natTrans fun j => LinearMap.proj j.as }.π.app j = s.π.app j
⊢ m = lift f s
state_after: case h
R : Type u
inst✝ : Ring R
J : Type w
f : J → ModuleCat R
s : Cone (Discrete.functor f)
m : s.pt ⟶ { pt := of R ((j : J) → ↑(f j)), π := Discrete.natTrans fun j => LinearMap.proj j.as }.pt
w :
  ∀ (j : Discrete J),
    m ≫ { pt := of R ((j : J) → ↑(f j)), π := Discrete.natTrans fun j => LinearMap.proj j.as }.π.app j = s.π.app j
x : ↑s.pt
⊢ m x = (lift f s) x
tactic: ext x
state_before: case h
R : Type u
inst✝ : Ring R
J : Type w
f : J → ModuleCat R
s : Cone (Discrete.functor f)
m : s.pt ⟶ { pt := of R ((j : J) → ↑(f j)), π := Discrete.natTrans fun j => LinearMap.proj j.as }.pt
w :
  ∀ (j : Discrete J),
    m ≫ { pt := of R ((j : J) → ↑(f j)), π := Discrete.natTrans fun j => LinearMap.proj j.as }.π.app j = s.π.app j
x : ↑s.pt
⊢ m x = (lift f s) x
state_after: case h.h
R : Type u
inst✝ : Ring R
J : Type w
f : J → ModuleCat R
s : Cone (Discrete.functor f)
m : s.pt ⟶ { pt := of R ((j : J) → ↑(f j)), π := Discrete.natTrans fun j => LinearMap.proj j.as }.pt
w :
  ∀ (j : Discrete J),
    m ≫ { pt := of R ((j : J) → ↑(f j)), π := Discrete.natTrans fun j => LinearMap.proj j.as }.π.app j = s.π.app j
x : ↑s.pt
j : J
⊢ m x j = (lift f s) x j
tactic: funext j
state_before: case h.h
R : Type u
inst✝ : Ring R
J : Type w
f : J → ModuleCat R
s : Cone (Discrete.functor f)
m : s.pt ⟶ { pt := of R ((j : J) → ↑(f j)), π := Discrete.natTrans fun j => LinearMap.proj j.as }.pt
w :
  ∀ (j : Discrete J),
    m ≫ { pt := of R ((j : J) → ↑(f j)), π := Discrete.natTrans fun j => LinearMap.proj j.as }.π.app j = s.π.app j
x : ↑s.pt
j : J
⊢ m x j = (lift f s) x j
state_after: no goals
tactic: exact congr_arg (fun g : s.pt ⟶ f j => (g : s.pt → f j) x) (w ⟨j⟩)
Theorem: EReal.limsup_add_lt_of_lt
File: Mathlib/Topology/Instances/EReal.lean

Proof steps:
state_before: α✝ : Type u_1
inst✝ : TopologicalSpace α✝
α : Type u_2
f : Filter α
u v : α → EReal
a b : EReal
ha : limsup u f < a
hb : limsup v f < b
⊢ limsup (u + v) f < a + b
state_after: case intro.intro
α✝ : Type u_1
inst✝ : TopologicalSpace α✝
α : Type u_2
f : Filter α
u v : α → EReal
a b : EReal
ha : limsup u f < a
hb : limsup v f < b
c : EReal
hc : limsup u f < c
hca : c < a
⊢ limsup (u + v) f < a + b
tactic: obtain ⟨c, hc, hca⟩ := DenselyOrdered.dense _ _ ha
state_before: case intro.intro
α✝ : Type u_1
inst✝ : TopologicalSpace α✝
α : Type u_2
f : Filter α
u v : α → EReal
a b : EReal
ha : limsup u f < a
hb : limsup v f < b
c : EReal
hc : limsup u f < c
hca : c < a
⊢ limsup (u + v) f < a + b
state_after: case intro.intro.intro.intro
α✝ : Type u_1
inst✝ : TopologicalSpace α✝
α : Type u_2
f : Filter α
u v : α → EReal
a b : EReal
ha : limsup u f < a
hb : limsup v f < b
c : EReal
hc : limsup u f < c
hca : c < a
d : EReal
hd : limsup v f < d
hdb : d < b
⊢ limsup (u + v) f < a + b
tactic: obtain ⟨d, hd, hdb⟩ := DenselyOrdered.dense _ _ hb
state_before: case intro.intro.intro.intro
α✝ : Type u_1
inst✝ : TopologicalSpace α✝
α : Type u_2
f : Filter α
u v : α → EReal
a b : EReal
ha : limsup u f < a
hb : limsup v f < b
c : EReal
hc : limsup u f < c
hca : c < a
d : EReal
hd : limsup v f < d
hdb : d < b
⊢ limsup (u + v) f < a + b
state_after: no goals
tactic: exact (limsup_add_le_of_lt hc hd).trans_lt (add_lt_add hca hdb)