ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: FractionalIdeal.spanSingleton_mul_spanSingleton
File: Mathlib/RingTheory/FractionalIdeal/Operations.lean

Proof steps:
state_before: R : Type u_1
inst✝⁶ : CommRing R
S : Submonoid R
P : Type u_2
inst✝⁵ : CommRing P
inst✝⁴ : Algebra R P
loc : IsLocalization S P
R₁ : Type u_3
inst✝³ : CommRing R₁
K : Type u_4
inst✝² : Field K
inst✝¹ : Algebra R₁ K
inst✝ : IsFractionRing R₁ K
x y : P
⊢ spanSingleton S x * spanSingleton S y = spanSingleton S (x * y)
state_after: case a
R : Type u_1
inst✝⁶ : CommRing R
S : Submonoid R
P : Type u_2
inst✝⁵ : CommRing P
inst✝⁴ : Algebra R P
loc : IsLocalization S P
R₁ : Type u_3
inst✝³ : CommRing R₁
K : Type u_4
inst✝² : Field K
inst✝¹ : Algebra R₁ K
inst✝ : IsFractionRing R₁ K
x y : P
⊢ (fun I => ↑I) (spanSingleton S x * spanSingleton S y) = (fun I => ↑I) (spanSingleton S (x * y))
tactic: apply coeToSubmodule_injective
state_before: case a
R : Type u_1
inst✝⁶ : CommRing R
S : Submonoid R
P : Type u_2
inst✝⁵ : CommRing P
inst✝⁴ : Algebra R P
loc : IsLocalization S P
R₁ : Type u_3
inst✝³ : CommRing R₁
K : Type u_4
inst✝² : Field K
inst✝¹ : Algebra R₁ K
inst✝ : IsFractionRing R₁ K
x y : P
⊢ (fun I => ↑I) (spanSingleton S x * spanSingleton S y) = (fun I => ↑I) (spanSingleton S (x * y))
state_after: no goals
tactic: simp only [coe_mul, coe_spanSingleton, span_mul_span, singleton_mul_singleton]
Theorem: Submodule.IsPrincipal.mem_iff_generator_dvd
File: Mathlib/RingTheory/PrincipalIdealDomain.lean

Proof steps:
state_before: R : Type u
M : Type v
inst✝³ : AddCommGroup M
inst✝² : CommRing R
inst✝¹ : Module R M
S : Ideal R
inst✝ : IsPrincipal S
x a : R
⊢ x = a • generator S ↔ x = generator S * a
state_after: no goals
tactic: simp only [mul_comm, smul_eq_mul]
Theorem: eq_compl_comm
File: Mathlib/Order/BooleanAlgebra.lean

Proof steps:
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : BooleanAlgebra α
⊢ x = yᶜ ↔ y = xᶜ
state_after: no goals
tactic: rw [eq_comm, compl_eq_iff_isCompl, eq_compl_iff_isCompl]
Theorem: MeasureTheory.Measure.rnDeriv_ne_top
File: Mathlib/MeasureTheory/Decomposition/Lebesgue.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
inst✝ : SigmaFinite μ
⊢ ∀ᵐ (x : α) ∂ν, μ.rnDeriv ν x ≠ ⊤
state_after: no goals
tactic: filter_upwards [Measure.rnDeriv_lt_top μ ν] with x hx using hx.ne
Theorem: Set.prod_eq_biUnion_right
File: Mathlib/Data/Set/Lattice.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
f : α → β → γ
s : Set α
t : Set β
⊢ s ×ˢ t = ⋃ b ∈ t, (fun a => (a, b)) '' s
state_after: no goals
tactic: rw [iUnion_image_right, image2_mk_eq_prod]
Theorem: Computation.destruct_eq_think
File: Mathlib/Data/Seq/Computation.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
s s' : Computation α
⊢ s.destruct = Sum.inr s' → s = s'.think
state_after: α : Type u
β : Type v
γ : Type w
s s' : Computation α
⊢ (match ↑s 0 with
      | none => Sum.inr s.tail
      | some a => Sum.inl a) =
      Sum.inr s' →
    s = s'.think
