ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Homeomorph.mulLeft_symm
File: Mathlib/Topology/Algebra/Group/Basic.lean

Proof steps:
state_before: G : Type w
H : Type x
α : Type u
β : Type v
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : ContinuousMul G
a : G
⊢ (Homeomorph.mulLeft a).symm = Homeomorph.mulLeft a⁻¹
state_after: case H
G : Type w
H : Type x
α : Type u
β : Type v
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : ContinuousMul G
a x✝ : G
⊢ (Homeomorph.mulLeft a).symm x✝ = (Homeomorph.mulLeft a⁻¹) x✝
tactic: ext
state_before: case H
G : Type w
H : Type x
α : Type u
β : Type v
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : ContinuousMul G
a x✝ : G
⊢ (Homeomorph.mulLeft a).symm x✝ = (Homeomorph.mulLeft a⁻¹) x✝
state_after: no goals
tactic: rfl
Theorem: HahnSeries.embDomain_add
File: Mathlib/RingTheory/HahnSeries/Addition.lean

Proof steps:
state_before: Γ : Type u_1
R : Type u_2
inst✝² : PartialOrder Γ
inst✝¹ : AddMonoid R
Γ' : Type u_3
inst✝ : PartialOrder Γ'
f : Γ ↪o Γ'
x y : HahnSeries Γ R
⊢ embDomain f (x + y) = embDomain f x + embDomain f y
state_after: case coeff.h
Γ : Type u_1
R : Type u_2
inst✝² : PartialOrder Γ
inst✝¹ : AddMonoid R
Γ' : Type u_3
inst✝ : PartialOrder Γ'
f : Γ ↪o Γ'
x y : HahnSeries Γ R
g : Γ'
⊢ (embDomain f (x + y)).coeff g = (embDomain f x + embDomain f y).coeff g
tactic: ext g
state_before: case coeff.h
Γ : Type u_1
R : Type u_2
inst✝² : PartialOrder Γ
inst✝¹ : AddMonoid R
Γ' : Type u_3
inst✝ : PartialOrder Γ'
f : Γ ↪o Γ'
x y : HahnSeries Γ R
g : Γ'
⊢ (embDomain f (x + y)).coeff g = (embDomain f x + embDomain f y).coeff g
state_after: case pos
Γ : Type u_1
R : Type u_2
inst✝² : PartialOrder Γ
inst✝¹ : AddMonoid R
Γ' : Type u_3
inst✝ : PartialOrder Γ'
f : Γ ↪o Γ'
x y : HahnSeries Γ R
g : Γ'
hg : g ∈ Set.range ⇑f
⊢ (embDomain f (x + y)).coeff g = (embDomain f x + embDomain f y).coeff g

case neg
Γ : Type u_1
R : Type u_2
inst✝² : PartialOrder Γ
inst✝¹ : AddMonoid R
Γ' : Type u_3
inst✝ : PartialOrder Γ'
f : Γ ↪o Γ'
x y : HahnSeries Γ R
g : Γ'
hg : g ∉ Set.range ⇑f
⊢ (embDomain f (x + y)).coeff g = (embDomain f x + embDomain f y).coeff g
tactic: by_cases hg : g ∈ Set.range f
Theorem: biUnion_associatedPrimes_eq_zero_divisors
File: Mathlib/RingTheory/Ideal/AssociatedPrime.lean

