ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: circleIntegrable_iff
File: Mathlib/MeasureTheory/Integral/CircleIntegral.lean

Proof steps:
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℂ → E
c : ℂ
R : ℝ
⊢ CircleIntegrable f c R ↔ IntervalIntegrable (fun θ => deriv (circleMap c R) θ • f (circleMap c R θ)) volume 0 (2 * π)
state_after: case pos
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℂ → E
c : ℂ
R : ℝ
h₀ : R = 0
⊢ CircleIntegrable f c R ↔ IntervalIntegrable (fun θ => deriv (circleMap c R) θ • f (circleMap c R θ)) volume 0 (2 * π)

case neg
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℂ → E
c : ℂ
R : ℝ
h₀ : ¬R = 0
⊢ CircleIntegrable f c R ↔ IntervalIntegrable (fun θ => deriv (circleMap c R) θ • f (circleMap c R θ)) volume 0 (2 * π)
tactic: by_cases h₀ : R = 0
state_before: case neg
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℂ → E
c : ℂ
R : ℝ
h₀ : ¬R = 0
⊢ CircleIntegrable f c R ↔ IntervalIntegrable (fun θ => deriv (circleMap c R) θ • f (circleMap c R θ)) volume 0 (2 * π)
state_after: case neg
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℂ → E
c : ℂ
R : ℝ
h₀ : ¬R = 0
h : IntervalIntegrable (fun θ => deriv (circleMap c R) θ • f (circleMap c R θ)) volume 0 (2 * π)
⊢ CircleIntegrable f c R
tactic: refine ⟨fun h => h.out, fun h => ?_⟩
state_before: case neg
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℂ → E
c : ℂ
R : ℝ
h₀ : ¬R = 0
h : IntervalIntegrable (fun θ => deriv (circleMap c R) θ • f (circleMap c R θ)) volume 0 (2 * π)
⊢ CircleIntegrable f c R
state_after: case neg
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℂ → E
c : ℂ
R : ℝ
h₀ : ¬R = 0
h : IntegrableOn (fun θ => (circleMap 0 R θ * I) • f (circleMap c R θ)) (Ι 0 (2 * π)) volume
⊢ IntegrableOn (fun θ => f (circleMap c R θ)) (Ι 0 (2 * π)) volume
tactic: simp only [CircleIntegrable, intervalIntegrable_iff, deriv_circleMap] at h ⊢
state_before: case neg
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℂ → E
c : ℂ
R : ℝ
h₀ : ¬R = 0
h : IntegrableOn (fun θ => (circleMap 0 R θ * I) • f (circleMap c R θ)) (Ι 0 (2 * π)) volume
⊢ IntegrableOn (fun θ => f (circleMap c R θ)) (Ι 0 (2 * π)) volume
state_after: case neg.refine_1
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℂ → E
c : ℂ
R : ℝ
h₀ : ¬R = 0
h : IntegrableOn (fun θ => (circleMap 0 R θ * I) • f (circleMap c R θ)) (Ι 0 (2 * π)) volume
⊢ AEStronglyMeasurable (fun θ => f (circleMap c R θ)) (volume.restrict (Ι 0 (2 * π)))

case neg.refine_2
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℂ → E
c : ℂ
R : ℝ
h₀ : ¬R = 0
h : IntegrableOn (fun θ => (circleMap 0 R θ * I) • f (circleMap c R θ)) (Ι 0 (2 * π)) volume
⊢ ∀ᵐ (a : ℝ) ∂volume.restrict (Ι 0 (2 * π)),
    ‖f (circleMap c R a)‖ ≤ |R|⁻¹ * ‖(circleMap 0 R a * I) • f (circleMap c R a)‖
tactic: refine (h.norm.const_mul |R|⁻¹).mono' ?_ ?_
Theorem: Set.Iic_union_Ioc
File: Mathlib/Order/Interval/Set/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h : min c d < b
⊢ Iic b ∪ Ioc c d = Iic (max b d)
state_after: case inl
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
hcd : c ≤ d
h : c < b
⊢ Iic b ∪ Ioc c d = Iic (max b d)

case inr
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
hcd : d ≤ c
h : d < b
⊢ Iic b ∪ Ioc c d = Iic (max b d)
tactic: rcases le_total c d with hcd | hcd <;> simp [hcd] at h
Theorem: LSeries_sub
File: Mathlib/NumberTheory/LSeries/Linearity.lean