tactic: dsimp [destruct]
state_before: α : Type u
β : Type v
γ : Type w
s s' : Computation α
⊢ (match ↑s 0 with
      | none => Sum.inr s.tail
      | some a => Sum.inl a) =
      Sum.inr s' →
    s = s'.think
state_after: case none
α : Type u
β : Type v
γ : Type w
s s' : Computation α
f0 : ↑s 0 = none
h :
  (match none with
    | none => Sum.inr s.tail
    | some a => Sum.inl a) =
    Sum.inr s'
⊢ s = s'.think

case some
α : Type u
β : Type v
γ : Type w
s s' : Computation α
a' : α
f0 : ↑s 0 = some a'
h :
  (match some a' with
    | none => Sum.inr s.tail
    | some a => Sum.inl a) =
    Sum.inr s'
⊢ s = s'.think
tactic: induction' f0 : s.1 0 with a' <;> intro h
Theorem: List.set_eq_modifyNth
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: α : Type u_1
a : α
l : List α
⊢ l.set 0 a = modifyNth (fun x => a) 0 l
state_after: no goals
tactic: cases l <;> rfl
Theorem: CategoryTheory.Presieve.Arrows.Compatible.familyOfElements_compatible
File: Mathlib/CategoryTheory/Sites/IsSheafFor.lean

Proof steps:
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
P Q U : Cᵒᵖ ⥤ Type w
X✝ Y : C
S : Sieve X✝
R : Presieve X✝
B : C
I : Type u_1
X : I → C
π : (i : I) → X i ⟶ B
x : (i : I) → P.obj (op (X i))
hx : Compatible P π x
⊢ hx.familyOfElements.Compatible
state_after: case mk.mk
C : Type u₁
inst✝ : Category.{v₁, u₁} C
P Q U : Cᵒᵖ ⥤ Type w
X✝ Y✝¹ : C
S : Sieve X✝
R : Presieve X✝
B : C
I : Type u_1
X : I → C
π : (i : I) → X i ⟶ B
x : (i : I) → P.obj (op (X i))
hx : Compatible P π x
Z Y✝ : C
i : I
g₁ : Z ⟶ X i
Y : C
j : I
g₂ : Z ⟶ X j
hgf : g₁ ≫ π i = g₂ ≫ π j
⊢ P.map g₁.op (hx.familyOfElements (π i) ⋯) = P.map g₂.op (hx.familyOfElements (π j) ⋯)
tactic: rintro Y₁ Y₂ Z g₁ g₂ f₁ f₂ ⟨i⟩ ⟨j⟩ hgf
state_before: case mk.mk
C : Type u₁
inst✝ : Category.{v₁, u₁} C
P Q U : Cᵒᵖ ⥤ Type w
X✝ Y✝¹ : C
S : Sieve X✝
R : Presieve X✝
B : C
I : Type u_1
X : I → C
π : (i : I) → X i ⟶ B
x : (i : I) → P.obj (op (X i))
hx : Compatible P π x
Z Y✝ : C
i : I
g₁ : Z ⟶ X i
Y : C
j : I
g₂ : Z ⟶ X j
hgf : g₁ ≫ π i = g₂ ≫ π j
⊢ P.map g₁.op (hx.familyOfElements (π i) ⋯) = P.map g₂.op (hx.familyOfElements (π j) ⋯)
state_after: no goals
tactic: simp [hx i j Z g₁ g₂ hgf]
Theorem: Mathlib.Tactic.Ring.neg_one_mul
File: Mathlib/Tactic/Ring/Basic.lean