Proof steps:
state_before: R : Type u_1
inst✝⁵ : CommRing R
I J : Ideal R
M : Type u_2
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
M' : Type u_3
inst✝² : AddCommGroup M'
inst✝¹ : Module R M'
f : M →ₗ[R] M'
inst✝ : IsNoetherianRing R
⊢ ⋃ p ∈ associatedPrimes R M, ↑p = {r | ∃ x, x ≠ 0 ∧ r • x = 0}
state_after: R : Type u_1
inst✝⁵ : CommRing R
I J : Ideal R
M : Type u_2
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
M' : Type u_3
inst✝² : AddCommGroup M'
inst✝¹ : Module R M'
f : M →ₗ[R] M'
inst✝ : IsNoetherianRing R
⊢ ⋃ p ∈ associatedPrimes R M, ↑p = {r | ∃ x, x ≠ 0 ∧ r ∈ (Submodule.span R {x}).annihilator}
tactic: simp_rw [← Submodule.mem_annihilator_span_singleton]
state_before: R : Type u_1
inst✝⁵ : CommRing R
I J : Ideal R
M : Type u_2
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
M' : Type u_3
inst✝² : AddCommGroup M'
inst✝¹ : Module R M'
f : M →ₗ[R] M'
inst✝ : IsNoetherianRing R
⊢ ⋃ p ∈ associatedPrimes R M, ↑p = {r | ∃ x, x ≠ 0 ∧ r ∈ (Submodule.span R {x}).annihilator}
state_after: case refine_1
R : Type u_1
inst✝⁵ : CommRing R
I J : Ideal R
M : Type u_2
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
M' : Type u_3
inst✝² : AddCommGroup M'
inst✝¹ : Module R M'
f : M →ₗ[R] M'
inst✝ : IsNoetherianRing R
⊢ ∀ i ∈ associatedPrimes R M, ↑i ⊆ {r | ∃ x, x ≠ 0 ∧ r ∈ (Submodule.span R {x}).annihilator}

case refine_2
R : Type u_1
inst✝⁵ : CommRing R
I J : Ideal R
M : Type u_2
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
M' : Type u_3
inst✝² : AddCommGroup M'
inst✝¹ : Module R M'
f : M →ₗ[R] M'
inst✝ : IsNoetherianRing R
⊢ {r | ∃ x, x ≠ 0 ∧ r ∈ (Submodule.span R {x}).annihilator} ⊆ ⋃ p ∈ associatedPrimes R M, ↑p
tactic: refine subset_antisymm (Set.iUnion₂_subset ?_) ?_
Theorem: AlgEquiv.piCongrRight_apply
File: Mathlib/Algebra/Algebra/Pi.lean

Proof steps:
state_before: R : Type u_1
ι : Type u_2
A₁ : ι → Type u_3
A₂ : ι → Type u_4
inst✝⁴ : CommSemiring R
inst✝³ : (i : ι) → Semiring (A₁ i)
inst✝² : (i : ι) → Semiring (A₂ i)
inst✝¹ : (i : ι) → Algebra R (A₁ i)
inst✝ : (i : ι) → Algebra R (A₂ i)
e : (i : ι) → A₁ i ≃ₐ[R] A₂ i
r : R
⊢ { toFun := fun x j => (e j) (x j), invFun := fun x j => (e j).symm (x j), left_inv := ⋯, right_inv := ⋯ }.toFun
      ((algebraMap R ((i : ι) → A₁ i)) r) =
    (algebraMap R ((i : ι) → A₂ i)) r
state_after: case h
R : Type u_1
ι : Type u_2
A₁ : ι → Type u_3
A₂ : ι → Type u_4
inst✝⁴ : CommSemiring R
inst✝³ : (i : ι) → Semiring (A₁ i)
inst✝² : (i : ι) → Semiring (A₂ i)
inst✝¹ : (i : ι) → Algebra R (A₁ i)
inst✝ : (i : ι) → Algebra R (A₂ i)
e : (i : ι) → A₁ i ≃ₐ[R] A₂ i
r : R
i : ι
⊢ { toFun := fun x j => (e j) (x j), invFun := fun x j => (e j).symm (x j), left_inv := ⋯, right_inv := ⋯ }.toFun
      ((algebraMap R ((i : ι) → A₁ i)) r) i =
    (algebraMap R ((i : ι) → A₂ i)) r i
tactic: ext i
state_before: case h
R : Type u_1
ι : Type u_2
A₁ : ι → Type u_3
A₂ : ι → Type u_4
inst✝⁴ : CommSemiring R
inst✝³ : (i : ι) → Semiring (A₁ i)
inst✝² : (i : ι) → Semiring (A₂ i)
inst✝¹ : (i : ι) → Algebra R (A₁ i)
inst✝ : (i : ι) → Algebra R (A₂ i)
e : (i : ι) → A₁ i ≃ₐ[R] A₂ i
r : R
i : ι
⊢ { toFun := fun x j => (e j) (x j), invFun := fun x j => (e j).symm (x j), left_inv := ⋯, right_inv := ⋯ }.toFun
      ((algebraMap R ((i : ι) → A₁ i)) r) i =
    (algebraMap R ((i : ι) → A₂ i)) r i
