ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: IsCoprime.add_mul_right_left
File: Mathlib/RingTheory/Coprime/Basic.lean

Proof steps:
state_before: R : Type u
inst✝ : CommRing R
x y : R
h : IsCoprime x y
z : R
⊢ IsCoprime (x + z * y) y
state_after: R : Type u
inst✝ : CommRing R
x y : R
h : IsCoprime x y
z : R
⊢ IsCoprime (x + y * z) y
tactic: rw [mul_comm]
state_before: R : Type u
inst✝ : CommRing R
x y : R
h : IsCoprime x y
z : R
⊢ IsCoprime (x + y * z) y
state_after: no goals
tactic: exact h.add_mul_left_left z
Theorem: ProbabilityTheory.compProd_toKernel
File: Mathlib/Probability/Kernel/Disintegration/CdfToKernel.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : Kernel α (β × ℝ)
ν : Kernel α β
f : α × β → StieltjesFunction
inst✝¹ : IsFiniteKernel κ
inst✝ : IsSFiniteKernel ν
hf : IsCondKernelCDF f κ ν
⊢ ν ⊗ₖ IsCondKernelCDF.toKernel f hf = κ
state_after: case h.h
α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : Kernel α (β × ℝ)
ν : Kernel α β
f : α × β → StieltjesFunction
inst✝¹ : IsFiniteKernel κ
inst✝ : IsSFiniteKernel ν
hf : IsCondKernelCDF f κ ν
a : α
s : Set (β × ℝ)
hs : MeasurableSet s
⊢ ((ν ⊗ₖ IsCondKernelCDF.toKernel f hf) a) s = (κ a) s
tactic: ext a s hs
state_before: case h.h
α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : Kernel α (β × ℝ)
ν : Kernel α β
f : α × β → StieltjesFunction
inst✝¹ : IsFiniteKernel κ
inst✝ : IsSFiniteKernel ν
hf : IsCondKernelCDF f κ ν
a : α
s : Set (β × ℝ)
hs : MeasurableSet s
⊢ ((ν ⊗ₖ IsCondKernelCDF.toKernel f hf) a) s = (κ a) s
state_after: no goals
tactic: rw [Kernel.compProd_apply _ _ _ hs, lintegral_toKernel_mem hf a hs]
Theorem: totallyBounded_of_forall_symm
File: Mathlib/Topology/UniformSpace/Cauchy.lean

Proof steps:
state_before: α : Type u
β : Type v
uniformSpace : UniformSpace α
s : Set α
h : ∀ V ∈ 𝓤 α, SymmetricRel V → ∃ t, t.Finite ∧ s ⊆ ⋃ y ∈ t, ball y V
V : Set (α × α)
hV : V ∈ 𝓤 α ∧ SymmetricRel V
⊢ ∃ t, t.Finite ∧ s ⊆ ⋃ y ∈ t, {x | (x, y) ∈ id V}
state_after: no goals
tactic: simpa only [ball_eq_of_symmetry hV.2] using h V hV.1 hV.2
Theorem: Real.rpow_mul_intCast
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

Proof steps:
state_before: x y✝ z : ℝ
n✝ : ℕ
hx : 0 ≤ x
y : ℝ
n : ℤ
⊢ x ^ (y * ↑n) = (x ^ y) ^ n
state_after: no goals
tactic: rw [rpow_mul hx, rpow_intCast]
Theorem: Sym.equivCongr_apply
File: Mathlib/Data/Sym/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
n n' m : ℕ
s : Sym α n
a b : α
e : α ≃ β
x : Sym α n
⊢ map (⇑e.symm) (map (⇑e) x) = x
state_after: no goals
tactic: rw [map_map, Equiv.symm_comp_self, map_id]
state_before: α : Type u_1
β : Type u_2
n n' m : ℕ
s : Sym α n
a b : α
e : α ≃ β
x : Sym β n
⊢ map (⇑e) (map (⇑e.symm) x) = x
state_after: no goals
tactic: rw [map_map, Equiv.self_comp_symm, map_id]
Theorem: Nat.Coprime.gcd_mul_left_cancel
File: .lake/packages/batteries/Batteries/Data/Nat/Gcd.lean

