ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: EllipticCurve.variableChange_a₄
File: Mathlib/AlgebraicGeometry/EllipticCurve/Weierstrass.lean

Proof steps:
state_before: R : Type u
inst✝ : CommRing R
E : EllipticCurve R
C : WeierstrassCurve.VariableChange R
⊢ ↑(C.u⁻¹ ^ 12 * E.Δ') = (E.variableChange C).Δ
state_after: no goals
tactic: rw [Units.val_mul, Units.val_pow_eq_pow_val, coe_Δ', E.variableChange_Δ]
Theorem: MeasureTheory.Integrable.comp_sub_right
File: Mathlib/MeasureTheory/Group/Integral.lean

Proof steps:
state_before: 𝕜 : Type u_1
M : Type u_2
α : Type u_3
G : Type u_4
E : Type u_5
F : Type u_6
inst✝⁷ : MeasurableSpace G
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
μ : Measure G
f✝ : G → E
g✝ : G
inst✝² : Group G
inst✝¹ : MeasurableMul G
f : G → F
inst✝ : μ.IsMulRightInvariant
hf : Integrable f μ
g : G
⊢ Integrable (fun t => f (t / g)) μ
state_after: 𝕜 : Type u_1
M : Type u_2
α : Type u_3
G : Type u_4
E : Type u_5
F : Type u_6
inst✝⁷ : MeasurableSpace G
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
μ : Measure G
f✝ : G → E
g✝ : G
inst✝² : Group G
inst✝¹ : MeasurableMul G
f : G → F
inst✝ : μ.IsMulRightInvariant
hf : Integrable f μ
g : G
⊢ Integrable (fun t => f (t * g⁻¹)) μ
tactic: simp_rw [div_eq_mul_inv]
state_before: 𝕜 : Type u_1
M : Type u_2
α : Type u_3
G : Type u_4
E : Type u_5
F : Type u_6
inst✝⁷ : MeasurableSpace G
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
μ : Measure G
f✝ : G → E
g✝ : G
inst✝² : Group G
inst✝¹ : MeasurableMul G
f : G → F
inst✝ : μ.IsMulRightInvariant
hf : Integrable f μ
g : G
⊢ Integrable (fun t => f (t * g⁻¹)) μ
state_after: no goals
tactic: exact hf.comp_mul_right g⁻¹
Theorem: List.drop_take_succ_join_eq_get'
File: Mathlib/Data/List/Join.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
L : List (List α)
i : Fin L.length
⊢ drop (Nat.sum (take (↑i) (map length L))) (take (Nat.sum (take (↑i + 1) (map length L))) L.join) = L.get i
state_after: no goals
tactic: simp [drop_take_succ_join_eq_getElem']
Theorem: EckmannHilton.mul
File: Mathlib/GroupTheory/EckmannHilton.lean

Proof steps:
state_before: X : Type u
m₁ m₂ : X → X → X
e₁ e₂ : X
h₁ : IsUnital m₁ e₁
h₂ : IsUnital m₂ e₂
distrib : ∀ (a b c d : X), m₁ (m₂ a b) (m₂ c d) = m₂ (m₁ a c) (m₁ b d)
⊢ m₁ = m₂
state_after: case h.h
X : Type u
m₁ m₂ : X → X → X
e₁ e₂ : X
h₁ : IsUnital m₁ e₁
h₂ : IsUnital m₂ e₂
distrib : ∀ (a b c d : X), m₁ (m₂ a b) (m₂ c d) = m₂ (m₁ a c) (m₁ b d)
a b : X
⊢ m₁ a b = m₂ a b
tactic: funext a b
state_before: case h.h
X : Type u
m₁ m₂ : X → X → X
e₁ e₂ : X
h₁ : IsUnital m₁ e₁
h₂ : IsUnital m₂ e₂
distrib : ∀ (a b c d : X), m₁ (m₂ a b) (m₂ c d) = m₂ (m₁ a c) (m₁ b d)
a b : X
⊢ m₁ a b = m₂ a b
state_after: no goals
tactic: calc
    m₁ a b = m₁ (m₂ a e₁) (m₂ e₁ b) := by
      { simp only [one h₁ h₂ distrib, h₁.left_id, h₁.right_id, h₂.left_id, h₂.right_id] }
    _ = m₂ a b := by simp only [distrib, h₁.left_id, h₁.right_id, h₂.left_id, h₂.right_id]
Theorem: Mathlib.Tactic.Rify.ratCast_ne
File: Mathlib/Tactic/Rify.lean

Proof steps:
state_before: a b : ℚ
⊢ a ≠ b ↔ ↑a ≠ ↑b
state_after: no goals
tactic: simp
Theorem: CategoryTheory.Localization.LeftBousfield.W_adj_unit_app
File: Mathlib/CategoryTheory/Localization/Bousfield.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝³ : Category.{u_4, u_1} C
inst✝² : Category.{u_3, u_2} D
F : C ⥤ D
G : D ⥤ C
adj : G ⊣ F
inst✝¹ : F.Full
inst✝ : F.Faithful
X : D
⊢ W (fun x => x ∈ Set.range F.obj) (adj.unit.app X)
state_after: case intro
C : Type u_1
D : Type u_2
inst✝³ : Category.{u_4, u_1} C
inst✝² : Category.{u_3, u_2} D
F : C ⥤ D
G : D ⥤ C
adj : G ⊣ F
inst✝¹ : F.Full
inst✝ : F.Faithful
X : D
Y : C
⊢ Function.Bijective fun g => adj.unit.app X ≫ g
tactic: rintro _ ⟨Y, rfl⟩
state_before: case intro
C : Type u_1
D : Type u_2
inst✝³ : Category.{u_4, u_1} C
inst✝² : Category.{u_3, u_2} D
F : C ⥤ D
G : D ⥤ C
adj : G ⊣ F
inst✝¹ : F.Full
inst✝ : F.Faithful
X : D
Y : C
⊢ Function.Bijective fun g => adj.unit.app X ≫ g
state_after: case h.e'_3.h
C : Type u_1
D : Type u_2
inst✝³ : Category.{u_4, u_1} C
inst✝² : Category.{u_3, u_2} D
F : C ⥤ D
G : D ⥤ C
adj : G ⊣ F
inst✝¹ : F.Full
inst✝ : F.Faithful
X : D
Y : C
e_1✝ : ((G ⋙ F).obj X ⟶ F.obj Y) = (F.obj (G.obj X) ⟶ F.obj Y)
e_2✝ : ((𝟭 D).obj X ⟶ F.obj Y) = (X ⟶ F.obj Y)
⊢ (fun g => adj.unit.app X ≫ g) = ⇑((Functor.FullyFaithful.ofFullyFaithful F).homEquiv.symm.trans (adj.homEquiv X Y))
tactic: convert ((Functor.FullyFaithful.ofFullyFaithful F).homEquiv.symm.trans
    (adj.homEquiv X Y)).bijective using 1
state_before: case h.e'_3.h
C : Type u_1
D : Type u_2
inst✝³ : Category.{u_4, u_1} C
inst✝² : Category.{u_3, u_2} D
F : C ⥤ D
G : D ⥤ C
adj : G ⊣ F
inst✝¹ : F.Full
inst✝ : F.Faithful
X : D
Y : C
e_1✝ : ((G ⋙ F).obj X ⟶ F.obj Y) = (F.obj (G.obj X) ⟶ F.obj Y)
e_2✝ : ((𝟭 D).obj X ⟶ F.obj Y) = (X ⟶ F.obj Y)
⊢ (fun g => adj.unit.app X ≫ g) = ⇑((Functor.FullyFaithful.ofFullyFaithful F).homEquiv.symm.trans (adj.homEquiv X Y))
state_after: no goals
tactic: aesop
Theorem: PartialHomeomorph.map_extend_symm_nhdsWithin
File: Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
M : Type u_3
H : Type u_4
E' : Type u_5
M' : Type u_6
H' : Type u_7
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : TopologicalSpace H
inst✝⁴ : TopologicalSpace M
f f' : PartialHomeomorph M H
I : ModelWithCorners 𝕜 E H
inst✝³ : NormedAddCommGroup E'
inst✝² : NormedSpace 𝕜 E'
inst✝¹ : TopologicalSpace H'
inst✝ : TopologicalSpace M'
I' : ModelWithCorners 𝕜 E' H'
s t : Set M
y : M
hy : y ∈ f.source
⊢ map (↑(f.extend I).symm) (𝓝[↑(f.extend I).symm ⁻¹' s ∩ range ↑I] ↑(f.extend I) y) = 𝓝[s] y
state_after: 𝕜 : Type u_1
E : Type u_2
M : Type u_3
H : Type u_4
E' : Type u_5
M' : Type u_6
H' : Type u_7
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : TopologicalSpace H
inst✝⁴ : TopologicalSpace M
f f' : PartialHomeomorph M H
I : ModelWithCorners 𝕜 E H
inst✝³ : NormedAddCommGroup E'
inst✝² : NormedSpace 𝕜 E'
inst✝¹ : TopologicalSpace H'
inst✝ : TopologicalSpace M'
I' : ModelWithCorners 𝕜 E' H'
s t : Set M
y : M
hy : y ∈ f.source
⊢ ↑(f.extend I).symm ∘ ↑(f.extend I) =ᶠ[𝓝[s] y] id
tactic: rw [← map_extend_nhdsWithin f I hy, map_map, Filter.map_congr, map_id]
state_before: 𝕜 : Type u_1
E : Type u_2
M : Type u_3
H : Type u_4
E' : Type u_5
M' : Type u_6
H' : Type u_7
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : TopologicalSpace H
inst✝⁴ : TopologicalSpace M
f f' : PartialHomeomorph M H
I : ModelWithCorners 𝕜 E H
inst✝³ : NormedAddCommGroup E'
inst✝² : NormedSpace 𝕜 E'
inst✝¹ : TopologicalSpace H'
inst✝ : TopologicalSpace M'
I' : ModelWithCorners 𝕜 E' H'
s t : Set M
y : M
hy : y ∈ f.source
⊢ ↑(f.extend I).symm ∘ ↑(f.extend I) =ᶠ[𝓝[s] y] id
state_after: no goals
tactic: exact (f.extend I).leftInvOn.eqOn.eventuallyEq_of_mem (extend_source_mem_nhdsWithin _ _ hy)
Theorem: Set.Finite.isLindelof_sUnion
File: Mathlib/Topology/Compactness/Lindelof.lean

Proof steps:
state_before: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
S : Set (Set X)
hf : S.Finite
hc : ∀ s ∈ S, IsLindelof s
⊢ IsLindelof (⋃₀ S)
state_after: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
S : Set (Set X)
hf : S.Finite
hc : ∀ s ∈ S, IsLindelof s
⊢ IsLindelof (⋃ i ∈ S, i)
tactic: rw [sUnion_eq_biUnion]
state_before: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
S : Set (Set X)
hf : S.Finite
hc : ∀ s ∈ S, IsLindelof s
⊢ IsLindelof (⋃ i ∈ S, i)
state_after: no goals
tactic: exact hf.isLindelof_biUnion hc
Theorem: Ordnode.Valid'.dual_iff
File: Mathlib/Data/Ordmap/Ordset.lean

Proof steps:
state_before: α : Type u_1
inst✝ : Preorder α
t : Ordnode α
o₁ : WithBot α
o₂ : WithTop α
h : Valid' o₂ t.dual o₁
⊢ Valid' o₁ t o₂
state_after: α : Type u_1
inst✝ : Preorder α
t : Ordnode α
o₁ : WithBot α
o₂ : WithTop α
h : Valid' o₂ t.dual o₁
this : Valid' o₁ t.dual.dual o₂
⊢ Valid' o₁ t o₂
tactic: have := Valid'.dual h
state_before: α : Type u_1
inst✝ : Preorder α
t : Ordnode α
o₁ : WithBot α
o₂ : WithTop α
h : Valid' o₂ t.dual o₁
this : Valid' o₁ t.dual.dual o₂
⊢ Valid' o₁ t o₂
state_after: no goals
tactic: rwa [dual_dual, OrderDual.Preorder.dual_dual] at this
Theorem: BoxIntegral.Prepartition.mem_inf
File: Mathlib/Analysis/BoxIntegral/Partition/Basic.lean

Proof steps:
state_before: ι : Type u_1
I J J₁ J₂ : Box ι
π π₁✝ π₂✝ : Prepartition I
x : ι → ℝ
πi πi₁ πi₂ : (J : Box ι) → Prepartition J
π₁ π₂ : Prepartition I
⊢ J ∈ π₁ ⊓ π₂ ↔ ∃ J₁ ∈ π₁, ∃ J₂ ∈ π₂, ↑J = ↑J₁ ⊓ ↑J₂
state_after: no goals
tactic: simp only [inf_def, mem_biUnion, mem_restrict]
Theorem: Finsupp.toAList_entries
File: Mathlib/Data/Finsupp/AList.lean

Proof steps:
state_before: α : Type u_1
M : Type u_2
inst✝ : Zero M
f : α →₀ M
⊢ (List.map Prod.toSigma f.graph.toList).NodupKeys
state_after: α : Type u_1
M : Type u_2
inst✝ : Zero M
f : α →₀ M
⊢ ∀ x ∈ f.graph.toList, ∀ y ∈ f.graph.toList, x.1 = y.1 → x = y

α : Type u_1
M : Type u_2
inst✝ : Zero M
f : α →₀ M
⊢ f.graph.toList.Nodup
tactic: rw [List.NodupKeys, List.keys, List.map_map, Prod.fst_comp_toSigma, List.nodup_map_iff_inj_on]
Theorem: Nat.pair_unpair
File: Mathlib/Data/Nat/Pairing.lean

Proof steps:
state_before: n : ℕ
⊢ pair (unpair n).1 (unpair n).2 = n
state_after: n : ℕ
⊢ pair
      (if n - n.sqrt * n.sqrt < n.sqrt then (n - n.sqrt * n.sqrt, n.sqrt) else (n.sqrt, n - n.sqrt * n.sqrt - n.sqrt)).1
      (if n - n.sqrt * n.sqrt < n.sqrt then (n - n.sqrt * n.sqrt, n.sqrt)
        else (n.sqrt, n - n.sqrt * n.sqrt - n.sqrt)).2 =
    n
tactic: dsimp only [unpair]
state_before: n : ℕ
⊢ pair
      (if n - n.sqrt * n.sqrt < n.sqrt then (n - n.sqrt * n.sqrt, n.sqrt) else (n.sqrt, n - n.sqrt * n.sqrt - n.sqrt)).1
      (if n - n.sqrt * n.sqrt < n.sqrt then (n - n.sqrt * n.sqrt, n.sqrt)
        else (n.sqrt, n - n.sqrt * n.sqrt - n.sqrt)).2 =
    n
state_after: n : ℕ
s : ℕ := n.sqrt
⊢ pair
      (if n - n.sqrt * n.sqrt < n.sqrt then (n - n.sqrt * n.sqrt, n.sqrt) else (n.sqrt, n - n.sqrt * n.sqrt - n.sqrt)).1
      (if n - n.sqrt * n.sqrt < n.sqrt then (n - n.sqrt * n.sqrt, n.sqrt)
        else (n.sqrt, n - n.sqrt * n.sqrt - n.sqrt)).2 =
    n
tactic: let s := sqrt n
state_before: n : ℕ
s : ℕ := n.sqrt
⊢ pair
      (if n - n.sqrt * n.sqrt < n.sqrt then (n - n.sqrt * n.sqrt, n.sqrt) else (n.sqrt, n - n.sqrt * n.sqrt - n.sqrt)).1
      (if n - n.sqrt * n.sqrt < n.sqrt then (n - n.sqrt * n.sqrt, n.sqrt)
        else (n.sqrt, n - n.sqrt * n.sqrt - n.sqrt)).2 =
    n
state_after: n : ℕ
s : ℕ := n.sqrt
sm : s * s + (n - s * s) = n
⊢ pair
      (if n - n.sqrt * n.sqrt < n.sqrt then (n - n.sqrt * n.sqrt, n.sqrt) else (n.sqrt, n - n.sqrt * n.sqrt - n.sqrt)).1
      (if n - n.sqrt * n.sqrt < n.sqrt then (n - n.sqrt * n.sqrt, n.sqrt)
        else (n.sqrt, n - n.sqrt * n.sqrt - n.sqrt)).2 =
    n
tactic: have sm : s * s + (n - s * s) = n := Nat.add_sub_cancel' (sqrt_le _)
state_before: n : ℕ
s : ℕ := n.sqrt
sm : s * s + (n - s * s) = n
⊢ pair
      (if n - n.sqrt * n.sqrt < n.sqrt then (n - n.sqrt * n.sqrt, n.sqrt) else (n.sqrt, n - n.sqrt * n.sqrt - n.sqrt)).1
      (if n - n.sqrt * n.sqrt < n.sqrt then (n - n.sqrt * n.sqrt, n.sqrt)
        else (n.sqrt, n - n.sqrt * n.sqrt - n.sqrt)).2 =
    n
state_after: case pos
n : ℕ
s : ℕ := n.sqrt
sm : s * s + (n - s * s) = n
h : n - n.sqrt * n.sqrt < n.sqrt
⊢ pair (n - n.sqrt * n.sqrt, n.sqrt).1 (n - n.sqrt * n.sqrt, n.sqrt).2 = n

case neg
n : ℕ
s : ℕ := n.sqrt
sm : s * s + (n - s * s) = n
h : ¬n - n.sqrt * n.sqrt < n.sqrt
⊢ pair (n.sqrt, n - n.sqrt * n.sqrt - n.sqrt).1 (n.sqrt, n - n.sqrt * n.sqrt - n.sqrt).2 = n
tactic: split_ifs with h
Theorem: ExpChar.neg_one_pow_expChar_pow
File: Mathlib/Algebra/CharP/ExpChar.lean

Proof steps:
state_before: R : Type u
inst✝ : Ring R
q n : ℕ
hR : ExpChar R q
⊢ (-1) ^ q ^ n = -1
state_after: case zero
R : Type u
inst✝¹ : Ring R
n : ℕ
inst✝ : CharZero R
⊢ (-1) ^ 1 ^ n = -1

case prime
R : Type u
inst✝ : Ring R
q n : ℕ
hprime : Nat.Prime q
hchar✝ : CharP R q
⊢ (-1) ^ q ^ n = -1
tactic: cases' hR with _ _ hprime _
state_before: case prime
R : Type u
inst✝ : Ring R
q n : ℕ
hprime : Nat.Prime q
hchar✝ : CharP R q
⊢ (-1) ^ q ^ n = -1
state_after: case prime
R : Type u
inst✝ : Ring R
q n : ℕ
hprime : Nat.Prime q
hchar✝ : CharP R q
this : Fact (Nat.Prime q)
⊢ (-1) ^ q ^ n = -1
tactic: haveI := Fact.mk hprime
state_before: case prime
R : Type u
inst✝ : Ring R
q n : ℕ
hprime : Nat.Prime q
hchar✝ : CharP R q
this : Fact (Nat.Prime q)
⊢ (-1) ^ q ^ n = -1
state_after: no goals
tactic: exact CharP.neg_one_pow_char_pow R q n
Theorem: AddMonoid.Coprod.mrange_eq
File: Mathlib/GroupTheory/Coprod/Basic.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
M' : Type u_3
N' : Type u_4
P : Type u_5
inst✝⁴ : MulOneClass M
inst✝³ : MulOneClass N
inst✝² : MulOneClass M'
inst✝¹ : MulOneClass N'
inst✝ : MulOneClass P
f : M ∗ N →* P
⊢ MonoidHom.mrange f = MonoidHom.mrange (f.comp inl) ⊔ MonoidHom.mrange (f.comp inr)
state_after: no goals
tactic: rw [MonoidHom.mrange_eq_map, ← mrange_inl_sup_mrange_inr, Submonoid.map_sup, MonoidHom.map_mrange,
    MonoidHom.map_mrange]
Theorem: Mathlib.Meta.Positivity.log_pos_of_isNegNat
File: Mathlib/Analysis/SpecialFunctions/Log/Basic.lean

Proof steps:
state_before: e : ℝ
d n : ℕ
h : NormNum.IsInt e (Int.negOfNat n)
w : Nat.blt 1 n = true
⊢ 0 < Real.log e
state_after: e : ℝ
d n : ℕ
h : NormNum.IsInt e (Int.negOfNat n)
w : Nat.blt 1 n = true
⊢ 0 < Real.log (-↑n)
tactic: rw [NormNum.IsInt.neg_to_eq h rfl]
state_before: e : ℝ
d n : ℕ
h : NormNum.IsInt e (Int.negOfNat n)
w : Nat.blt 1 n = true
⊢ 0 < Real.log (-↑n)
state_after: e : ℝ
d n : ℕ
h : NormNum.IsInt e (Int.negOfNat n)
w : Nat.blt 1 n = true
⊢ 0 < Real.log ↑n
tactic: rw [Real.log_neg_eq_log]
state_before: e : ℝ
d n : ℕ
h : NormNum.IsInt e (Int.negOfNat n)
w : Nat.blt 1 n = true
⊢ 0 < Real.log ↑n
state_after: case hx
e : ℝ
d n : ℕ
h : NormNum.IsInt e (Int.negOfNat n)
w : Nat.blt 1 n = true
⊢ 1 < ↑n
tactic: apply Real.log_pos
state_before: case hx
e : ℝ
d n : ℕ
h : NormNum.IsInt e (Int.negOfNat n)
w : Nat.blt 1 n = true
⊢ 1 < ↑n
state_after: no goals
tactic: simpa using w
Theorem: PMF.mem_support_ofFinset_iff
File: Mathlib/Probability/ProbabilityMassFunction/Constructions.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f : α → ℝ≥0∞
s : Finset α
h : ∑ a ∈ s, f a = 1
h' : ∀ a ∉ s, f a = 0
a : α
⊢ a ∈ (ofFinset f s h h').support ↔ a ∈ s ∧ f a ≠ 0
state_after: no goals
tactic: simp
Theorem: CategoryTheory.Quotient.lift_spec
File: Mathlib/CategoryTheory/Quotient.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
r : HomRel C
D : Type u_3
inst✝ : Category.{u_4, u_3} D
F : C ⥤ D
H : ∀ (x y : C) (f₁ f₂ : x ⟶ y), r f₁ f₂ → F.map f₁ = F.map f₂
⊢ functor r ⋙ lift r F H = F
state_after: case h_map
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
r : HomRel C
D : Type u_3
inst✝ : Category.{u_4, u_3} D
F : C ⥤ D
H : ∀ (x y : C) (f₁ f₂ : x ⟶ y), r f₁ f₂ → F.map f₁ = F.map f₂
⊢ autoParam (∀ (X Y : C) (f : X ⟶ Y), (functor r ⋙ lift r F H).map f = eqToHom ⋯ ≫ F.map f ≫ eqToHom ⋯) _auto✝

case h_obj
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
r : HomRel C
D : Type u_3
inst✝ : Category.{u_4, u_3} D
F : C ⥤ D
H : ∀ (x y : C) (f₁ f₂ : x ⟶ y), r f₁ f₂ → F.map f₁ = F.map f₂
⊢ ∀ (X : C), (functor r ⋙ lift r F H).obj X = F.obj X
tactic: apply Functor.ext
state_before: case h_map
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
r : HomRel C
D : Type u_3
inst✝ : Category.{u_4, u_3} D
F : C ⥤ D
H : ∀ (x y : C) (f₁ f₂ : x ⟶ y), r f₁ f₂ → F.map f₁ = F.map f₂
⊢ autoParam (∀ (X Y : C) (f : X ⟶ Y), (functor r ⋙ lift r F H).map f = eqToHom ⋯ ≫ F.map f ≫ eqToHom ⋯) _auto✝

case h_obj
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
r : HomRel C
D : Type u_3
inst✝ : Category.{u_4, u_3} D
F : C ⥤ D
H : ∀ (x y : C) (f₁ f₂ : x ⟶ y), r f₁ f₂ → F.map f₁ = F.map f₂
⊢ ∀ (X : C), (functor r ⋙ lift r F H).obj X = F.obj X
state_after: case h_obj
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
r : HomRel C
D : Type u_3
inst✝ : Category.{u_4, u_3} D
F : C ⥤ D
H : ∀ (x y : C) (f₁ f₂ : x ⟶ y), r f₁ f₂ → F.map f₁ = F.map f₂
⊢ ∀ (X : C), (functor r ⋙ lift r F H).obj X = F.obj X

case h_map
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
r : HomRel C
D : Type u_3
inst✝ : Category.{u_4, u_3} D
F : C ⥤ D
H : ∀ (x y : C) (f₁ f₂ : x ⟶ y), r f₁ f₂ → F.map f₁ = F.map f₂
⊢ autoParam (∀ (X Y : C) (f : X ⟶ Y), (functor r ⋙ lift r F H).map f = eqToHom ⋯ ≫ F.map f ≫ eqToHom ⋯) _auto✝
tactic: rotate_left
Theorem: CliffordAlgebraComplex.ofComplex_I
File: Mathlib/LinearAlgebra/CliffordAlgebra/Equivs.lean

Proof steps:
state_before: ⊢ ↑⟨(ι Q) 1, ofComplex.proof_1⟩ * ↑⟨(ι Q) 1, ofComplex.proof_1⟩ = -1
state_after: no goals
tactic: simp
Theorem: Set.star_singleton
File: Mathlib/Algebra/Star/Pointwise.lean

Proof steps:
state_before: α : Type u_1
s t : Set α
a : α
β : Type u_2
inst✝ : InvolutiveStar β
x : β
⊢ {x}⋆ = {x⋆}
state_after: case h
α : Type u_1
s t : Set α
a : α
β : Type u_2
inst✝ : InvolutiveStar β
x y : β
⊢ y ∈ {x}⋆ ↔ y ∈ {x⋆}
tactic: ext1 y
state_before: case h
α : Type u_1
s t : Set α
a : α
β : Type u_2
inst✝ : InvolutiveStar β
x y : β
⊢ y ∈ {x}⋆ ↔ y ∈ {x⋆}
state_after: no goals
tactic: rw [mem_star, mem_singleton_iff, mem_singleton_iff, star_eq_iff_star_eq, eq_comm]
Theorem: Uniform.continuousWithinAt_iff'_left
File: Mathlib/Topology/UniformSpace/Basic.lean

Proof steps:
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝¹ : UniformSpace α
inst✝ : TopologicalSpace β
f : β → α
b : β
s : Set β
⊢ ContinuousWithinAt f s b ↔ Tendsto (fun x => (f x, f b)) (𝓝[s] b) (𝓤 α)
state_after: no goals
tactic: rw [ContinuousWithinAt, tendsto_nhds_left]
Theorem: PartialHomeomorph.map_extend_nhds
File: Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
M : Type u_3
H : Type u_4
E' : Type u_5
M' : Type u_6
H' : Type u_7
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : TopologicalSpace H
inst✝⁴ : TopologicalSpace M
f f' : PartialHomeomorph M H
I : ModelWithCorners 𝕜 E H
inst✝³ : NormedAddCommGroup E'
inst✝² : NormedSpace 𝕜 E'
inst✝¹ : TopologicalSpace H'
inst✝ : TopologicalSpace M'
I' : ModelWithCorners 𝕜 E' H'
s t : Set M
x : M
hy : x ∈ f.source
⊢ map (↑(f.extend I)) (𝓝 x) = 𝓝[range ↑I] ↑(f.extend I) x
state_after: no goals
tactic: rwa [extend_coe, comp_apply, ← I.map_nhds_eq, ← f.map_nhds_eq, map_map]
Theorem: ZNum.cast_sub
File: Mathlib/Data/Num/Lemmas.lean

Proof steps:
state_before: α : Type u_1
inst✝ : Ring α
m n : ZNum
⊢ ↑(m - n) = ↑m - ↑n
state_after: no goals
tactic: simp [sub_eq_neg_add]
Theorem: List.nodup_permutations'Aux_of_not_mem
File: Mathlib/Data/List/Perm.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
l l₁ l₂ : List α
a : α
s : List α
x : α
hx : x ∉ s
⊢ (permutations'Aux x s).Nodup
state_after: case nil
α : Type u_1
β : Type u_2
l l₁ l₂ : List α
a x : α
hx : x ∉ []
⊢ (permutations'Aux x []).Nodup

case cons
α : Type u_1
β : Type u_2
l l₁ l₂ : List α
a x y : α
s : List α
IH : x ∉ s → (permutations'Aux x s).Nodup
hx : x ∉ y :: s
⊢ (permutations'Aux x (y :: s)).Nodup
tactic: induction' s with y s IH
Theorem: Nat.digits_add_two_add_one
File: Mathlib/Data/Nat/Digits.lean

Proof steps:
state_before: n✝ b n : ℕ
⊢ (b + 2).digits (n + 1) = (n + 1) % (b + 2) :: (b + 2).digits ((n + 1) / (b + 2))
state_after: no goals
tactic: simp [digits, digitsAux_def]
Theorem: totallyBounded_insert
File: Mathlib/Topology/UniformSpace/Cauchy.lean

Proof steps:
state_before: α : Type u
β : Type v
uniformSpace : UniformSpace α
a : α
s : Set α
⊢ TotallyBounded (insert a s) ↔ TotallyBounded s
state_after: no goals
tactic: simp_rw [← singleton_union, totallyBounded_union, totallyBounded_singleton, true_and]
Theorem: AddMonoidHom.eq_liftOfRightInverse
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
G₁ : Type u_5
G₂ : Type u_6
G₃ : Type u_7
inst✝² : Group G₁
inst✝¹ : Group G₂
inst✝ : Group G₃
f : G₁ →* G₂
f_inv : G₂ → G₁
hf : Function.RightInverse f_inv ⇑f
g : G₁ →* G₃
hg : f.ker ≤ g.ker
h : G₂ →* G₃
hh : h.comp f = g
⊢ h = (f.liftOfRightInverse f_inv hf) ⟨g, hg⟩
state_after: 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
G₁ : Type u_5
G₂ : Type u_6
G₃ : Type u_7
inst✝² : Group G₁
inst✝¹ : Group G₂
inst✝ : Group G₃
f : G₁ →* G₂
f_inv : G₂ → G₁
hf : Function.RightInverse f_inv ⇑f
g : G₁ →* G₃
hg : f.ker ≤ g.ker
h : G₂ →* G₃
hh : h.comp f = g
⊢ h = (f.liftOfRightInverse f_inv hf) ⟨h.comp f, ⋯⟩
tactic: simp_rw [← hh]
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
G₁ : Type u_5
G₂ : Type u_6
G₃ : Type u_7
inst✝² : Group G₁
inst✝¹ : Group G₂
inst✝ : Group G₃
f : G₁ →* G₂
f_inv : G₂ → G₁
hf : Function.RightInverse f_inv ⇑f
g : G₁ →* G₃
hg : f.ker ≤ g.ker
h : G₂ →* G₃
hh : h.comp f = g
⊢ h = (f.liftOfRightInverse f_inv hf) ⟨h.comp f, ⋯⟩
state_after: no goals
tactic: exact ((f.liftOfRightInverse f_inv hf).apply_symm_apply _).symm
Theorem: MeasureTheory.Submartingale.expected_stoppedValue_mono
File: Mathlib/Probability/Martingale/OptionalStopping.lean

Proof steps:
state_before: Ω : Type u_1
m0 : MeasurableSpace Ω
μ : Measure Ω
𝒢 : Filtration ℕ m0
f : ℕ → Ω → ℝ
τ π : Ω → ℕ
inst✝ : SigmaFiniteFiltration μ 𝒢
hf : Submartingale f 𝒢 μ
hτ : IsStoppingTime 𝒢 τ
hπ : IsStoppingTime 𝒢 π
hle : τ ≤ π
N : ℕ
hbdd : ∀ (ω : Ω), π ω ≤ N
⊢ ∫ (x : Ω), stoppedValue f τ x ∂μ ≤ ∫ (x : Ω), stoppedValue f π x ∂μ
state_after: Ω : Type u_1
m0 : MeasurableSpace Ω
μ : Measure Ω
𝒢 : Filtration ℕ m0
f : ℕ → Ω → ℝ
τ π : Ω → ℕ
inst✝ : SigmaFiniteFiltration μ 𝒢
hf : Submartingale f 𝒢 μ
hτ : IsStoppingTime 𝒢 τ
hπ : IsStoppingTime 𝒢 π
hle : τ ≤ π
N : ℕ
hbdd : ∀ (ω : Ω), π ω ≤ N
⊢ 0 ≤ ∫ (a : Ω), (fun ω => (∑ i ∈ Finset.range (N + 1), {ω | τ ω ≤ i ∧ i < π ω}.indicator (f (i + 1) - f i)) ω) a ∂μ

case hf
Ω : Type u_1
m0 : MeasurableSpace Ω
μ : Measure Ω
𝒢 : Filtration ℕ m0
f : ℕ → Ω → ℝ
τ π : Ω → ℕ
inst✝ : SigmaFiniteFiltration μ 𝒢
hf : Submartingale f 𝒢 μ
hτ : IsStoppingTime 𝒢 τ
hπ : IsStoppingTime 𝒢 π
hle : τ ≤ π
N : ℕ
hbdd : ∀ (ω : Ω), π ω ≤ N
⊢ Integrable (stoppedValue f π) μ

case hg
Ω : Type u_1
m0 : MeasurableSpace Ω
μ : Measure Ω
𝒢 : Filtration ℕ m0
f : ℕ → Ω → ℝ
τ π : Ω → ℕ
inst✝ : SigmaFiniteFiltration μ 𝒢
hf : Submartingale f 𝒢 μ
hτ : IsStoppingTime 𝒢 τ
hπ : IsStoppingTime 𝒢 π
hle : τ ≤ π
N : ℕ
hbdd : ∀ (ω : Ω), π ω ≤ N
⊢ Integrable (stoppedValue f τ) μ
tactic: rw [← sub_nonneg, ← integral_sub', stoppedValue_sub_eq_sum' hle hbdd]
Theorem: HasFPowerSeriesAt.sub
File: Mathlib/Analysis/Analytic/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f g : E → F
p pf pg : FormalMultilinearSeries 𝕜 E F
x : E
r r' : ℝ≥0∞
hf : HasFPowerSeriesAt f pf x
hg : HasFPowerSeriesAt g pg x
⊢ HasFPowerSeriesAt (f - g) (pf - pg) x
state_after: no goals
tactic: simpa only [sub_eq_add_neg] using hf.add hg.neg
Theorem: Subring.map_comap_eq_self
File: Mathlib/Algebra/Ring/Subring/Basic.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
inst✝² : Ring R
inst✝¹ : Ring S
inst✝ : Ring T
f : R →+* S
t : Subring S
h : t ≤ f.range
⊢ map f (comap f t) = t
state_after: no goals
tactic: simpa only [inf_of_le_left h] using Subring.map_comap_eq f t