state_after: no goals
tactic: simp
Theorem: IsOpenMap.preimage_frontier_subset_frontier_preimage
File: Mathlib/Topology/Maps/Basic.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
ι : Type u_4
f : X → Y
g : Y → Z
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
hf : IsOpenMap f
s : Set Y
⊢ f ⁻¹' frontier s ⊆ frontier (f ⁻¹' s)
state_after: no goals
tactic: simpa only [frontier_eq_closure_inter_closure, preimage_inter] using
    inter_subset_inter hf.preimage_closure_subset_closure_preimage
      hf.preimage_closure_subset_closure_preimage
Theorem: single_le_finprod
File: Mathlib/Algebra/BigOperators/Finprod.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M✝ : Type u_5
N : Type u_6
inst✝² : CommMonoid M✝
inst✝¹ : CommMonoid N
f✝ g : α → M✝
a b : α
s t : Set α
M : Type u_7
inst✝ : OrderedCommMonoid M
i : α
f : α → M
hf : (mulSupport f).Finite
h : ∀ (j : α), 1 ≤ f j
⊢ f i ≤ ∏ᶠ (j : α), f j
state_after: no goals
tactic: classical calc
      f i ≤ ∏ j ∈ insert i hf.toFinset, f j :=
        Finset.single_le_prod' (fun j _ => h j) (Finset.mem_insert_self _ _)
      _ = ∏ᶠ j, f j :=
        (finprod_eq_prod_of_mulSupport_toFinset_subset _ hf (Finset.subset_insert _ _)).symm
Theorem: sInf_div
File: Mathlib/Algebra/Order/Pointwise.lean

Proof steps:
state_before: α : Type u_1
inst✝³ : CompleteLattice α
inst✝² : Group α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
s t : Set α
⊢ sInf (s / t) = sInf s / sSup t
state_after: no goals
tactic: simp_rw [div_eq_mul_inv, sInf_mul, sInf_inv]
Theorem: Pell.Solution₁.eq_one_or_neg_one_iff_y_eq_zero
File: Mathlib/NumberTheory/Pell.lean

Proof steps:
state_before: d : ℤ
a : Solution₁ d
⊢ a = 1 ∨ a = -1 ↔ a.y = 0
state_after: d : ℤ
a : Solution₁ d
H : a.y = 0
⊢ a = 1 ∨ a = -1
tactic: refine ⟨fun H => H.elim (fun h => by simp [h]) fun h => by simp [h], fun H => ?_⟩
state_before: d : ℤ
a : Solution₁ d
H : a.y = 0
⊢ a = 1 ∨ a = -1
state_after: d : ℤ
a : Solution₁ d
H : a.y = 0
prop : a.x ^ 2 - d * a.y ^ 2 = 1
⊢ a = 1 ∨ a = -1
tactic: have prop := a.prop
state_before: d : ℤ
a : Solution₁ d
H : a.y = 0
prop : a.x ^ 2 - d * a.y ^ 2 = 1
⊢ a = 1 ∨ a = -1
state_after: d : ℤ
a : Solution₁ d
H : a.y = 0
prop : a.x = 1 ∨ a.x = -1
⊢ a = 1 ∨ a = -1
tactic: rw [H, sq (0 : ℤ), mul_zero, mul_zero, sub_zero, sq_eq_one_iff] at prop
state_before: d : ℤ
a : Solution₁ d
H : a.y = 0
prop : a.x = 1 ∨ a.x = -1
⊢ a = 1 ∨ a = -1
state_after: no goals
tactic: exact prop.imp (fun h => ext h H) fun h => ext h H
Theorem: LinearMap.map_le_map_iff'
File: Mathlib/LinearAlgebra/Span.lean

Proof steps:
state_before: R : Type u_1
R₂ : Type u_2
K : Type u_3
M : Type u_4
M₂ : Type u_5
V : Type u_6
S : Type u_7
inst✝⁸ : Semiring R
inst✝⁷ : Semiring R₂
inst✝⁶ : AddCommGroup M
inst✝⁵ : AddCommGroup M₂
inst✝⁴ : Module R M
inst✝³ : Module R₂ M₂
τ₁₂ : R →+* R₂
inst✝² : RingHomSurjective τ₁₂
F : Type u_8
inst✝¹ : FunLike F M M₂
inst✝ : SemilinearMapClass F τ₁₂ M M₂
f : F
hf : ker f = ⊥
p p' : Submodule R M
⊢ map f p ≤ map f p' ↔ p ≤ p'
state_after: no goals
tactic: rw [LinearMap.map_le_map_iff, hf, sup_bot_eq]
Theorem: ZMod.valMinAbs_spec
File: Mathlib/Data/ZMod/Basic.lean