Proof steps:
state_before: k n m : Nat
H : k.Coprime n
⊢ ((k * m).gcd n).Coprime k
state_after: no goals
tactic: rw [Coprime, Nat.gcd_assoc, H.symm.gcd_eq_one, gcd_one_right]
Theorem: HahnSeries.coeff_eq_zero_of_lt_orderTop
File: Mathlib/RingTheory/HahnSeries/Basic.lean

Proof steps:
state_before: Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : Zero R
a b : Γ
r : R
x : HahnSeries Γ R
i : Γ
hi : ↑i < x.orderTop
⊢ x.coeff i = 0
state_after: case inl
Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : Zero R
a b : Γ
r : R
i : Γ
hi : ↑i < orderTop 0
⊢ coeff 0 i = 0

case inr
Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : Zero R
a b : Γ
r : R
x : HahnSeries Γ R
i : Γ
hi : ↑i < x.orderTop
hx : x ≠ 0
⊢ x.coeff i = 0
tactic: rcases eq_or_ne x 0 with (rfl | hx)
state_before: case inr
Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : Zero R
a b : Γ
r : R
x : HahnSeries Γ R
i : Γ
hi : ↑i < x.orderTop
hx : x ≠ 0
⊢ x.coeff i = 0
state_after: case inr
Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : Zero R
a b : Γ
r : R
x : HahnSeries Γ R
i : Γ
hx : x ≠ 0
hi : x.coeff i ≠ 0
⊢ ¬↑i < x.orderTop
tactic: contrapose! hi
state_before: case inr
Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : Zero R
a b : Γ
r : R
x : HahnSeries Γ R
i : Γ
hx : x ≠ 0
hi : x.coeff i ≠ 0
⊢ ¬↑i < x.orderTop
state_after: case inr
Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : Zero R
a b : Γ
r : R
x : HahnSeries Γ R
i : Γ
hx : x ≠ 0
hi : i ∈ x.support
⊢ ¬↑i < x.orderTop
tactic: rw [← mem_support] at hi
state_before: case inr
Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : Zero R
a b : Γ
r : R
x : HahnSeries Γ R
i : Γ
hx : x ≠ 0
hi : i ∈ x.support
⊢ ¬↑i < x.orderTop
state_after: case inr
Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : Zero R
a b : Γ
r : R
x : HahnSeries Γ R
i : Γ
hx : x ≠ 0
hi : i ∈ x.support
⊢ ¬i < ⋯.min ⋯
tactic: rw [orderTop_of_ne hx, WithTop.coe_lt_coe]
state_before: case inr
Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : Zero R
a b : Γ
r : R
x : HahnSeries Γ R
i : Γ
hx : x ≠ 0
hi : i ∈ x.support
⊢ ¬i < ⋯.min ⋯
state_after: no goals
tactic: exact Set.IsWF.not_lt_min _ _ hi
Theorem: Real.Gamma_mul_Gamma_add_half
File: Mathlib/Analysis/SpecialFunctions/Gamma/Beta.lean

Proof steps:
state_before: s : ℝ
⊢ Gamma s * Gamma (s + 1 / 2) = Gamma (2 * s) * 2 ^ (1 - 2 * s) * √π
state_after: s : ℝ
⊢ ↑(Gamma s * Gamma (s + 1 / 2)) = ↑(Gamma (2 * s) * 2 ^ (1 - 2 * s) * √π)
tactic: rw [← ofReal_inj]
state_before: s : ℝ
⊢ ↑(Gamma s * Gamma (s + 1 / 2)) = ↑(Gamma (2 * s) * 2 ^ (1 - 2 * s) * √π)
state_after: no goals
tactic: simpa only [← Gamma_ofReal, ofReal_cpow zero_le_two, ofReal_mul, ofReal_add, ofReal_div,
    ofReal_sub] using Complex.Gamma_mul_Gamma_add_half ↑s
Theorem: FiniteDimensional.exists_mul_eq_one
File: Mathlib/LinearAlgebra/FiniteDimensional/Defs.lean