Proof steps:
state_before: f g : ℕ → ℂ
s : ℂ
hf : LSeriesSummable f s
hg : LSeriesSummable g s
⊢ LSeries (f - g) s = LSeries f s - LSeries g s
state_after: no goals
tactic: simpa only [LSeries, term_sub, Pi.sub_apply] using tsum_sub hf hg
Theorem: HasDerivWithinAt.rpow
File: Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean

Proof steps:
state_before: f g : ℝ → ℝ
f' g' x y p : ℝ
s : Set ℝ
hf : HasDerivWithinAt f f' s x
hg : HasDerivWithinAt g g' s x
h : 0 < f x
⊢ HasDerivWithinAt (fun x => f x ^ g x) (f' * g x * f x ^ (g x - 1) + g' * f x ^ g x * Real.log (f x)) s x
state_after: case h.e'_7
f g : ℝ → ℝ
f' g' x y p : ℝ
s : Set ℝ
hf : HasDerivWithinAt f f' s x
hg : HasDerivWithinAt g g' s x
h : 0 < f x
⊢ f' * g x * f x ^ (g x - 1) + g' * f x ^ g x * Real.log (f x) =
    ((g x * f x ^ (g x - 1)) • ContinuousLinearMap.smulRight 1 f' +
        (f x ^ g x * Real.log (f x)) • ContinuousLinearMap.smulRight 1 g')
      1
tactic: convert (hf.hasFDerivWithinAt.rpow hg.hasFDerivWithinAt h).hasDerivWithinAt using 1
state_before: case h.e'_7
f g : ℝ → ℝ
f' g' x y p : ℝ
s : Set ℝ
hf : HasDerivWithinAt f f' s x
hg : HasDerivWithinAt g g' s x
h : 0 < f x
⊢ f' * g x * f x ^ (g x - 1) + g' * f x ^ g x * Real.log (f x) =
    ((g x * f x ^ (g x - 1)) • ContinuousLinearMap.smulRight 1 f' +
        (f x ^ g x * Real.log (f x)) • ContinuousLinearMap.smulRight 1 g')
      1
state_after: case h.e'_7
f g : ℝ → ℝ
f' g' x y p : ℝ
s : Set ℝ
hf : HasDerivWithinAt f f' s x
hg : HasDerivWithinAt g g' s x
h : 0 < f x
⊢ f' * g x * f x ^ (g x - 1) + g' * f x ^ g x * Real.log (f x) =
    g x * f x ^ (g x - 1) * (1 * f') + f x ^ g x * Real.log (f x) * (1 * g')
tactic: dsimp
state_before: case h.e'_7
f g : ℝ → ℝ
f' g' x y p : ℝ
s : Set ℝ
hf : HasDerivWithinAt f f' s x
hg : HasDerivWithinAt g g' s x
h : 0 < f x
⊢ f' * g x * f x ^ (g x - 1) + g' * f x ^ g x * Real.log (f x) =
    g x * f x ^ (g x - 1) * (1 * f') + f x ^ g x * Real.log (f x) * (1 * g')
state_after: no goals
tactic: ring
Theorem: FirstOrder.Language.card_functions_sum
File: Mathlib/ModelTheory/Basic.lean

Proof steps:
state_before: L : Language
L' : Language
i : ℕ
⊢ #((L.sum L').Functions i) = lift.{u', u} #(L.Functions i) + lift.{u, u'} #(L'.Functions i)
state_after: no goals
tactic: simp [Language.sum]
Theorem: measurable_of_Iic
File: Mathlib/MeasureTheory/Constructions/BorelSpace/Order.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort y
s t u : Set α
inst✝⁹ : TopologicalSpace α
inst✝⁸ : MeasurableSpace α
inst✝⁷ : BorelSpace α
inst✝⁶ : TopologicalSpace β
inst✝⁵ : MeasurableSpace β
inst✝⁴ : BorelSpace β
inst✝³ : MeasurableSpace δ
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : SecondCountableTopology α
f : δ → α
hf : ∀ (x : α), MeasurableSet (f ⁻¹' Iic x)
⊢ Measurable f
state_after: case hf
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort y
s t u : Set α
inst✝⁹ : TopologicalSpace α
inst✝⁸ : MeasurableSpace α
inst✝⁷ : BorelSpace α
inst✝⁶ : TopologicalSpace β
inst✝⁵ : MeasurableSpace β
inst✝⁴ : BorelSpace β
inst✝³ : MeasurableSpace δ
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : SecondCountableTopology α
f : δ → α
hf : ∀ (x : α), MeasurableSet (f ⁻¹' Iic x)
⊢ ∀ (x : α), MeasurableSet (f ⁻¹' Ioi x)
tactic: apply measurable_of_Ioi
state_before: case hf
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort y
s t u : Set α
inst✝⁹ : TopologicalSpace α
inst✝⁸ : MeasurableSpace α
inst✝⁷ : BorelSpace α
inst✝⁶ : TopologicalSpace β
inst✝⁵ : MeasurableSpace β
inst✝⁴ : BorelSpace β
inst✝³ : MeasurableSpace δ
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : SecondCountableTopology α
f : δ → α
hf : ∀ (x : α), MeasurableSet (f ⁻¹' Iic x)
⊢ ∀ (x : α), MeasurableSet (f ⁻¹' Ioi x)
state_after: case hf
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort y
s t u : Set α
inst✝⁹ : TopologicalSpace α
inst✝⁸ : MeasurableSpace α
inst✝⁷ : BorelSpace α
inst✝⁶ : TopologicalSpace β
inst✝⁵ : MeasurableSpace β
inst✝⁴ : BorelSpace β
inst✝³ : MeasurableSpace δ
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : SecondCountableTopology α
f : δ → α
hf : ∀ (x : α), MeasurableSet (f ⁻¹' Iic x)
⊢ ∀ (x : α), MeasurableSet (f ⁻¹' Iic x)
tactic: simp_rw [← compl_Iic, preimage_compl, MeasurableSet.compl_iff]
state_before: case hf
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort y
s t u : Set α
inst✝⁹ : TopologicalSpace α
inst✝⁸ : MeasurableSpace α
inst✝⁷ : BorelSpace α
inst✝⁶ : TopologicalSpace β
inst✝⁵ : MeasurableSpace β
inst✝⁴ : BorelSpace β
inst✝³ : MeasurableSpace δ
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : SecondCountableTopology α
f : δ → α
hf : ∀ (x : α), MeasurableSet (f ⁻¹' Iic x)
⊢ ∀ (x : α), MeasurableSet (f ⁻¹' Iic x)
state_after: no goals
tactic: assumption
Theorem: MeasureTheory.Lp.simpleFunc.toSimpleFunc_toLp
File: Mathlib/MeasureTheory/Function/SimpleFuncDenseLp.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
E : Type u_4
F : Type u_5
𝕜 : Type u_6
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedAddCommGroup F
p : ℝ≥0∞
μ : Measure α
f : α →ₛ E
hfi : Memℒp (↑f) p μ
⊢ ↑(toSimpleFunc (toLp f hfi)) =ᶠ[ae μ] ↑f
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
E : Type u_4
F : Type u_5
𝕜 : Type u_6
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedAddCommGroup F
p : ℝ≥0∞
μ : Measure α
f : α →ₛ E
hfi : Memℒp (↑f) p μ
⊢ AEEqFun.mk ↑(toSimpleFunc (toLp f hfi)) ?m.235803 = AEEqFun.mk ↑f ?m.235804

α : Type u_1
β : Type u_2
ι : Type u_3
E : Type u_4
F : Type u_5
𝕜 : Type u_6
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedAddCommGroup F
p : ℝ≥0∞
μ : Measure α
f : α →ₛ E
hfi : Memℒp (↑f) p μ
⊢ AEStronglyMeasurable (↑(toSimpleFunc (toLp f hfi))) μ

α : Type u_1
β : Type u_2
ι : Type u_3
E : Type u_4
F : Type u_5
𝕜 : Type u_6
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedAddCommGroup F
p : ℝ≥0∞
μ : Measure α
f : α →ₛ E
hfi : Memℒp (↑f) p μ
⊢ AEStronglyMeasurable (↑f) μ
tactic: rw [← AEEqFun.mk_eq_mk]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
E : Type u_4
F : Type u_5
𝕜 : Type u_6
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedAddCommGroup F
p : ℝ≥0∞
μ : Measure α
f : α →ₛ E
hfi : Memℒp (↑f) p μ
⊢ AEEqFun.mk ↑(toSimpleFunc (toLp f hfi)) ?m.235803 = AEEqFun.mk ↑f ?m.235804

α : Type u_1
β : Type u_2
ι : Type u_3
E : Type u_4
F : Type u_5
𝕜 : Type u_6
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedAddCommGroup F
p : ℝ≥0∞
μ : Measure α
f : α →ₛ E
hfi : Memℒp (↑f) p μ
⊢ AEStronglyMeasurable (↑(toSimpleFunc (toLp f hfi))) μ

α : Type u_1
β : Type u_2
ι : Type u_3
E : Type u_4
F : Type u_5
𝕜 : Type u_6
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedAddCommGroup F
p : ℝ≥0∞
μ : Measure α
f : α →ₛ E
hfi : Memℒp (↑f) p μ
⊢ AEStronglyMeasurable (↑f) μ
state_after: no goals
tactic: exact Classical.choose_spec (toLp f hfi).2
Theorem: Order.Ioo_pred_right_eq_insert
File: Mathlib/Order/SuccPred/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : PartialOrder α
inst✝¹ : PredOrder α
a b : α
inst✝ : NoMinOrder α
h : a < b
⊢ Ioo (pred a) b = insert a (Ioo a b)
state_after: no goals
tactic: simp_rw [← Ioi_inter_Iio, Ioi_pred_eq_insert, insert_inter_of_mem (mem_Iio.2 h)]
Theorem: RingQuot.Rel.star
File: Mathlib/Algebra/Star/RingQuot.lean

Proof steps:
state_before: R : Type u
inst✝¹ : Semiring R
r : R → R → Prop
inst✝ : StarRing R
hr : ∀ (a b : R), r a b → r (Star.star a) (Star.star b)
a b : R
h : Rel r a b
⊢ Rel r (Star.star a) (Star.star b)
state_after: no goals
tactic: induction h with
  | of h          => exact Rel.of (hr _ _ h)
  | add_left _ h  => rw [star_add, star_add]
                     exact Rel.add_left h
  | mul_left _ h  => rw [star_mul, star_mul]
                     exact Rel.mul_right h
  | mul_right _ h => rw [star_mul, star_mul]
                     exact Rel.mul_left h
Theorem: ValuationSubring.unitGroup_le_unitGroup
File: Mathlib/RingTheory/Valuation/ValuationSubring.lean

Proof steps:
state_before: K : Type u
inst✝ : Field K
A✝ A B : ValuationSubring K
⊢ A.unitGroup ≤ B.unitGroup ↔ A ≤ B
state_after: case mp
K : Type u
inst✝ : Field K
A✝ A B : ValuationSubring K
⊢ A.unitGroup ≤ B.unitGroup → A ≤ B

case mpr
K : Type u
inst✝ : Field K
A✝ A B : ValuationSubring K
⊢ A ≤ B → A.unitGroup ≤ B.unitGroup
tactic: constructor
Theorem: Complex.continuousOn_prod_circle_transform_function
File: Mathlib/MeasureTheory/Integral/CircleTransform.lean

Proof steps:
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
R✝ : ℝ
z✝ w : ℂ
R r : ℝ
hr : r < R
z : ℂ
⊢ ContinuousOn (fun w => (circleMap z R w.2 - w.1)⁻¹ ^ 2) (closedBall z r ×ˢ univ)
state_after: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
R✝ : ℝ
z✝ w : ℂ
R r : ℝ
hr : r < R
z : ℂ
⊢ ContinuousOn (fun w => (1 / (circleMap z R w.2 - w.1)) ^ 2) (closedBall z r ×ˢ univ)
tactic: simp_rw [← one_div]
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
R✝ : ℝ
z✝ w : ℂ
R r : ℝ
hr : r < R
z : ℂ
⊢ ContinuousOn (fun w => (1 / (circleMap z R w.2 - w.1)) ^ 2) (closedBall z r ×ˢ univ)
state_after: case hf.hg
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
R✝ : ℝ
z✝ w : ℂ
R r : ℝ
hr : r < R
z : ℂ
⊢ ContinuousOn (fun x => circleMap z R x.2 - x.1) (closedBall z r ×ˢ univ)

case hf.h₀
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
R✝ : ℝ
z✝ w : ℂ
R r : ℝ
hr : r < R
z : ℂ
⊢ ∀ x ∈ closedBall z r ×ˢ univ, circleMap z R x.2 - x.1 ≠ 0
tactic: apply_rules [ContinuousOn.pow, ContinuousOn.div, continuousOn_const]
Theorem: LinearMap.mul_toMatrix'
File: Mathlib/LinearAlgebra/Matrix/SesquilinearForm.lean

Proof steps:
state_before: R✝ : Type u_1
R₁ : Type u_2
S₁ : Type u_3
R₂ : Type u_4
S₂ : Type u_5
M✝ : Type u_6
M₁ : Type u_7
M₂ : Type u_8
M₁' : Type u_9
M₂' : Type u_10
N₂ : Type u_11
n : Type u_12
m : Type u_13
n' : Type u_14
m' : Type u_15
ι : Type u_16
R : Type u_17
inst✝⁸ : CommSemiring R
inst✝⁷ : Fintype n
inst✝⁶ : Fintype m
inst✝⁵ : DecidableEq n
inst✝⁴ : DecidableEq m
inst✝³ : Fintype n'
inst✝² : Fintype m'
inst✝¹ : DecidableEq n'
inst✝ : DecidableEq m'
B : (n → R) →ₗ[R] (m → R) →ₗ[R] R
M : Matrix n' n R
⊢ M * (toMatrix₂' R) B = (toMatrix₂' R) (B ∘ₗ toLin' Mᵀ)
state_after: no goals
tactic: simp only [B.toMatrix₂'_comp, transpose_transpose, toMatrix'_toLin']
Theorem: MeasurableEmbedding.ae_map_iff
File: Mathlib/MeasureTheory/Measure/Restrict.lean

Proof steps:
state_before: R : Type u_1
α : Type u_2
β : Type u_3
δ : Type u_4
γ : Type u_5
ι : Type u_6
m0 : MeasurableSpace α
m1 : MeasurableSpace β
f : α → β
hf : MeasurableEmbedding f
p : β → Prop
μ : Measure α
⊢ (∀ᵐ (x : β) ∂Measure.map f μ, p x) ↔ ∀ᵐ (x : α) ∂μ, p (f x)
state_after: no goals
tactic: simp only [ae_iff, hf.map_apply, preimage_setOf_eq]
Theorem: WeierstrassCurve.Jacobian.dblY_of_Z_eq_zero
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 : Fin 3 → R
hP : W'.Equation P
hPz : P z = 0
⊢ W'.dblY P = (P x ^ 2) ^ 3
state_after: no goals
tactic: erw [dblY, negDblY_of_Z_eq_zero hP hPz, dblZ_of_Z_eq_zero hPz, negY_of_Z_eq_zero rfl, neg_neg]
Theorem: AlgebraicGeometry.Scheme.OpenCover.copy_obj
File: Mathlib/AlgebraicGeometry/Cover/Open.lean

Proof steps:
state_before: X✝ Y Z : Scheme
𝒰✝ : X✝.OpenCover
f : X✝ ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (x : 𝒰✝.J), HasPullback (𝒰✝.map x ≫ f) g
X : Scheme
𝒰 : X.OpenCover
J : Type u_1
obj : J → Scheme
map : (i : J) → obj i ⟶ X
e₁ : J ≃ 𝒰.J
e₂✝ : (i : J) → obj i ≅ 𝒰.obj (e₁ i)
e₂ : ∀ (i : J), map i = (e₂✝ i).hom ≫ 𝒰.map (e₁ i)
x : ↑↑X.toPresheafedSpace
⊢ x ∈ Set.range ⇑(map ((fun x => e₁.symm (𝒰.f x)) x)).val.base
state_after: X✝ Y Z : Scheme
𝒰✝ : X✝.OpenCover
f : X✝ ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (x : 𝒰✝.J), HasPullback (𝒰✝.map x ≫ f) g
X : Scheme
𝒰 : X.OpenCover
J : Type u_1
obj : J → Scheme
map : (i : J) → obj i ⟶ X
e₁ : J ≃ 𝒰.J
e₂✝ : (i : J) → obj i ≅ 𝒰.obj (e₁ i)
e₂ : ∀ (i : J), map i = (e₂✝ i).hom ≫ 𝒰.map (e₁ i)
x : ↑↑X.toPresheafedSpace
⊢ x ∈ Set.range ⇑(𝒰.map (𝒰.f x)).val.base

X✝ Y Z : Scheme
𝒰✝ : X✝.OpenCover
f : X✝ ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (x : 𝒰✝.J), HasPullback (𝒰✝.map x ≫ f) g
X : Scheme
𝒰 : X.OpenCover
J : Type u_1
obj : J → Scheme
map : (i : J) → obj i ⟶ X
e₁ : J ≃ 𝒰.J
e₂✝ : (i : J) → obj i ≅ 𝒰.obj (e₁ i)
e₂ : ∀ (i : J), map i = (e₂✝ i).hom ≫ 𝒰.map (e₁ i)
x : ↑↑X.toPresheafedSpace
⊢ Function.Surjective ⇑(e₂✝ ((fun x => e₁.symm (𝒰.f x)) x)).hom.val.base
tactic: rw [e₂, Scheme.comp_val_base, TopCat.coe_comp, Set.range_comp, Set.range_iff_surjective.mpr,
        Set.image_univ, e₁.rightInverse_symm]
state_before: X✝ Y Z : Scheme
𝒰✝ : X✝.OpenCover
f : X✝ ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (x : 𝒰✝.J), HasPullback (𝒰✝.map x ≫ f) g
X : Scheme
𝒰 : X.OpenCover
J : Type u_1
obj : J → Scheme
map : (i : J) → obj i ⟶ X
e₁ : J ≃ 𝒰.J
e₂✝ : (i : J) → obj i ≅ 𝒰.obj (e₁ i)
e₂ : ∀ (i : J), map i = (e₂✝ i).hom ≫ 𝒰.map (e₁ i)
i : J
⊢ IsOpenImmersion (map i)
state_after: X✝ Y Z : Scheme
𝒰✝ : X✝.OpenCover
f : X✝ ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (x : 𝒰✝.J), HasPullback (𝒰✝.map x ≫ f) g
X : Scheme
𝒰 : X.OpenCover
J : Type u_1
obj : J → Scheme
map : (i : J) → obj i ⟶ X
e₁ : J ≃ 𝒰.J
e₂✝ : (i : J) → obj i ≅ 𝒰.obj (e₁ i)
e₂ : ∀ (i : J), map i = (e₂✝ i).hom ≫ 𝒰.map (e₁ i)
i : J
⊢ IsOpenImmersion ((e₂✝ i).hom ≫ 𝒰.map (e₁ i))
tactic: rw [e₂]
state_before: X✝ Y Z : Scheme
𝒰✝ : X✝.OpenCover
f : X✝ ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (x : 𝒰✝.J), HasPullback (𝒰✝.map x ≫ f) g
X : Scheme
𝒰 : X.OpenCover
J : Type u_1
obj : J → Scheme
map : (i : J) → obj i ⟶ X
e₁ : J ≃ 𝒰.J
e₂✝ : (i : J) → obj i ≅ 𝒰.obj (e₁ i)
e₂ : ∀ (i : J), map i = (e₂✝ i).hom ≫ 𝒰.map (e₁ i)
i : J
⊢ IsOpenImmersion ((e₂✝ i).hom ≫ 𝒰.map (e₁ i))
state_after: no goals
tactic: exact PresheafedSpace.IsOpenImmersion.comp _ _
Theorem: Polynomial.support_neg
File: Mathlib/Algebra/Polynomial/Basic.lean

Proof steps:
state_before: R : Type u
a b : R
m n : ℕ
inst✝ : Ring R
p : R[X]
⊢ (-p).support = p.support
state_after: case ofFinsupp
R : Type u
a b : R
m n : ℕ
inst✝ : Ring R
toFinsupp✝ : R[ℕ]
⊢ (-{ toFinsupp := toFinsupp✝ }).support = { toFinsupp := toFinsupp✝ }.support
tactic: rcases p with ⟨⟩
state_before: case ofFinsupp
R : Type u
a b : R
m n : ℕ
inst✝ : Ring R
toFinsupp✝ : R[ℕ]
⊢ (-{ toFinsupp := toFinsupp✝ }).support = { toFinsupp := toFinsupp✝ }.support
state_after: case ofFinsupp
R : Type u
a b : R
m n : ℕ
inst✝ : Ring R
toFinsupp✝ : R[ℕ]
⊢ (match { toFinsupp := -toFinsupp✝ } with
    | { toFinsupp := p } => p.support) =
    match { toFinsupp := toFinsupp✝ } with
    | { toFinsupp := p } => p.support
tactic: rw [← ofFinsupp_neg, support, support]
state_before: case ofFinsupp
R : Type u
a b : R
m n : ℕ
inst✝ : Ring R
toFinsupp✝ : R[ℕ]
⊢ (match { toFinsupp := -toFinsupp✝ } with
    | { toFinsupp := p } => p.support) =
    match { toFinsupp := toFinsupp✝ } with
    | { toFinsupp := p } => p.support
state_after: no goals
tactic: apply Finsupp.support_neg
Theorem: AbsoluteValue.abs_abv_sub_le_abv_sub
File: Mathlib/Algebra/Order/AbsoluteValue.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
R✝ : Type u_3
S✝ : Type u_4
R : Type u_5
S : Type u_6
inst✝¹ : Ring R
inst✝ : LinearOrderedCommRing S
abv : AbsoluteValue R S
a b : R
⊢ abv b - abv a ≤ abv (a - b)
state_after: ι : Type u_1
α : Type u_2
R✝ : Type u_3
S✝ : Type u_4
R : Type u_5
S : Type u_6
inst✝¹ : Ring R
inst✝ : LinearOrderedCommRing S
abv : AbsoluteValue R S
a b : R
⊢ abv b - abv a ≤ abv (b - a)
tactic: rw [abv.map_sub]
state_before: ι : Type u_1
α : Type u_2
R✝ : Type u_3
S✝ : Type u_4
R : Type u_5
S : Type u_6
inst✝¹ : Ring R
inst✝ : LinearOrderedCommRing S
abv : AbsoluteValue R S
a b : R
⊢ abv b - abv a ≤ abv (b - a)
state_after: no goals
tactic: apply abv.le_sub
Theorem: CategoryTheory.Limits.limitObjIsoLimitCompEvaluation_hom_π
File: Mathlib/CategoryTheory/Limits/FunctorCategory.lean

Proof steps:
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
inst✝ : HasLimitsOfShape J C
F : J ⥤ K ⥤ C
j : J
k : K
⊢ (limitObjIsoLimitCompEvaluation F k).hom ≫ limit.π (F ⋙ (evaluation K C).obj k) j = (limit.π F j).app k
state_after: C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
inst✝ : HasLimitsOfShape J C
F : J ⥤ K ⥤ C
j : J
k : K
⊢ (preservesLimitIso ((evaluation K C).obj k) F).hom ≫ limit.π (F ⋙ (evaluation K C).obj k) j = (limit.π F j).app k
tactic: dsimp [limitObjIsoLimitCompEvaluation]
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
inst✝ : HasLimitsOfShape J C
F : J ⥤ K ⥤ C
j : J
k : K
⊢ (preservesLimitIso ((evaluation K C).obj k) F).hom ≫ limit.π (F ⋙ (evaluation K C).obj k) j = (limit.π F j).app k
state_after: no goals
tactic: simp
Theorem: Ideal.mem_pointwise_smul_iff_inv_smul_mem
File: Mathlib/RingTheory/Ideal/Pointwise.lean

Proof steps:
state_before: M : Type u_1
R : Type u_2
inst✝² : Group M
inst✝¹ : CommRing R
inst✝ : MulSemiringAction M R
a : M
S : Ideal R
x : R
h : x ∈ a • S
⊢ a⁻¹ • x ∈ S
state_after: no goals
tactic: simpa using smul_mem_pointwise_smul a⁻¹ _ _ h
state_before: M : Type u_1
R : Type u_2
inst✝² : Group M
inst✝¹ : CommRing R
inst✝ : MulSemiringAction M R
a : M
S : Ideal R
x : R
h : a⁻¹ • x ∈ S
⊢ x ∈ a • S
state_after: no goals
tactic: simpa using smul_mem_pointwise_smul a _ _ h
Theorem: norm_jacobiTheta₂_term
File: Mathlib/NumberTheory/ModularForms/JacobiTheta/TwoVariable.lean

Proof steps:
state_before: n : ℤ
z τ : ℂ
⊢ ‖jacobiTheta₂_term n z τ‖ = rexp (-π * ↑n ^ 2 * τ.im - 2 * π * ↑n * z.im)
state_after: n : ℤ
z τ : ℂ
⊢ rexp (-(π * (2 * ↑n) * z.im) + -(π * ↑n ^ 2 * τ.im)) = rexp (-π * ↑n ^ 2 * τ.im - 2 * π * ↑n * z.im)
tactic: rw [jacobiTheta₂_term, Complex.norm_eq_abs, Complex.abs_exp, (by push_cast; ring :
    (2 * π : ℂ) * I * n * z + π * I * n ^ 2 * τ = (π * (2 * n):) * z * I + (π * n ^ 2 :) * τ * I),
    add_re, mul_I_re, im_ofReal_mul, mul_I_re, im_ofReal_mul]
state_before: n : ℤ
z τ : ℂ
⊢ rexp (-(π * (2 * ↑n) * z.im) + -(π * ↑n ^ 2 * τ.im)) = rexp (-π * ↑n ^ 2 * τ.im - 2 * π * ↑n * z.im)
state_after: no goals
tactic: ring_nf
Theorem: MeasureTheory.eventuallyConst_inv_set_ae
File: Mathlib/MeasureTheory/Group/Prod.lean

Proof steps:
state_before: G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SFinite ν
inst✝² : SFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : μ.IsMulLeftInvariant
⊢ EventuallyConst s⁻¹ (ae μ) ↔ EventuallyConst s (ae μ)
state_after: no goals
tactic: rw [← inv_preimage, eventuallyConst_preimage, Filter.map_inv, inv_ae]
Theorem: Submodule.range_liftQ
File: Mathlib/LinearAlgebra/Quotient.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
r : R
x y : M
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
p p' : Submodule R M
R₂ : Type u_3
M₂ : Type u_4
inst✝³ : Ring R₂
inst✝² : AddCommGroup M₂
inst✝¹ : Module R₂ M₂
τ₁₂ : R →+* R₂
q : Submodule R₂ M₂
inst✝ : RingHomSurjective τ₁₂
f : M →ₛₗ[τ₁₂] M₂
h : p ≤ ker f
⊢ range (p.liftQ f h) = range f
state_after: no goals
tactic: simpa only [range_eq_map] using map_liftQ _ _ _ _
Theorem: ENNReal.dichotomy
File: Mathlib/Data/ENNReal/Real.lean

Proof steps:
state_before: a b c d : ℝ≥0∞
r p✝ q : ℝ≥0
p : ℝ≥0∞
inst✝ : Fact (1 ≤ p)
⊢ p = ⊤ ∨ 0 < p.toReal ∧ 1 ≤ p.toReal
state_after: no goals
tactic: simpa using ENNReal.trichotomy₂ (Fact.out : 1 ≤ p)
Theorem: finRotate_succ_apply
File: Mathlib/Logic/Equiv/Fin.lean

Proof steps:
state_before: m n : ℕ
i : Fin (n + 1)
⊢ (finRotate (n + 1)) i = i + 1
state_after: case zero
m : ℕ
i : Fin (0 + 1)
⊢ (finRotate (0 + 1)) i = i + 1

case succ
m n✝ : ℕ
i : Fin (n✝ + 1 + 1)
⊢ (finRotate (n✝ + 1 + 1)) i = i + 1
tactic: cases n
state_before: case succ
m n✝ : ℕ
i : Fin (n✝ + 1 + 1)
⊢ (finRotate (n✝ + 1 + 1)) i = i + 1
state_after: case succ.inl
m n✝ : ℕ
⊢ (finRotate (n✝ + 1 + 1)) (Fin.last (n✝ + 1)) = Fin.last (n✝ + 1) + 1

case succ.inr
m n✝ : ℕ
i : Fin (n✝ + 1 + 1)
h : i < Fin.last (n✝ + 1)
⊢ (finRotate (n✝ + 1 + 1)) i = i + 1
tactic: obtain rfl | h := Fin.eq_or_lt_of_le i.le_last