Proof steps:
state_before: m n✝ n : ℕ
inst✝ : NeZero n
x : ZMod n
y : ℤ
⊢ x.valMinAbs = y → x = ↑y ∧ y * 2 ∈ Set.Ioc (-↑n) ↑n
state_after: m n✝ n : ℕ
inst✝ : NeZero n
x : ZMod n
⊢ x = ↑x.valMinAbs ∧ x.valMinAbs * 2 ∈ Set.Ioc (-↑n) ↑n
tactic: rintro rfl
state_before: m n✝ n : ℕ
inst✝ : NeZero n
x : ZMod n
⊢ x = ↑x.valMinAbs ∧ x.valMinAbs * 2 ∈ Set.Ioc (-↑n) ↑n
state_after: no goals
tactic: exact ⟨x.coe_valMinAbs.symm, x.valMinAbs_mem_Ioc⟩
state_before: m n✝ n : ℕ
inst✝ : NeZero n
x : ZMod n
y : ℤ
h : x = ↑y ∧ y * 2 ∈ Set.Ioc (-↑n) ↑n
⊢ x.valMinAbs = y
state_after: m n✝ n : ℕ
inst✝ : NeZero n
x : ZMod n
y : ℤ
h : x = ↑y ∧ y * 2 ∈ Set.Ioc (-↑n) ↑n
⊢ x.valMinAbs - y = 0
tactic: rw [← sub_eq_zero]
state_before: m n✝ n : ℕ
inst✝ : NeZero n
x : ZMod n
y : ℤ
h : x = ↑y ∧ y * 2 ∈ Set.Ioc (-↑n) ↑n
⊢ x.valMinAbs - y = 0
state_after: case h1
m n✝ n : ℕ
inst✝ : NeZero n
x : ZMod n
y : ℤ
h : x = ↑y ∧ y * 2 ∈ Set.Ioc (-↑n) ↑n
⊢ ↑n ∣ x.valMinAbs - y