Proof steps:
state_before: K✝ : Type u
V : Type v
F : Type u_1
K : Type u_2
inst✝⁴ : Field F
inst✝³ : Ring K
inst✝² : IsDomain K
inst✝¹ : Algebra F K
inst✝ : FiniteDimensional F K
x : K
H : x ≠ 0
⊢ ∃ y, x * y = 1
state_after: K✝ : Type u
V : Type v
F : Type u_1
K : Type u_2
inst✝⁴ : Field F
inst✝³ : Ring K
inst✝² : IsDomain K
inst✝¹ : Algebra F K
inst✝ : FiniteDimensional F K
x : K
H : x ≠ 0
this : Surjective ⇑(LinearMap.mulLeft F x)
⊢ ∃ y, x * y = 1
tactic: have : Function.Surjective (LinearMap.mulLeft F x) :=
    LinearMap.injective_iff_surjective.1 fun y z => ((mul_right_inj' H).1 : x * y = x * z → y = z)
state_before: K✝ : Type u
V : Type v
F : Type u_1
K : Type u_2
inst✝⁴ : Field F
inst✝³ : Ring K
inst✝² : IsDomain K
inst✝¹ : Algebra F K
inst✝ : FiniteDimensional F K
x : K
H : x ≠ 0
this : Surjective ⇑(LinearMap.mulLeft F x)
⊢ ∃ y, x * y = 1
state_after: no goals
tactic: exact this 1
Theorem: ProbabilityTheory.Kernel.setIntegral_restrict
File: Mathlib/Probability/Kernel/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : Kernel α β
s t✝ : Set β
E : Type u_4
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : β → E
a : α
hs : MeasurableSet s
t : Set β
⊢ ∫ (x : β) in t, f x ∂(κ.restrict hs) a = ∫ (x : β) in t ∩ s, f x ∂κ a
state_after: no goals
tactic: rw [restrict_apply, Measure.restrict_restrict' hs]
Theorem: IsConnected.iUnion_of_chain
File: Mathlib/Topology/Connected/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝⁴ : TopologicalSpace α
s✝ t u v : Set α
inst✝³ : LinearOrder β
inst✝² : SuccOrder β
inst✝¹ : IsSuccArchimedean β
inst✝ : Nonempty β
s : β → Set α
H : ∀ (n : β), IsConnected (s n)
K : ∀ (n : β), (s n ∩ s (succ n)).Nonempty
i✝ j i : β
x✝ : i ∈ Ico j i✝
⊢ (s (succ i) ∩ s i).Nonempty
state_after: α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝⁴ : TopologicalSpace α
s✝ t u v : Set α
inst✝³ : LinearOrder β
inst✝² : SuccOrder β
inst✝¹ : IsSuccArchimedean β
inst✝ : Nonempty β
s : β → Set α
H : ∀ (n : β), IsConnected (s n)
K : ∀ (n : β), (s n ∩ s (succ n)).Nonempty
i✝ j i : β
x✝ : i ∈ Ico j i✝
⊢ (s i ∩ s (succ i)).Nonempty
tactic: rw [inter_comm]
state_before: α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝⁴ : TopologicalSpace α
s✝ t u v : Set α
inst✝³ : LinearOrder β
inst✝² : SuccOrder β
inst✝¹ : IsSuccArchimedean β
inst✝ : Nonempty β
s : β → Set α
H : ∀ (n : β), IsConnected (s n)
K : ∀ (n : β), (s n ∩ s (succ n)).Nonempty
i✝ j i : β
x✝ : i ∈ Ico j i✝
⊢ (s i ∩ s (succ i)).Nonempty
state_after: no goals
tactic: exact K i
Theorem: MeasureTheory.pdf.lintegral_eq_measure_univ
File: Mathlib/Probability/Density.lean

Proof steps:
state_before: Ω : Type u_1
E : Type u_2
inst✝¹ : MeasurableSpace E
m : MeasurableSpace Ω
ℙ : Measure Ω
μ : Measure E
X : Ω → E
inst✝ : HasPDF X ℙ μ
⊢ ∫⁻ (x : E), pdf X ℙ μ x ∂μ = ℙ Set.univ
state_after: no goals
tactic: rw [← setLIntegral_univ, ← map_eq_setLIntegral_pdf X ℙ μ MeasurableSet.univ,
    map_apply_of_aemeasurable (HasPDF.aemeasurable X ℙ μ) MeasurableSet.univ, Set.preimage_univ]
Theorem: SimplicialObject.Splitting.IndexSet.id_fst
File: Mathlib/AlgebraicTopology/SplitSimplicialObject.lean

Proof steps:
state_before: C : Type u_1
inst✝ : Category.{?u.3220, u_1} C
Δ : SimplexCategoryᵒᵖ
A : IndexSet Δ
⊢ Epi (𝟙 (unop Δ))
state_after: no goals
tactic: infer_instance
Theorem: PiNat.isTopologicalBasis_cylinders
File: Mathlib/Topology/MetricSpace/PiNat.lean

Proof steps:
state_before: E : ℕ → Type u_1
inst✝¹ : (n : ℕ) → TopologicalSpace (E n)
inst✝ : ∀ (n : ℕ), DiscreteTopology (E n)
⊢ IsTopologicalBasis {s | ∃ x n, s = cylinder x n}
state_after: case h_open
E : ℕ → Type u_1
inst✝¹ : (n : ℕ) → TopologicalSpace (E n)
inst✝ : ∀ (n : ℕ), DiscreteTopology (E n)
⊢ ∀ u ∈ {s | ∃ x n, s = cylinder x n}, IsOpen u

case h_nhds
E : ℕ → Type u_1
inst✝¹ : (n : ℕ) → TopologicalSpace (E n)
inst✝ : ∀ (n : ℕ), DiscreteTopology (E n)
⊢ ∀ (a : (n : ℕ) → E n) (u : Set ((n : ℕ) → E n)), a ∈ u → IsOpen u → ∃ v ∈ {s | ∃ x n, s = cylinder x n}, a ∈ v ∧ v ⊆ u
tactic: apply isTopologicalBasis_of_isOpen_of_nhds
Theorem: Finset.sum_antidiagonal_choose_add
File: Mathlib/Data/Nat/Choose/Sum.lean

Proof steps:
state_before: R✝ : Type u_1
M : Type u_2
R : Type u_3
inst✝¹ : CommMonoid M
inst✝ : NonAssocSemiring R
d n : ℕ
⊢ ∑ ij ∈ antidiagonal n, (d + ij.2).choose d = (d + n).choose d + (d + n).choose d.succ
state_after: no goals
tactic: induction n with
  | zero => simp
  | succ n hn => simpa [Nat.sum_antidiagonal_succ] using hn
Theorem: sameRay_neg_swap
File: Mathlib/LinearAlgebra/Ray.lean

Proof steps:
state_before: R : Type u_1
inst✝⁴ : StrictOrderedCommRing R
M : Type u_2
N : Type u_3
inst✝³ : AddCommGroup M
inst✝² : AddCommGroup N
inst✝¹ : Module R M
inst✝ : Module R N
x y : M
⊢ SameRay R (-x) y ↔ SameRay R x (-y)
state_after: no goals
tactic: rw [← sameRay_neg_iff, neg_neg]
Theorem: MvPolynomial.eq_zero_of_eval_eq_zero
File: Mathlib/FieldTheory/Finite/Polynomial.lean

Proof steps:
state_before: σ K : Type u
inst✝² : Fintype K
inst✝¹ : Field K
inst✝ : Finite σ
p : MvPolynomial σ K
h : ∀ (v : σ → K), (eval v) p = 0
hp : p ∈ restrictDegree σ K (Fintype.card K - 1)
p' : R σ K := ⟨p, hp⟩
this : p' ∈ ker (evalᵢ σ K)
⊢ p' = 0
state_after: no goals
tactic: rwa [ker_evalₗ, mem_bot] at this
Theorem: HomologicalComplex₂.flip_X_d
File: Mathlib/Algebra/Homology/HomologicalBicomplex.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{?u.12556, u_1} C
inst✝ : HasZeroMorphisms C
I₁ : Type u_2
I₂ : Type u_3
c₁ : ComplexShape I₁
c₂ : ComplexShape I₂
K : HomologicalComplex₂ C c₁ c₂
i i' : I₂
w : ¬c₂.Rel i i'
⊢ (fun i i' => { f := fun j => (K.X j).d i i', comm' := ⋯ }) i i' = 0
state_after: case h
C : Type u_1
inst✝¹ : Category.{?u.12556, u_1} C
inst✝ : HasZeroMorphisms C
I₁ : Type u_2
I₂ : Type u_3
c₁ : ComplexShape I₁
c₂ : ComplexShape I₂
K : HomologicalComplex₂ C c₁ c₂
i i' : I₂
w : ¬c₂.Rel i i'
j : I₁
⊢ ((fun i i' => { f := fun j => (K.X j).d i i', comm' := ⋯ }) i i').f j = Hom.f 0 j
tactic: ext j
state_before: case h
C : Type u_1
inst✝¹ : Category.{?u.12556, u_1} C
inst✝ : HasZeroMorphisms C
I₁ : Type u_2
I₂ : Type u_3
c₁ : ComplexShape I₁
c₂ : ComplexShape I₂
K : HomologicalComplex₂ C c₁ c₂
i i' : I₂
w : ¬c₂.Rel i i'
j : I₁
⊢ ((fun i i' => { f := fun j => (K.X j).d i i', comm' := ⋯ }) i i').f j = Hom.f 0 j
state_after: no goals
tactic: exact (K.X j).shape i i' w
Theorem: tsum_neg
File: Mathlib/Topology/Algebra/InfiniteSum/Group.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : CommGroup α
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalGroup α
f g : β → α
a a₁ a₂ : α
inst✝ : T2Space α
⊢ ∏' (b : β), (f b)⁻¹ = (∏' (b : β), f b)⁻¹
state_after: case pos
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : CommGroup α
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalGroup α
f g : β → α
a a₁ a₂ : α
inst✝ : T2Space α
hf : Multipliable f
⊢ ∏' (b : β), (f b)⁻¹ = (∏' (b : β), f b)⁻¹

case neg
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : CommGroup α
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalGroup α
f g : β → α
a a₁ a₂ : α
inst✝ : T2Space α
hf : ¬Multipliable f
⊢ ∏' (b : β), (f b)⁻¹ = (∏' (b : β), f b)⁻¹
tactic: by_cases hf : Multipliable f
Theorem: Ordnode.Sized.eq_node'
File: Mathlib/Data/Ordmap/Ordset.lean

Proof steps:
state_before: α : Type u_1
s : ℕ
l : Ordnode α
x : α
r : Ordnode α
h : (node s l x r).Sized
⊢ node s l x r = l.node' x r
state_after: no goals
tactic: rw [h.1]
Theorem: Sym2.other_eq_other'
File: Mathlib/Data/Sym/Sym2.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
e : Sym2 α
f : α → β
inst✝ : DecidableEq α
a : α
z : Sym2 α
h : a ∈ z
⊢ Mem.other h = Mem.other' h
state_after: no goals
tactic: rw [← congr_right, other_spec' h, other_spec]
Theorem: Computation.ret_bind
File: Mathlib/Data/Seq/Computation.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
a : α
f : α → Computation β
⊢ (pure a).bind f = f a
state_after: case bisim
α : Type u
β : Type v
γ : Type w
a : α
f : α → Computation β
⊢ IsBisimulation fun c₁ c₂ => c₁ = (pure a).bind f ∧ c₂ = f a ∨ c₁ = corec (Bind.f f) (Sum.inr c₂)

case r
α : Type u
β : Type v
γ : Type w
a : α
f : α → Computation β
⊢ (pure a).bind f = (pure a).bind f ∧ f a = f a ∨ (pure a).bind f = corec (Bind.f f) (Sum.inr (f a))
tactic: apply
    eq_of_bisim fun c₁ c₂ => c₁ = bind (pure a) f ∧ c₂ = f a ∨ c₁ = corec (Bind.f f) (Sum.inr c₂)
Theorem: Rat.inv_intCast_num_of_pos
File: Mathlib/Data/Rat/Lemmas.lean

Proof steps:
state_before: a : ℤ
ha0 : 0 < a
⊢ (↑a)⁻¹.num = 1
state_after: a : ℤ
ha0 : 0 < a
⊢ (↑1 / ↑a).num = 1
tactic: rw [← ofInt_eq_cast, ofInt, mk_eq_divInt, Rat.inv_divInt', divInt_eq_div, Nat.cast_one]
state_before: a : ℤ
ha0 : 0 < a
⊢ (↑1 / ↑a).num = 1
state_after: a : ℤ
ha0 : 0 < a
⊢ (Int.natAbs 1).Coprime a.natAbs
tactic: apply num_div_eq_of_coprime ha0
state_before: a : ℤ
ha0 : 0 < a
⊢ (Int.natAbs 1).Coprime a.natAbs
state_after: a : ℤ
ha0 : 0 < a
⊢ Nat.Coprime 1 a.natAbs
tactic: rw [Int.natAbs_one]
state_before: a : ℤ
ha0 : 0 < a
⊢ Nat.Coprime 1 a.natAbs
state_after: no goals
tactic: exact Nat.coprime_one_left _
Theorem: AlgebraicGeometry.Scheme.OpenCover.pullbackCover'_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 W : Scheme
𝒰 : X.OpenCover
f : W ⟶ X
x : ↑↑W.toPresheafedSpace
⊢ x ∈ Set.range ⇑((fun x => pullback.snd (𝒰.map x) f) ((fun x => 𝒰.f (f.val.base 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 W : Scheme
𝒰 : X.OpenCover
f : W ⟶ X
x : ↑↑W.toPresheafedSpace
⊢ x ∈
    Set.range
      ⇑((PreservesPullback.iso forgetToTop (𝒰.map (𝒰.f (f.val.base x))) f).hom ≫
          pullback.snd (forgetToTop.map (𝒰.map (𝒰.f (f.val.base x)))) (forgetToTop.map f))
tactic: rw [←
      show _ = (pullback.snd (𝒰.map (𝒰.f (f.1.base x))) f).1.base from
        PreservesPullback.iso_hom_snd Scheme.forgetToTop (𝒰.map (𝒰.f (f.1.base x))) f]
state_before: X✝ Y Z : Scheme
𝒰✝ : X✝.OpenCover
f✝ : X✝ ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (x : 𝒰✝.J), HasPullback (𝒰✝.map x ≫ f✝) g
X W : Scheme
𝒰 : X.OpenCover
f : W ⟶ X
x : ↑↑W.toPresheafedSpace
⊢ x ∈
    Set.range
      ⇑((PreservesPullback.iso forgetToTop (𝒰.map (𝒰.f (f.val.base x))) f).hom ≫
          pullback.snd (forgetToTop.map (𝒰.map (𝒰.f (f.val.base x)))) (forgetToTop.map f))
state_after: X✝ Y Z : Scheme
𝒰✝ : X✝.OpenCover
f✝ : X✝ ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (x : 𝒰✝.J), HasPullback (𝒰✝.map x ≫ f✝) g
X W : Scheme
𝒰 : X.OpenCover
f : W ⟶ X
x : ↑↑W.toPresheafedSpace
⊢ x ∈ {y | ∃ x_1, (forgetToTop.map (𝒰.map (𝒰.f (f.val.base x)))) x_1 = (forgetToTop.map f) y}

X✝ Y Z : Scheme
𝒰✝ : X✝.OpenCover
f✝ : X✝ ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (x : 𝒰✝.J), HasPullback (𝒰✝.map x ≫ f✝) g
X W : Scheme
𝒰 : X.OpenCover
f : W ⟶ X
x : ↑↑W.toPresheafedSpace
⊢ Function.Surjective ⇑(PreservesPullback.iso forgetToTop (𝒰.map (𝒰.f (f.val.base x))) f).hom
tactic: rw [TopCat.coe_comp, Set.range_comp, Set.range_iff_surjective.mpr, Set.image_univ,
      TopCat.pullback_snd_range]
Theorem: Complex.logTaylor_at_zero
File: Mathlib/Analysis/SpecialFunctions/Complex/LogBounds.lean

Proof steps:
state_before: n : ℕ
⊢ logTaylor n 0 = 0
state_after: no goals
tactic: induction n with
  | zero => simp [logTaylor_zero]
  | succ n ih => simpa [logTaylor_succ, ih] using ne_or_eq n 0
Theorem: le_iff_oneLePart_leOnePart
File: Mathlib/Algebra/Order/Group/PosPart.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : Lattice α
inst✝¹ : CommGroup α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b : α
⊢ a ≤ b ↔ a⁺ᵐ ≤ b⁺ᵐ ∧ b⁻ᵐ ≤ a⁻ᵐ
state_after: α : Type u_1
β : Type u_2
inst✝² : Lattice α
inst✝¹ : CommGroup α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b : α
h : a⁺ᵐ ≤ b⁺ᵐ ∧ b⁻ᵐ ≤ a⁻ᵐ
⊢ a ≤ b
tactic: refine ⟨fun h ↦ ⟨oneLePart_mono h, leOnePart_anti h⟩, fun h ↦ ?_⟩
state_before: α : Type u_1
β : Type u_2
inst✝² : Lattice α
inst✝¹ : CommGroup α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b : α
h : a⁺ᵐ ≤ b⁺ᵐ ∧ b⁻ᵐ ≤ a⁻ᵐ
⊢ a ≤ b
state_after: α : Type u_1
β : Type u_2
inst✝² : Lattice α
inst✝¹ : CommGroup α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b : α
h : a⁺ᵐ ≤ b⁺ᵐ ∧ b⁻ᵐ ≤ a⁻ᵐ
⊢ a⁺ᵐ / a⁻ᵐ ≤ b⁺ᵐ / b⁻ᵐ
tactic: rw [← oneLePart_div_leOnePart a, ← oneLePart_div_leOnePart b]
state_before: α : Type u_1
β : Type u_2
inst✝² : Lattice α
inst✝¹ : CommGroup α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b : α
h : a⁺ᵐ ≤ b⁺ᵐ ∧ b⁻ᵐ ≤ a⁻ᵐ
⊢ a⁺ᵐ / a⁻ᵐ ≤ b⁺ᵐ / b⁻ᵐ
state_after: no goals
tactic: exact div_le_div'' h.1 h.2
Theorem: Nat.lt_floor_add_one
File: Mathlib/Algebra/Order/Floor.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a✝ : α
n : ℕ
a : α
⊢ a < ↑⌊a⌋₊ + 1
state_after: no goals
tactic: simpa using lt_succ_floor a
Theorem: Mathlib.Tactic.Abel.term_atom
File: Mathlib/Tactic/Abel.lean

Proof steps:
state_before: α : Type u_1
inst✝ : AddCommMonoid α
x : α
⊢ x = term 1 x 0
state_after: no goals
tactic: simp [term]
Theorem: Behrend.map_succ
File: Mathlib/Combinatorics/Additive/AP/Three/Behrend.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
a : Fin (n + 1) → ℕ
⊢ (map d) a = a 0 + (∑ x : Fin n, a x.succ * d ^ ↑x) * d
state_after: no goals
tactic: simp [map, Fin.sum_univ_succ, _root_.pow_succ, ← mul_assoc, ← sum_mul]
Theorem: List.countP_le_length
File: .lake/packages/batteries/Batteries/Data/List/Count.lean

Proof steps:
state_before: α : Type u_1
p q : α → Bool
l : List α
⊢ countP p l ≤ l.length
state_after: α : Type u_1
p q : α → Bool
l : List α
⊢ (filter p l).length ≤ l.length
tactic: simp only [countP_eq_length_filter]
state_before: α : Type u_1
p q : α → Bool
l : List α
⊢ (filter p l).length ≤ l.length
state_after: no goals
tactic: apply length_filter_le
Theorem: CategoryTheory.Abelian.Ext.zero_comp
File: Mathlib/Algebra/Homology/DerivedCategory/Ext.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : HasExt C
X Y Z T : C
n m : ℕ
β : Ext Y Z m
p : ℕ
h : n + m = p
⊢ comp 0 β h = 0
state_after: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : HasExt C
X Y Z T : C
n m : ℕ
β : Ext Y Z m
p : ℕ
h : n + m = p
this : HasDerivedCategory C := HasDerivedCategory.standard C
⊢ comp 0 β h = 0
tactic: letI := HasDerivedCategory.standard C
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : HasExt C
X Y Z T : C
n m : ℕ
β : Ext Y Z m
p : ℕ
h : n + m = p
this : HasDerivedCategory C := HasDerivedCategory.standard C
⊢ comp 0 β h = 0
state_after: case h
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : HasExt C
X Y Z T : C
n m : ℕ
β : Ext Y Z m
p : ℕ
h : n + m = p
this : HasDerivedCategory C := HasDerivedCategory.standard C
⊢ (comp 0 β h).hom = hom 0
tactic: ext
state_before: case h
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : HasExt C
X Y Z T : C
n m : ℕ
β : Ext Y Z m
p : ℕ
h : n + m = p
this : HasDerivedCategory C := HasDerivedCategory.standard C
⊢ (comp 0 β h).hom = hom 0
state_after: no goals
tactic: simp [zero_hom']
Theorem: SemiconjBy.inv_right_iff
File: Mathlib/Algebra/Group/Semiconj/Basic.lean

Proof steps:
state_before: G : Type u_1
inst✝ : Group G
a x y : G
⊢ SemiconjBy a x⁻¹ y⁻¹ ↔ SemiconjBy a x y
state_after: no goals
tactic: rw [← inv_symm_left_iff, inv_inv_symm_iff]
Theorem: CategoryTheory.Quotient.natTrans_ext
File: Mathlib/CategoryTheory/Quotient.lean

Proof steps:
state_before: C : Type u_3
inst✝¹ : Category.{u_1, u_3} C
r : HomRel C
D : Type u_4
inst✝ : Category.{u_2, u_4} D
F✝ : C ⥤ D
H : ∀ (x y : C) (f₁ f₂ : x ⟶ y), r f₁ f₂ → F✝.map f₁ = F✝.map f₂
F G : Quotient r ⥤ D
τ₁ τ₂ : F ⟶ G
h : whiskerLeft (functor r) τ₁ = whiskerLeft (functor r) τ₂
⊢ τ₁.app = τ₂.app
state_after: case h.mk
C : Type u_3
inst✝¹ : Category.{u_1, u_3} C
r : HomRel C
D : Type u_4
inst✝ : Category.{u_2, u_4} D
F✝ : C ⥤ D
H : ∀ (x y : C) (f₁ f₂ : x ⟶ y), r f₁ f₂ → F✝.map f₁ = F✝.map f₂
F G : Quotient r ⥤ D
τ₁ τ₂ : F ⟶ G
h : whiskerLeft (functor r) τ₁ = whiskerLeft (functor r) τ₂
X : C
⊢ τ₁.app { as := X } = τ₂.app { as := X }
tactic: ext1 ⟨X⟩
state_before: case h.mk
C : Type u_3
inst✝¹ : Category.{u_1, u_3} C
r : HomRel C
D : Type u_4
inst✝ : Category.{u_2, u_4} D
F✝ : C ⥤ D
H : ∀ (x y : C) (f₁ f₂ : x ⟶ y), r f₁ f₂ → F✝.map f₁ = F✝.map f₂
F G : Quotient r ⥤ D
τ₁ τ₂ : F ⟶ G
h : whiskerLeft (functor r) τ₁ = whiskerLeft (functor r) τ₂
X : C
⊢ τ₁.app { as := X } = τ₂.app { as := X }
state_after: no goals
tactic: exact NatTrans.congr_app h X
Theorem: AdicCompletion.evalₐ_mk
File: Mathlib/RingTheory/AdicCompletion/Algebra.lean

Proof steps:
state_before: R : Type u_1
inst✝² : CommRing R
I : Ideal R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
n : ℕ
x : AdicCauchySequence I R
⊢ (evalₐ I n) ((mk I R) x) = (Ideal.Quotient.mk (I ^ n)) (↑x n)
state_after: no goals
tactic: simp [evalₐ]
Theorem: List.length_sublists
File: Mathlib/Data/List/Sublists.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
l : List α
⊢ l.sublists.length = 2 ^ l.length
state_after: no goals
tactic: simp only [sublists_eq_sublists', length_map, length_sublists', length_reverse]
Theorem: continuous_multiset_prod
File: Mathlib/Topology/Algebra/Monoid.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
X : Type u_5
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : CommMonoid M
inst✝ : ContinuousMul M
f : ι → X → M
s : Multiset ι
⊢ (∀ i ∈ s, Continuous (f i)) → Continuous fun a => (Multiset.map (fun i => f i a) s).prod
state_after: case mk
ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
X : Type u_5
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : CommMonoid M
inst✝ : ContinuousMul M
f : ι → X → M
s : Multiset ι
l : List ι
⊢ (∀ i ∈ Quot.mk Setoid.r l, Continuous (f i)) →
    Continuous fun a => (Multiset.map (fun i => f i a) (Quot.mk Setoid.r l)).prod
tactic: rcases s with ⟨l⟩
state_before: case mk
ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
X : Type u_5
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : CommMonoid M
inst✝ : ContinuousMul M
f : ι → X → M
s : Multiset ι
l : List ι
⊢ (∀ i ∈ Quot.mk Setoid.r l, Continuous (f i)) →
    Continuous fun a => (Multiset.map (fun i => f i a) (Quot.mk Setoid.r l)).prod
state_after: no goals
tactic: simpa using continuous_list_prod l