Proof steps:
state_before: u✝ : Lean.Level
arg : Q(Type u✝)
sα✝ : Q(CommSemiring «$arg»)
u : Lean.Level
α : Q(Type u)
sα : Q(CommSemiring «$α»)
R✝ : Type u_1
inst✝¹ : CommSemiring R✝
a✝ a' a₁ a₂ a₃ b✝ b' b₁ b₂ b₃ c c₁ c₂ : R✝
R : Type u_2
inst✝ : Ring R
a b : R
x✝ : (Int.negOfNat 1).rawCast * a = b
⊢ -a = b
state_after: u✝ : Lean.Level
arg : Q(Type u✝)
sα✝ : Q(CommSemiring «$arg»)
u : Lean.Level
α : Q(Type u)
sα : Q(CommSemiring «$α»)
R✝ : Type u_1
inst✝¹ : CommSemiring R✝
a✝ a' a₁ a₂ a₃ b b' b₁ b₂ b₃ c c₁ c₂ : R✝
R : Type u_2
inst✝ : Ring R
a : R
⊢ -a = (Int.negOfNat 1).rawCast * a
tactic: subst_vars
state_before: u✝ : Lean.Level
arg : Q(Type u✝)
sα✝ : Q(CommSemiring «$arg»)
u : Lean.Level
α : Q(Type u)
sα : Q(CommSemiring «$α»)
R✝ : Type u_1
inst✝¹ : CommSemiring R✝
a✝ a' a₁ a₂ a₃ b b' b₁ b₂ b₃ c c₁ c₂ : R✝
R : Type u_2
inst✝ : Ring R
a : R
⊢ -a = (Int.negOfNat 1).rawCast * a
state_after: no goals
tactic: simp [Int.negOfNat]
Theorem: gauge_pos
File: Mathlib/Analysis/Convex/Gauge.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝³ : AddCommGroup E
inst✝² : Module ℝ E
s t : Set E
x : E
a : ℝ
inst✝¹ : TopologicalSpace E
inst✝ : T1Space E
hs : Absorbent ℝ s
hb : Bornology.IsVonNBounded ℝ s
⊢ 0 < gauge s x ↔ x ≠ 0
state_after: no goals
tactic: simp only [(gauge_nonneg _).gt_iff_ne, Ne, gauge_eq_zero hs hb]
Theorem: Basis.dualBasis_equivFun
File: Mathlib/LinearAlgebra/Dual.lean

Proof steps:
state_before: R : Type uR
M : Type uM
K : Type uK
V : Type uV
ι : Type uι
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : DecidableEq ι
b : Basis ι R M
inst✝ : _root_.Finite ι
l : Dual R M
i : ι
⊢ b.dualBasis.equivFun l i = l (b i)
state_after: no goals
tactic: rw [Basis.equivFun_apply, dualBasis_repr]
Theorem: Matroid.exists_basis_union_inter_basis
File: Mathlib/Data/Matroid/Basic.lean

Proof steps:
state_before: α : Type u_1
M✝ : Matroid α
B I✝ J✝ X✝ Y✝ : Set α
e : α
M : Matroid α
X Y : Set α
hX : autoParam (X ⊆ M.E) _auto✝
hY : autoParam (Y ⊆ M.E) _auto✝
J : Set α
hJ : M.Basis J Y
I : Set α
hI : M.Basis I (X ∪ Y) ∧ I ∩ Y = J
⊢ M.Basis (I ∩ Y) Y
state_after: no goals
tactic: rwa [hI.2]
Theorem: ENNReal.ofReal_one
File: Mathlib/Data/ENNReal/Basic.lean

Proof steps:
state_before: α : Type u_1
a b c d : ℝ≥0∞
r p q : ℝ≥0
⊢ ENNReal.ofReal 1 = 1
state_after: no goals
tactic: simp [ENNReal.ofReal]
Theorem: EuclideanGeometry.inversion_mem_perpBisector_inversion_iff'
File: Mathlib/Geometry/Euclidean/Inversion/ImageHyperplane.lean

Proof steps:
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
c x y : P
R : ℝ
hR : R ≠ 0
hy : y ≠ c
⊢ inversion c R x ∈ perpBisector c (inversion c R y) ↔ dist x y = dist y c ∧ x ≠ c
state_after: case inl
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
x y : P
R : ℝ
hR : R ≠ 0
hy : y ≠ x
⊢ inversion x R x ∈ perpBisector x (inversion x R y) ↔ dist x y = dist y x ∧ x ≠ x