case h2
m n✝ n : ℕ
inst✝ : NeZero n
x : ZMod n
y : ℤ
h : x = ↑y ∧ y * 2 ∈ Set.Ioc (-↑n) ↑n
⊢ |x.valMinAbs - y| < ↑n
tactic: apply @Int.eq_zero_of_abs_lt_dvd n
state_before: case h2
m n✝ n : ℕ
inst✝ : NeZero n
x : ZMod n
y : ℤ
h : x = ↑y ∧ y * 2 ∈ Set.Ioc (-↑n) ↑n
⊢ |x.valMinAbs - y| < ↑n
state_after: case h2
m n✝ n : ℕ
inst✝ : NeZero n
x : ZMod n
y : ℤ
h : x = ↑y ∧ y * 2 ∈ Set.Ioc (-↑n) ↑n
⊢ |x.valMinAbs - y| * 2 < ↑n * 2
tactic: rw [← mul_lt_mul_right (@zero_lt_two ℤ _ _ _ _ _)]
state_before: case h2
m n✝ n : ℕ
inst✝ : NeZero n
x : ZMod n
y : ℤ
h : x = ↑y ∧ y * 2 ∈ Set.Ioc (-↑n) ↑n
⊢ |x.valMinAbs - y| * 2 < ↑n * 2
state_after: case h2
m n✝ n : ℕ
inst✝ : NeZero n
x : ZMod n
y : ℤ
h : x = ↑y ∧ y * 2 ∈ Set.Ioc (-↑n) ↑n
⊢ |x.valMinAbs - y| * |2| < ↑n * 2
tactic: nth_rw 1 [← abs_eq_self.2 (@zero_le_two ℤ _ _ _ _)]
state_before: case h2
m n✝ n : ℕ
inst✝ : NeZero n
x : ZMod n
y : ℤ
h : x = ↑y ∧ y * 2 ∈ Set.Ioc (-↑n) ↑n
⊢ |x.valMinAbs - y| * |2| < ↑n * 2
state_after: case h2
m n✝ n : ℕ
inst✝ : NeZero n
x : ZMod n
y : ℤ
h : x = ↑y ∧ y * 2 ∈ Set.Ioc (-↑n) ↑n
⊢ -(↑n * 2) < x.valMinAbs * 2 - y * 2 ∧ x.valMinAbs * 2 - y * 2 < ↑n * 2
tactic: rw [← abs_mul, sub_mul, abs_lt]
state_before: case h2
m n✝ n : ℕ
inst✝ : NeZero n
x : ZMod n
y : ℤ
h : x = ↑y ∧ y * 2 ∈ Set.Ioc (-↑n) ↑n
⊢ -(↑n * 2) < x.valMinAbs * 2 - y * 2 ∧ x.valMinAbs * 2 - y * 2 < ↑n * 2
state_after: no goals
tactic: constructor <;> linarith only [x.valMinAbs_mem_Ioc.1, x.valMinAbs_mem_Ioc.2, h.2.1, h.2.2]
Theorem: Mathlib.Meta.NormNum.isNat_intCast
File: Mathlib/Tactic/NormNum/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Ring R
n : ℤ
m : ℕ
⊢ IsNat n m → IsNat (↑n) m
state_after: case mk.refl
R : Type u_1
inst✝ : Ring R
m : ℕ
⊢ IsNat (↑↑m) m
tactic: rintro ⟨⟨⟩⟩
state_before: case mk.refl
R : Type u_1
inst✝ : Ring R
m : ℕ
⊢ IsNat (↑↑m) m
state_after: no goals
tactic: exact ⟨by simp⟩
Theorem: Orientation.areaForm_swap
File: Mathlib/Analysis/InnerProductSpace/TwoDim.lean

Proof steps:
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace ℝ E
inst✝ : Fact (finrank ℝ E = 2)
o : Orientation ℝ E (Fin 2)
x y : E
⊢ (o.areaForm x) y = -(o.areaForm y) x
state_after: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace ℝ E
inst✝ : Fact (finrank ℝ E = 2)
o : Orientation ℝ E (Fin 2)
x y : E
⊢ o.volumeForm ![x, y] = -o.volumeForm ![y, x]
tactic: simp only [areaForm_to_volumeForm]
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace ℝ E
inst✝ : Fact (finrank ℝ E = 2)
o : Orientation ℝ E (Fin 2)
x y : E
⊢ o.volumeForm ![x, y] = -o.volumeForm ![y, x]
state_after: case h.e'_2.h.e'_6
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace ℝ E
inst✝ : Fact (finrank ℝ E = 2)
o : Orientation ℝ E (Fin 2)
x y : E
⊢ ![x, y] = ![y, x] ∘ ⇑(Equiv.swap 0 1)

E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace ℝ E
inst✝ : Fact (finrank ℝ E = 2)
o : Orientation ℝ E (Fin 2)
x y : E
⊢ 0 ≠ 1
tactic: convert o.volumeForm.map_swap ![y, x] (_ : (0 : Fin 2) ≠ 1)
Theorem: MeasureTheory.Measure.pi_empty_univ
File: Mathlib/MeasureTheory/Constructions/Pi.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
α✝ : ι → Type u_3
inst✝⁴ : Fintype ι
m✝ : (i : ι) → OuterMeasure (α✝ i)
inst✝³ : (i : ι) → MeasurableSpace (α✝ i)
μ✝ : (i : ι) → Measure (α✝ i)
inst✝² : ∀ (i : ι), SigmaFinite (μ✝ i)
α : Type u_4
inst✝¹ : Fintype α
inst✝ : IsEmpty α
β : α → Type u_5
m : (α : α) → MeasurableSpace (β α)
μ : (a : α) → Measure (β a)
⊢ (Measure.pi μ) univ = 1
state_after: no goals
tactic: rw [pi_of_empty, measure_univ]
Theorem: intervalIntegral.integral_of_ge
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