case inr
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
c x y : P
R : ℝ
hR : R ≠ 0
hy : y ≠ c
hx : x ≠ c
⊢ inversion c R x ∈ perpBisector c (inversion c R y) ↔ dist x y = dist y c ∧ x ≠ c
tactic: rcases eq_or_ne x c with rfl | hx
Theorem: Real.not_bddBelow_coe
File: Mathlib/Data/Real/Archimedean.lean

Proof steps:
state_before: ⊢ ¬BddBelow (range fun x => ↑x)
state_after: ⊢ ¬{x | ∀ ⦃a : ℝ⦄, (a ∈ range fun x => ↑x) → x ≤ a}.Nonempty
tactic: dsimp only [BddBelow, lowerBounds]
state_before: ⊢ ¬{x | ∀ ⦃a : ℝ⦄, (a ∈ range fun x => ↑x) → x ≤ a}.Nonempty
state_after: ⊢ {x | ∀ ⦃a : ℝ⦄, (a ∈ range fun x => ↑x) → x ≤ a} = ∅
tactic: rw [Set.not_nonempty_iff_eq_empty]
state_before: ⊢ {x | ∀ ⦃a : ℝ⦄, (a ∈ range fun x => ↑x) → x ≤ a} = ∅
state_after: case h
x✝ : ℝ
⊢ x✝ ∈ {x | ∀ ⦃a : ℝ⦄, (a ∈ range fun x => ↑x) → x ≤ a} ↔ x✝ ∈ ∅
tactic: ext
state_before: case h
x✝ : ℝ
⊢ x✝ ∈ {x | ∀ ⦃a : ℝ⦄, (a ∈ range fun x => ↑x) → x ≤ a} ↔ x✝ ∈ ∅
state_after: no goals
tactic: simpa using exists_rat_lt _
Theorem: le_one_of_mul_le_left
File: Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : MulOneClass α
inst✝¹ : LE α
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: Complex.ofReal_pow
File: Mathlib/Data/Complex/Basic.lean

Proof steps:
state_before: r : ℝ
n : ℕ
⊢ ↑(r ^ n) = ↑r ^ n
state_after: no goals
tactic: induction n <;> simp [*, ofReal_mul, pow_succ]
Theorem: MeasurableSpace.compl_mem_generateMeasurableRec
File: Mathlib/MeasureTheory/MeasurableSpace/Card.lean

Proof steps:
state_before: α : Type u
s : Set (Set α)
i j : (Quotient.out (aleph 1).ord).α
h : j < i
t : Set α
ht : t ∈ generateMeasurableRec s j
⊢ tᶜ ∈ generateMeasurableRec s i
state_after: α : Type u
s : Set (Set α)
i j : (Quotient.out (aleph 1).ord).α
h : j < i
t : Set α
ht : t ∈ generateMeasurableRec s j
⊢ tᶜ ∈
    let i := i;
    let S := ⋃ j, generateMeasurableRec s ↑j;
    s ∪ {∅} ∪ compl '' S ∪ range fun f => ⋃ n, ↑(f n)
tactic: unfold generateMeasurableRec
state_before: α : Type u
s : Set (Set α)
i j : (Quotient.out (aleph 1).ord).α
h : j < i
t : Set α
ht : t ∈ generateMeasurableRec s j
⊢ tᶜ ∈
    let i := i;
    let S := ⋃ j, generateMeasurableRec s ↑j;
    s ∪ {∅} ∪ compl '' S ∪ range fun f => ⋃ n, ↑(f n)
state_after: no goals
tactic: exact mem_union_left _ (mem_union_right _ ⟨t, mem_iUnion.2 ⟨⟨j, h⟩, ht⟩, rfl⟩)
Theorem: Filter.atTop_eq_generate_of_forall_exists_le
File: Mathlib/Order/Filter/AtTopBot.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝ : LinearOrder α
s : Set α
hs : ∀ (x : α), ∃ y ∈ s, x ≤ y
⊢ atTop = generate (Ici '' s)
state_after: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝ : LinearOrder α
s : Set α
hs : ∀ (x : α), ∃ y ∈ s, x ≤ y
⊢ generate (range Ici) = generate (Ici '' s)
tactic: rw [atTop_eq_generate_Ici]
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝ : LinearOrder α
s : Set α
hs : ∀ (x : α), ∃ y ∈ s, x ≤ y
⊢ generate (range Ici) = generate (Ici '' s)
state_after: case a
ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝ : LinearOrder α
s : Set α
hs : ∀ (x : α), ∃ y ∈ s, x ≤ y
⊢ generate (range Ici) ≤ generate (Ici '' s)

case a
ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝ : LinearOrder α
s : Set α
hs : ∀ (x : α), ∃ y ∈ s, x ≤ y
⊢ generate (Ici '' s) ≤ generate (range Ici)
tactic: apply le_antisymm
Theorem: MeasureTheory.lintegral_nnnorm_le_of_forall_fin_meas_integral_eq
File: Mathlib/MeasureTheory/Function/ConditionalExpectation/Unique.lean

Proof steps:
state_before: α : Type u_1
E' : Type u_2
F' : Type u_3
𝕜 : Type u_4
p : ℝ≥0∞
m m0 : MeasurableSpace α
μ : Measure α
inst✝⁸ : RCLike 𝕜
inst✝⁷ : NormedAddCommGroup E'
inst✝⁶ : InnerProductSpace 𝕜 E'
inst✝⁵ : CompleteSpace E'
inst✝⁴ : NormedSpace ℝ E'
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace 𝕜 F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : CompleteSpace F'
s : Set α
hm : m ≤ m0
f g : α → ℝ
hf : StronglyMeasurable f
hfi : IntegrableOn f s μ
hg : StronglyMeasurable g
hgi : IntegrableOn g s μ
hgf : ∀ (t : Set α), MeasurableSet t → μ t < ⊤ → ∫ (x : α) in t, g x ∂μ = ∫ (x : α) in t, f x ∂μ
hs : MeasurableSet s
hμs : μ s ≠ ⊤
⊢ ∫⁻ (x : α) in s, ↑‖g x‖₊ ∂μ ≤ ∫⁻ (x : α) in s, ↑‖f x‖₊ ∂μ
state_after: α : Type u_1
E' : Type u_2
F' : Type u_3
𝕜 : Type u_4
p : ℝ≥0∞
m m0 : MeasurableSpace α
μ : Measure α
inst✝⁸ : RCLike 𝕜
inst✝⁷ : NormedAddCommGroup E'
inst✝⁶ : InnerProductSpace 𝕜 E'
inst✝⁵ : CompleteSpace E'
inst✝⁴ : NormedSpace ℝ E'
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace 𝕜 F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : CompleteSpace F'
s : Set α
hm : m ≤ m0
f g : α → ℝ
hf : StronglyMeasurable f
hfi : IntegrableOn f s μ
hg : StronglyMeasurable g
hgi : IntegrableOn g s μ
hgf : ∀ (t : Set α), MeasurableSet t → μ t < ⊤ → ∫ (x : α) in t, g x ∂μ = ∫ (x : α) in t, f x ∂μ
hs : MeasurableSet s
hμs : μ s ≠ ⊤
⊢ ∫ (x : α) in s, ‖g x‖ ∂μ ≤ ∫ (x : α) in s, ‖f x‖ ∂μ

α : Type u_1
E' : Type u_2
F' : Type u_3
𝕜 : Type u_4
p : ℝ≥0∞
m m0 : MeasurableSpace α
μ : Measure α
inst✝⁸ : RCLike 𝕜
inst✝⁷ : NormedAddCommGroup E'
inst✝⁶ : InnerProductSpace 𝕜 E'
inst✝⁵ : CompleteSpace E'
inst✝⁴ : NormedSpace ℝ E'
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace 𝕜 F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : CompleteSpace F'
s : Set α
hm : m ≤ m0
f g : α → ℝ
hf : StronglyMeasurable f
hfi : IntegrableOn f s μ
hg : StronglyMeasurable g
hgi : IntegrableOn g s μ
hgf : ∀ (t : Set α), MeasurableSet t → μ t < ⊤ → ∫ (x : α) in t, g x ∂μ = ∫ (x : α) in t, f x ∂μ
hs : MeasurableSet s
hμs : μ s ≠ ⊤
⊢ 0 ≤ ∫ (x : α) in s, ‖f x‖ ∂μ
tactic: rw [← ofReal_integral_norm_eq_lintegral_nnnorm hfi, ←
    ofReal_integral_norm_eq_lintegral_nnnorm hgi, ENNReal.ofReal_le_ofReal_iff]