Proof steps:
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
a b : ℝ
f g : ℝ → E
μ : Measure ℝ
h : b ≤ a
⊢ ∫ (x : ℝ) in a..b, f x ∂μ = -∫ (x : ℝ) in Ioc b a, f x ∂μ
state_after: no goals
tactic: simp only [integral_symm b, integral_of_le h]
Theorem: IsLocalization.isInteger_smul
File: Mathlib/RingTheory/Localization/Integer.lean

Proof steps:
state_before: R : Type u_1
inst✝³ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝² : CommSemiring S
inst✝¹ : Algebra R S
P : Type u_3
inst✝ : CommSemiring P
a : R
b : S
hb : IsInteger R b
⊢ IsInteger R (a • b)
state_after: case intro
R : Type u_1
inst✝³ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝² : CommSemiring S
inst✝¹ : Algebra R S
P : Type u_3
inst✝ : CommSemiring P
a : R
b : S
b' : R
hb : (algebraMap R S) b' = b
⊢ IsInteger R (a • b)
tactic: rcases hb with ⟨b', hb⟩
state_before: case intro
R : Type u_1
inst✝³ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝² : CommSemiring S
inst✝¹ : Algebra R S
P : Type u_3
inst✝ : CommSemiring P
a : R
b : S
b' : R
hb : (algebraMap R S) b' = b
⊢ IsInteger R (a • b)
state_after: case h
R : Type u_1
inst✝³ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝² : CommSemiring S
inst✝¹ : Algebra R S
P : Type u_3
inst✝ : CommSemiring P
a : R
b : S
b' : R
hb : (algebraMap R S) b' = b
⊢ (algebraMap R S) (a * b') = a • b
tactic: use a * b'
state_before: case h
R : Type u_1
inst✝³ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝² : CommSemiring S
inst✝¹ : Algebra R S
P : Type u_3
inst✝ : CommSemiring P
a : R
b : S
b' : R
hb : (algebraMap R S) b' = b
⊢ (algebraMap R S) (a * b') = a • b
state_after: no goals
tactic: rw [← hb, (algebraMap R S).map_mul, Algebra.smul_def]
Theorem: Surreal.dyadicMap_apply_pow'
File: Mathlib/SetTheory/Surreal/Dyadic.lean

Proof steps:
state_before: m : ℤ
n : ℕ
⊢ ↑m * powHalf (Submonoid.log (Submonoid.pow 2 n)) = ↑m * powHalf n
state_after: no goals
tactic: rw [@Submonoid.log_pow_int_eq_self 2 one_lt_two]
Theorem: AlgebraicGeometry.PresheafedSpace.IsOpenImmersion.lift_fac
File: Mathlib/Geometry/RingedSpace/OpenImmersion.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y Z : PresheafedSpace C
f : X ⟶ Z
hf : IsOpenImmersion f
g : Y ⟶ Z
s : PullbackCone f g
H : Set.range ⇑g.base ⊆ Set.range ⇑f.base
⊢ lift f g H ≫ f = g
state_after: C : Type u
inst✝ : Category.{v, u} C
X Y Z : PresheafedSpace C
f : X ⟶ Z
hf : IsOpenImmersion f
g : Y ⟶ Z
s : PullbackCone f g
H : Set.range ⇑g.base ⊆ Set.range ⇑f.base
⊢ inv (pullback.snd f g) ≫ pullback.fst f g ≫ f = g
tactic: erw [Category.assoc]
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y Z : PresheafedSpace C
f : X ⟶ Z
hf : IsOpenImmersion f
g : Y ⟶ Z
s : PullbackCone f g
H : Set.range ⇑g.base ⊆ Set.range ⇑f.base
⊢ inv (pullback.snd f g) ≫ pullback.fst f g ≫ f = g
state_after: C : Type u
inst✝ : Category.{v, u} C
X Y Z : PresheafedSpace C
f : X ⟶ Z
hf : IsOpenImmersion f
g : Y ⟶ Z
s : PullbackCone f g
H : Set.range ⇑g.base ⊆ Set.range ⇑f.base
⊢ pullback.fst f g ≫ f = pullback.snd f g ≫ g
tactic: rw [IsIso.inv_comp_eq]
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y Z : PresheafedSpace C
f : X ⟶ Z
hf : IsOpenImmersion f
g : Y ⟶ Z
s : PullbackCone f g
H : Set.range ⇑g.base ⊆ Set.range ⇑f.base
⊢ pullback.fst f g ≫ f = pullback.snd f g ≫ g
state_after: no goals
tactic: exact pullback.condition
Theorem: Fin.succAbove_rev_left
File: Mathlib/Data/Fin/Basic.lean

Proof steps:
state_before: n m : ℕ
p✝ : Fin (n + 1)
i✝ j : Fin n
p : Fin (n + 1)
i : Fin n
⊢ p.rev.succAbove i = (p.succAbove i.rev).rev
state_after: case inl
n m : ℕ
p✝ : Fin (n + 1)
i✝ j : Fin n
p : Fin (n + 1)
i : Fin n
h : i.succ ≤ p.rev
⊢ p.rev.succAbove i = (p.succAbove i.rev).rev

case inr
n m : ℕ
p✝ : Fin (n + 1)
i✝ j : Fin n
p : Fin (n + 1)
i : Fin n
h : p.rev ≤ i.castSucc
⊢ p.rev.succAbove i = (p.succAbove i.rev).rev
tactic: obtain h | h := (rev p).succ_le_or_le_castSucc i
Theorem: AddSubgroup.sup_eq_closure
File: Mathlib/Algebra/Group/Subgroup/Basic.lean

Proof steps:
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝³ : Group G
inst✝² : Group G'
inst✝¹ : Group G''
A : Type u_4
inst✝ : AddGroup A
H✝ K : Subgroup G
k : Set G
H H' : Subgroup G
⊢ H ⊔ H' = closure (↑H ∪ ↑H')
state_after: no goals
tactic: simp_rw [closure_union, closure_eq]
Theorem: MeasureTheory.Measure.restrict_comm
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 α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
hs : MeasurableSet s
⊢ (μ.restrict t).restrict s = (μ.restrict s).restrict t
state_after: no goals
tactic: rw [restrict_restrict hs, restrict_restrict' hs, inter_comm]
Theorem: MeasureTheory.lmarginal_eq_of_subset
File: Mathlib/MeasureTheory/Integral/Marginal.lean

Proof steps:
state_before: δ : Type u_1
δ' : Type u_2
π : δ → Type u_3
inst✝² : (x : δ) → MeasurableSpace (π x)
μ : (i : δ) → Measure (π i)
inst✝¹ : ∀ (i : δ), SigmaFinite (μ i)
inst✝ : DecidableEq δ
s t : Finset δ
f✝ g✝ : ((i : δ) → π i) → ℝ≥0∞
x y : (i : δ) → π i
i : δ
f g : ((i : δ) → π i) → ℝ≥0∞
hst : s ⊆ t
hf : Measurable f
hg : Measurable g
hfg : ∫⋯∫⁻_s, f ∂μ = ∫⋯∫⁻_s, g ∂μ
⊢ ∫⋯∫⁻_t, f ∂μ = ∫⋯∫⁻_t, g ∂μ
state_after: no goals
tactic: rw [← union_sdiff_of_subset hst, lmarginal_union' μ f hf disjoint_sdiff,
    lmarginal_union' μ g hg disjoint_sdiff, hfg]
Theorem: le_of_forall_pos_le_add
File: Mathlib/Algebra/Order/Monoid/Unbundled/ExistsOfLE.lean

Proof steps:
state_before: α : Type u
inst✝⁵ : LinearOrder α
inst✝⁴ : DenselyOrdered α
inst✝³ : Monoid α
inst✝² : ExistsMulOfLE α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : ContravariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
a b : α
h : ∀ (ε : α), 1 < ε → a ≤ b * ε
x : α
hxb : b < x
⊢ a ≤ x
state_after: case intro
α : Type u
inst✝⁵ : LinearOrder α
inst✝⁴ : DenselyOrdered α
inst✝³ : Monoid α
inst✝² : ExistsMulOfLE α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : ContravariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
a b : α
h : ∀ (ε : α), 1 < ε → a ≤ b * ε
ε : α
hxb : b < b * ε
⊢ a ≤ b * ε
tactic: obtain ⟨ε, rfl⟩ := exists_mul_of_le hxb.le
state_before: case intro
α : Type u
inst✝⁵ : LinearOrder α
inst✝⁴ : DenselyOrdered α
inst✝³ : Monoid α
inst✝² : ExistsMulOfLE α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : ContravariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
a b : α
h : ∀ (ε : α), 1 < ε → a ≤ b * ε
ε : α
hxb : b < b * ε
⊢ a ≤ b * ε
state_after: no goals
tactic: exact h _ ((lt_mul_iff_one_lt_right' b).1 hxb)
Theorem: Polynomial.degree_of_subsingleton
File: Mathlib/Algebra/Polynomial/Degree/Definitions.lean

Proof steps:
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝¹ : Semiring R
p q r : R[X]
inst✝ : Subsingleton R
⊢ p.degree = ⊥
state_after: no goals
tactic: rw [Subsingleton.elim p 0, degree_zero]
Theorem: Int.ModEq.pow_card_sub_one_eq_one
File: Mathlib/FieldTheory/Finite/Basic.lean

Proof steps:
state_before: K : Type u_1
R : Type u_2
p : ℕ
hp : Nat.Prime p
n : ℤ
hpn : IsCoprime n ↑p
⊢ n ^ (p - 1) ≡ 1 [ZMOD ↑p]
state_after: K : Type u_1
R : Type u_2
p : ℕ
hp : Nat.Prime p
n : ℤ
hpn : IsCoprime n ↑p
this : Fact (Nat.Prime p)
⊢ n ^ (p - 1) ≡ 1 [ZMOD ↑p]
tactic: haveI : Fact p.Prime := ⟨hp⟩
state_before: K : Type u_1
R : Type u_2
p : ℕ
hp : Nat.Prime p
n : ℤ
hpn : IsCoprime n ↑p
this✝ : Fact (Nat.Prime p)
this : ¬↑n = 0
⊢ n ^ (p - 1) ≡ 1 [ZMOD ↑p]
state_after: no goals
tactic: simpa [← ZMod.intCast_eq_intCast_iff] using ZMod.pow_card_sub_one_eq_one this
Theorem: nhdsSet_inj_iff
File: Mathlib/Topology/Separation.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : T1Space X
s t : Set X
⊢ 𝓝ˢ s = 𝓝ˢ t ↔ s = t
state_after: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : T1Space X
s t : Set X
⊢ 𝓝ˢ s ≤ 𝓝ˢ t ∧ 𝓝ˢ t ≤ 𝓝ˢ s ↔ s ≤ t ∧ t ≤ s
tactic: simp_rw [le_antisymm_iff]
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : T1Space X
s t : Set X
⊢ 𝓝ˢ s ≤ 𝓝ˢ t ∧ 𝓝ˢ t ≤ 𝓝ˢ s ↔ s ≤ t ∧ t ≤ s
state_after: no goals
tactic: exact and_congr nhdsSet_le_iff nhdsSet_le_iff
Theorem: neg_of_add_lt_left
File: Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : MulOneClass α
inst✝¹ : LT α
inst✝ : ContravariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x < x_1
a b : α
h : a * b < b
⊢ a * b < 1 * b
state_after: no goals
tactic: simpa only [one_mul]
Theorem: RatFunc.intDegree_zero
File: Mathlib/FieldTheory/RatFunc/Degree.lean

Proof steps:
state_before: K : Type u
inst✝ : Field K
⊢ intDegree 0 = 0
state_after: no goals
tactic: rw [intDegree, num_zero, natDegree_zero, denom_zero, natDegree_one, sub_self]
Theorem: Set.pi_inter_compl
File: Mathlib/Data/Set/Prod.lean

Proof steps:
state_before: ι : Type u_1
α : ι → Type u_2
β : ι → Type u_3
s✝ s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
i : ι
s : Set ι
⊢ s.pi t ∩ sᶜ.pi t = univ.pi t
state_after: no goals
tactic: rw [← union_pi, union_compl_self]
Theorem: mul_pos_iff_of_pos_right
File: Mathlib/Algebra/Order/GroupWithZero/Unbundled.lean

Proof steps:
state_before: α : Type u_1
a b c d : α
inst✝³ : MulZeroClass α
inst✝² : Preorder α
inst✝¹ : MulPosStrictMono α
inst✝ : MulPosReflectLT α
h : 0 < b
⊢ 0 < a * b ↔ 0 < a
state_after: no goals
tactic: simpa using mul_lt_mul_right (b := 0) h