Theorem: PosNum.minFac_to_nat
File: Mathlib/Data/Num/Prime.lean

Proof steps:
state_before: n : PosNum
⊢ ↑n.minFac = (↑n).minFac
state_after: case one

⊢ ↑one.minFac = (↑one).minFac

case bit1
n : PosNum
⊢ ↑n.bit1.minFac = (↑n.bit1).minFac

case bit0
a✝ : PosNum
⊢ ↑a✝.bit0.minFac = (↑a✝.bit0).minFac
tactic: cases' n with n
Theorem: Finset.map_add_right_Icc
File: Mathlib/Algebra/Order/Interval/Finset.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
inst✝² : OrderedCancelAddCommMonoid α
inst✝¹ : ExistsAddOfLE α
inst✝ : LocallyFiniteOrder α
a b c : α
⊢ map (addRightEmbedding c) (Icc a b) = Icc (a + c) (b + c)
state_after: ι : Type u_1
α : Type u_2
inst✝² : OrderedCancelAddCommMonoid α
inst✝¹ : ExistsAddOfLE α
inst✝ : LocallyFiniteOrder α
a b c : α
⊢ ⇑(addRightEmbedding c) '' Set.Icc a b = Set.Icc (a + c) (b + c)
tactic: rw [← coe_inj, coe_map, coe_Icc, coe_Icc]
state_before: ι : Type u_1
α : Type u_2
inst✝² : OrderedCancelAddCommMonoid α
inst✝¹ : ExistsAddOfLE α
inst✝ : LocallyFiniteOrder α
a b c : α
⊢ ⇑(addRightEmbedding c) '' Set.Icc a b = Set.Icc (a + c) (b + c)
state_after: no goals
tactic: exact Set.image_add_const_Icc _ _ _
Theorem: _private.Mathlib.Algebra.Module.LocalizedModule.0.LocalizedModule.zero_add'
File: Mathlib/Algebra/Module/LocalizedModule.lean

Proof steps:
state_before: R : Type u
inst✝⁵ : CommSemiring R
S : Submonoid R
M : Type v
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
T : Type u_1
inst✝² : CommSemiring T
inst✝¹ : Algebra R T
inst✝ : IsLocalization S T
x : LocalizedModule S M
m : M
s : ↥S
⊢ 0 + mk m s = mk m s
state_after: R : Type u
inst✝⁵ : CommSemiring R
S : Submonoid R
M : Type v
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
T : Type u_1
inst✝² : CommSemiring T
inst✝¹ : Algebra R T
inst✝ : IsLocalization S T
x : LocalizedModule S M
m : M
s : ↥S
⊢ ∃ u, u • s • s • m = u • (s * s) • m
tactic: rw [← zero_mk s, mk_add_mk, smul_zero, zero_add, mk_eq]
state_before: R : Type u
inst✝⁵ : CommSemiring R
S : Submonoid R
M : Type v
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
T : Type u_1
inst✝² : CommSemiring T
inst✝¹ : Algebra R T
inst✝ : IsLocalization S T
x : LocalizedModule S M
m : M
s : ↥S
⊢ ∃ u, u • s • s • m = u • (s * s) • m
state_after: no goals
tactic: exact ⟨1, by rw [one_smul, mul_smul, one_smul]⟩
Theorem: continuousAt_congr
File: Mathlib/Topology/Basic.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
f : X → Y
s : Set X
x : X
y : Y
g : X → Y
h : f =ᶠ[𝓝 x] g
⊢ ContinuousAt f x ↔ ContinuousAt g x
state_after: no goals
tactic: simp only [ContinuousAt, tendsto_congr' h, h.eq_of_nhds]
Theorem: Finset.Ioc_subset_Ioi_self
File: Mathlib/Order/Interval/Finset/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
inst✝² : Preorder α
inst✝¹ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
inst✝ : LocallyFiniteOrderTop α
⊢ Ioc a b ⊆ Ioi a
state_after: no goals
tactic: simpa [← coe_subset] using Set.Ioc_subset_Ioi_self
Theorem: Polynomial.degree_X_pow_sub_C
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✝¹ : Ring R
inst✝ : Nontrivial R
n : ℕ
hn : 0 < n
a : R
⊢ (X ^ n - C a).degree = ↑n
state_after: no goals
tactic: rw [sub_eq_add_neg, ← map_neg C a, degree_X_pow_add_C hn]
Theorem: ENNReal.zero_rpow_of_pos
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

Proof steps:
state_before: y : ℝ
h : 0 < y
⊢ 0 ^ y = 0
state_after: y : ℝ
h : 0 < y
⊢ some 0 ^ y = some 0
tactic: rw [← ENNReal.coe_zero, ← ENNReal.some_eq_coe]
state_before: y : ℝ
h : 0 < y
⊢ (if 0 = 0 ∧ y < 0 then ⊤ else ↑(NNReal.rpow 0 y)) = some 0
state_after: no goals
tactic: simp [h, asymm h, ne_of_gt h]
Theorem: Cardinal.cantorFunctionAux_eq
File: Mathlib/Data/Real/Cardinality.lean

Proof steps:
state_before: c : ℝ
f g : ℕ → Bool
n : ℕ
h : f n = g n
⊢ cantorFunctionAux c f n = cantorFunctionAux c g n
state_after: no goals
tactic: simp [cantorFunctionAux, h]
Theorem: CategoryTheory.Functor.Initial.limit_cone_comp_aux
File: Mathlib/CategoryTheory/Limits/Final.lean

Proof steps:
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
F : C ⥤ D
inst✝¹ : F.Initial
E : Type u₃
inst✝ : Category.{v₃, u₃} E
G : D ⥤ E
s : Cone (F ⋙ G)
j : C
⊢ s.π.app (lift F (F.obj j)) ≫ G.map (homToLift F (F.obj j)) = s.π.app j
state_after: case h₁
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
F : C ⥤ D
inst✝¹ : F.Initial
E : Type u₃
inst✝ : Category.{v₃, u₃} E
G : D ⥤ E
s : Cone (F ⋙ G)
j : C
⊢ ∀ (X₁ X₂ : C) (k₁ : F.obj X₁ ⟶ F.obj j) (k₂ : F.obj X₂ ⟶ F.obj j) (f : X₁ ⟶ X₂),
    F.map f ≫ k₂ = k₁ → s.π.app X₁ ≫ G.map k₁ = s.π.app j → s.π.app X₂ ≫ G.map k₂ = s.π.app j

case h₂
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
F : C ⥤ D
inst✝¹ : F.Initial
E : Type u₃
inst✝ : Category.{v₃, u₃} E
G : D ⥤ E
s : Cone (F ⋙ G)
j : C
⊢ ∀ (X₁ X₂ : C) (k₁ : F.obj X₁ ⟶ F.obj j) (k₂ : F.obj X₂ ⟶ F.obj j) (f : X₁ ⟶ X₂),
    F.map f ≫ k₂ = k₁ → s.π.app X₂ ≫ G.map k₂ = s.π.app j → s.π.app X₁ ≫ G.map k₁ = s.π.app j

case z
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
F : C ⥤ D
inst✝¹ : F.Initial
E : Type u₃
inst✝ : Category.{v₃, u₃} E
G : D ⥤ E
s : Cone (F ⋙ G)
j : C
⊢ s.π.app ?X₀ ≫ G.map ?k₀ = s.π.app j

case X₀
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
F : C ⥤ D
inst✝¹ : F.Initial
E : Type u₃
inst✝ : Category.{v₃, u₃} E
G : D ⥤ E
s : Cone (F ⋙ G)
j : C
⊢ C

case k₀
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
F : C ⥤ D
inst✝¹ : F.Initial
E : Type u₃
inst✝ : Category.{v₃, u₃} E
G : D ⥤ E
s : Cone (F ⋙ G)
j : C
⊢ F.obj ?X₀ ⟶ F.obj j
tactic: apply induction F fun X k => s.π.app X ≫ G.map k = (s.π.app j : _)
Theorem: MeasureTheory.AEStronglyMeasurable.truncation
File: Mathlib/Probability/StrongLaw.lean

Proof steps:
state_before: α : Type u_1
m : MeasurableSpace α
μ : Measure α
f : α → ℝ
hf : AEStronglyMeasurable f μ
A : ℝ
⊢ AEStronglyMeasurable (ProbabilityTheory.truncation f A) μ
state_after: α : Type u_1
m : MeasurableSpace α
μ : Measure α
f : α → ℝ
hf : AEStronglyMeasurable f μ
A : ℝ
⊢ AEStronglyMeasurable ((Set.Ioc (-A) A).indicator id) (Measure.map f μ)
tactic: apply AEStronglyMeasurable.comp_aemeasurable _ hf.aemeasurable
state_before: α : Type u_1
m : MeasurableSpace α
μ : Measure α
f : α → ℝ
hf : AEStronglyMeasurable f μ
A : ℝ
⊢ AEStronglyMeasurable ((Set.Ioc (-A) A).indicator id) (Measure.map f μ)
state_after: no goals
tactic: exact (stronglyMeasurable_id.indicator measurableSet_Ioc).aestronglyMeasurable
Theorem: mem_fixingSubgroup_compl_iff_movedBy_subset
File: Mathlib/GroupTheory/GroupAction/FixingSubgroup.lean

Proof steps:
state_before: M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
s : Set α
m : M
⊢ m ∈ fixingSubgroup M sᶜ ↔ (fixedBy α m)ᶜ ⊆ s
state_after: no goals
tactic: rw [mem_fixingSubgroup_iff_subset_fixedBy, Set.compl_subset_comm]
Theorem: CategoryTheory.MorphismProperty.IsCompatibleWithShift.iff
File: Mathlib/CategoryTheory/Shift/Localization.lean

Proof steps:
state_before: C : Type u₁
D : Type u₂
inst✝⁶ : Category.{v₁, u₁} C
inst✝⁵ : Category.{v₂, u₂} D
E : Type u₃
inst✝⁴ : Category.{v₃, u₃} E
L : C ⥤ D
W : MorphismProperty C
inst✝³ : L.IsLocalization W
A : Type w
inst✝² : AddMonoid A
inst✝¹ : HasShift C A
inst✝ : W.IsCompatibleWithShift A
X Y : C
f : X ⟶ Y
a : A
⊢ W ((shiftFunctor C a).map f) ↔ W f
state_after: C : Type u₁
D : Type u₂
inst✝⁶ : Category.{v₁, u₁} C
inst✝⁵ : Category.{v₂, u₂} D
E : Type u₃
inst✝⁴ : Category.{v₃, u₃} E
L : C ⥤ D
W : MorphismProperty C
inst✝³ : L.IsLocalization W
A : Type w
inst✝² : AddMonoid A
inst✝¹ : HasShift C A
inst✝ : W.IsCompatibleWithShift A
X Y : C
f : X ⟶ Y
a : A
⊢ W ((shiftFunctor C a).map f) ↔ W.inverseImage (shiftFunctor C a) f
tactic: conv_rhs => rw [← @IsCompatibleWithShift.condition _ _ W A _ _ _ a]
state_before: C : Type u₁
D : Type u₂
inst✝⁶ : Category.{v₁, u₁} C
inst✝⁵ : Category.{v₂, u₂} D
E : Type u₃
inst✝⁴ : Category.{v₃, u₃} E
L : C ⥤ D
W : MorphismProperty C
inst✝³ : L.IsLocalization W
A : Type w
inst✝² : AddMonoid A
inst✝¹ : HasShift C A
inst✝ : W.IsCompatibleWithShift A
X Y : C
f : X ⟶ Y
a : A
⊢ W ((shiftFunctor C a).map f) ↔ W.inverseImage (shiftFunctor C a) f
state_after: no goals
tactic: rfl