ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Submodule.fst_inf_snd
File: Mathlib/LinearAlgebra/Prod.lean

Proof steps:
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type u_1
M₆ : Type u_2
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M
inst✝ : Module R M₂
p : Submodule R M
q : Submodule R M₂
⊢ fst R M M₂ ⊓ snd R M M₂ = ⊥
state_after: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type u_1
M₆ : Type u_2
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M
inst✝ : Module R M₂
p : Submodule R M
q : Submodule R M₂
⊢ fst R M M₂ ⊓ snd R M M₂ ≤ ⊥
tactic: rw [eq_bot_iff]
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type u_1
M₆ : Type u_2
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M
inst✝ : Module R M₂
p : Submodule R M
q : Submodule R M₂
⊢ fst R M M₂ ⊓ snd R M M₂ ≤ ⊥
state_after: case mk
R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type u_1
M₆ : Type u_2
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M
inst✝ : Module R M₂
p : Submodule R M
q : Submodule R M₂
x : M
y : M₂
⊢ (x, y) ∈ fst R M M₂ ⊓ snd R M M₂ → (x, y) ∈ ⊥
tactic: rintro ⟨x, y⟩
state_before: case mk
R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type u_1
M₆ : Type u_2
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M
inst✝ : Module R M₂
p : Submodule R M
q : Submodule R M₂
x : M
y : M₂
⊢ (x, y) ∈ fst R M M₂ ⊓ snd R M M₂ → (x, y) ∈ ⊥
state_after: no goals
tactic: simp only [fst, comap_bot, snd, mem_inf, mem_ker, snd_apply, fst_apply, mem_bot,
    Prod.mk_eq_zero, and_comm, imp_self]
Theorem: Function.LeftInverse.preimage_preimage
File: Mathlib/Data/Set/Image.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Sort u_3
f : α → β
g : β → α
h : LeftInverse g f
s : Set α
⊢ f ⁻¹' (g ⁻¹' s) = s
state_after: no goals
tactic: rw [← preimage_comp, h.comp_eq_id, preimage_id]
Theorem: max_neg_zero
File: Mathlib/Algebra/Order/Group/MinMax.lean

Proof steps:
state_before: α : Type u_1
inst✝² : Group α
inst✝¹ : LinearOrder α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a : α
⊢ max a⁻¹ 1 = a⁻¹ * max a 1
state_after: no goals
tactic: rw [eq_inv_mul_iff_mul_eq, ← eq_div_iff_mul_eq', max_one_div_max_inv_one_eq_self]
Theorem: CategoryTheory.Comma.preLeft_obj_right
File: Mathlib/CategoryTheory/Comma/Basic.lean

Proof steps:
state_before: A : Type u₁
inst✝⁷ : Category.{v₁, u₁} A
B : Type u₂
inst✝⁶ : Category.{v₂, u₂} B
T : Type u₃
inst✝⁵ : Category.{v₃, u₃} T
A' : Type u_1
B' : Type u_2
T' : Type u_3
inst✝⁴ : Category.{?u.129256, u_1} A'
inst✝³ : Category.{?u.129260, u_2} B'
inst✝² : Category.{?u.129264, u_3} T'
L✝ : A ⥤ T
R✝ : B ⥤ T
C : Type u₄
inst✝¹ : Category.{v₄, u₄} C
D : Type u₅
inst✝ : Category.{v₅, u₅} D
F : C ⥤ A
L : A ⥤ T
R : B ⥤ T
X✝ Y✝ : Comma (F ⋙ L) R
f : X✝ ⟶ Y✝
⊢ L.map (F.map f.left) ≫ ((fun X => { left := F.obj X.left, right := X.right, hom := X.hom }) Y✝).hom =
    ((fun X => { left := F.obj X.left, right := X.right, hom := X.hom }) X✝).hom ≫ R.map f.right
state_after: no goals
tactic: simpa using f.w
Theorem: Set.offDiag_nonempty
File: Mathlib/Data/Set/Prod.lean

Proof steps:
state_before: α : Type u_1
s t : Set α
x : α × α
a : α
⊢ s.offDiag.Nonempty ↔ s.Nontrivial
state_after: no goals
tactic: simp [offDiag, Set.Nonempty, Set.Nontrivial]
Theorem: Finsupp.prod_subtypeDomain_index
File: Mathlib/Data/Finsupp/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝¹ : Zero M
p : α → Prop
inst✝ : CommMonoid N
v : α →₀ M
h : α → M → N
hp : ∀ x ∈ v.support, p x
⊢ ((subtypeDomain p v).prod fun a b => h (↑a) b) = v.prod h
state_after: no goals
tactic: refine Finset.prod_bij (fun p _ ↦ p) ?_ ?_ ?_ ?_ <;> aesop
Theorem: NNReal.concaveOn_rpow
File: Mathlib/Analysis/Convex/SpecificFunctions/Pow.lean

Proof steps:
state_before: p : ℝ
hp₀ : 0 ≤ p
hp₁ : p ≤ 1
⊢ ConcaveOn ℝ≥0 univ fun x => x ^ p
state_after: case inl
hp₀ : 0 ≤ 0
hp₁ : 0 ≤ 1
⊢ ConcaveOn ℝ≥0 univ fun x => x ^ 0

case inr
p : ℝ
hp₀✝ : 0 ≤ p
hp₁ : p ≤ 1
hp₀ : 0 < p
⊢ ConcaveOn ℝ≥0 univ fun x => x ^ p
tactic: rcases eq_or_lt_of_le hp₀ with (rfl | hp₀)
state_before: case inr
p : ℝ
hp₀✝ : 0 ≤ p
hp₁ : p ≤ 1
hp₀ : 0 < p
⊢ ConcaveOn ℝ≥0 univ fun x => x ^ p
state_after: case inr.inl
hp₀✝ : 0 ≤ 1
hp₁ : 1 ≤ 1
hp₀ : 0 < 1
⊢ ConcaveOn ℝ≥0 univ fun x => x ^ 1

case inr.inr
p : ℝ
hp₀✝ : 0 ≤ p
hp₁✝ : p ≤ 1
hp₀ : 0 < p
hp₁ : p < 1
⊢ ConcaveOn ℝ≥0 univ fun x => x ^ p
tactic: rcases eq_or_lt_of_le hp₁ with (rfl | hp₁)
state_before: case inr.inr
p : ℝ
hp₀✝ : 0 ≤ p
hp₁✝ : p ≤ 1
hp₀ : 0 < p
hp₁ : p < 1
⊢ ConcaveOn ℝ≥0 univ fun x => x ^ p
state_after: no goals
tactic: exact (strictConcaveOn_rpow hp₀ hp₁).concaveOn
Theorem: Module.mem_support_iff'
File: Mathlib/RingTheory/Support.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
p : PrimeSpectrum R
⊢ p ∈ support R M ↔ ∃ m, ∀ r ∉ p.asIdeal, r • m ≠ 0
state_after: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
p : PrimeSpectrum R
⊢ (¬∀ (m : M), ∃ r ∉ p.asIdeal, r • m = 0) ↔ ∃ m, ∀ r ∉ p.asIdeal, r • m ≠ 0
tactic: rw [← @not_not (_ ∈ _), not_mem_support_iff']
state_before: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
p : PrimeSpectrum R
⊢ (¬∀ (m : M), ∃ r ∉ p.asIdeal, r • m = 0) ↔ ∃ m, ∀ r ∉ p.asIdeal, r • m ≠ 0
state_after: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
p : PrimeSpectrum R
⊢ (∃ m, ∀ r ∉ p.asIdeal, r • m ≠ 0) ↔ ∃ m, ∀ r ∉ p.asIdeal, r • m ≠ 0
tactic: push_neg
state_before: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
p : PrimeSpectrum R
⊢ (∃ m, ∀ r ∉ p.asIdeal, r • m ≠ 0) ↔ ∃ m, ∀ r ∉ p.asIdeal, r • m ≠ 0
state_after: no goals
tactic: rfl
Theorem: Relation.cutExpand_add_right
File: Mathlib/Logic/Hydra.lean

Proof steps:
state_before: α : Type u_1
r : α → α → Prop
s' s t : Multiset α
⊢ CutExpand r (s' + t) (s + t) ↔ CutExpand r s' s
state_after: no goals
tactic: convert cutExpand_add_left t using 2 <;> apply add_comm
Theorem: Asymptotics.isBigO_nat_atTop_iff
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
G : Type u_5
E' : Type u_6
F' : Type u_7
G' : Type u_8
E'' : Type u_9
F'' : Type u_10
G'' : Type u_11
E''' : Type u_12
R : Type u_13
R' : Type u_14
𝕜 : Type u_15
𝕜' : Type u_16
inst✝¹³ : Norm E
inst✝¹² : Norm F
inst✝¹¹ : Norm G
inst✝¹⁰ : SeminormedAddCommGroup E'
inst✝⁹ : SeminormedAddCommGroup F'
inst✝⁸ : SeminormedAddCommGroup G'
inst✝⁷ : NormedAddCommGroup E''
inst✝⁶ : NormedAddCommGroup F''
inst✝⁵ : NormedAddCommGroup G''
inst✝⁴ : SeminormedRing R
inst✝³ : SeminormedAddGroup E'''
inst✝² : SeminormedRing R'
inst✝¹ : NormedDivisionRing 𝕜
inst✝ : NormedDivisionRing 𝕜'
c c' c₁ c₂ : ℝ
f✝ : α → E
g✝ : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
f : ℕ → E''
g : ℕ → F''
h : ∀ (x : ℕ), g x = 0 → f x = 0
⊢ f =O[atTop] g ↔ ∃ C, ∀ (x : ℕ), ‖f x‖ ≤ C * ‖g x‖
state_after: no goals
tactic: rw [← Nat.cofinite_eq_atTop, isBigO_cofinite_iff h]
Theorem: ContinuousWithinAt.oscillationWithin_eq_zero
File: Mathlib/Analysis/Oscillation.lean

Proof steps:
state_before: E : Type u
F : Type v
inst✝¹ : PseudoEMetricSpace F
inst✝ : TopologicalSpace E
f : E → F
D : Set E
x : E
hf : ContinuousWithinAt f D x
⊢ oscillationWithin f D x = 0
state_after: E : Type u
F : Type v
inst✝¹ : PseudoEMetricSpace F
inst✝ : TopologicalSpace E
f : E → F
D : Set E
x : E
hf : ContinuousWithinAt f D x
ε : NNReal
hε : 0 < ε
x✝ : 0 < ⊤
⊢ oscillationWithin f D x ≤ 0 + ↑ε
tactic: refine le_antisymm (le_of_forall_pos_le_add fun ε hε _ ↦ ?_) (zero_le _)
state_before: E : Type u
F : Type v
inst✝¹ : PseudoEMetricSpace F
inst✝ : TopologicalSpace E
f : E → F
D : Set E
x : E
hf : ContinuousWithinAt f D x
ε : NNReal
hε : 0 < ε
x✝ : 0 < ⊤
⊢ oscillationWithin f D x ≤ 0 + ↑ε
state_after: E : Type u
F : Type v
inst✝¹ : PseudoEMetricSpace F
inst✝ : TopologicalSpace E
f : E → F
D : Set E
x : E
hf : ContinuousWithinAt f D x
ε : NNReal
hε : 0 < ε
x✝ : 0 < ⊤
⊢ oscillationWithin f D x ≤ ↑ε
tactic: rw [zero_add]
state_before: E : Type u
F : Type v
inst✝¹ : PseudoEMetricSpace F
inst✝ : TopologicalSpace E
f : E → F
D : Set E
x : E
hf : ContinuousWithinAt f D x
ε : NNReal
hε : 0 < ε
x✝ : 0 < ⊤
⊢ oscillationWithin f D x ≤ ↑ε
state_after: E : Type u
F : Type v
inst✝¹ : PseudoEMetricSpace F
inst✝ : TopologicalSpace E
f : E → F
D : Set E
x : E
hf : ContinuousWithinAt f D x
ε : NNReal
hε : 0 < ε
x✝ : 0 < ⊤
this : ball (f x) (↑ε / 2) ∈ Filter.map f (𝓝[D] x)
⊢ oscillationWithin f D x ≤ ↑ε
tactic: have : ball (f x) (ε / 2) ∈ (𝓝[D] x).map f := hf <| ball_mem_nhds _ (by simp [ne_of_gt hε])
state_before: E : Type u
F : Type v
inst✝¹ : PseudoEMetricSpace F
inst✝ : TopologicalSpace E
f : E → F
D : Set E
x : E
hf : ContinuousWithinAt f D x
ε : NNReal
hε : 0 < ε
x✝ : 0 < ⊤
this : ball (f x) (↑ε / 2) ∈ Filter.map f (𝓝[D] x)
⊢ oscillationWithin f D x ≤ ↑ε
state_after: E : Type u
F : Type v
inst✝¹ : PseudoEMetricSpace F
inst✝ : TopologicalSpace E
f : E → F
D : Set E
x : E
hf : ContinuousWithinAt f D x
ε : NNReal
hε : 0 < ε
x✝ : 0 < ⊤
this : ball (f x) (↑ε / 2) ∈ Filter.map f (𝓝[D] x)
⊢ 2 * (↑ε / 2) = ↑ε
tactic: refine (biInf_le diam this).trans (le_of_le_of_eq diam_ball ?_)
state_before: E : Type u
F : Type v
inst✝¹ : PseudoEMetricSpace F
inst✝ : TopologicalSpace E
f : E → F
D : Set E
x : E
hf : ContinuousWithinAt f D x
ε : NNReal
hε : 0 < ε
x✝ : 0 < ⊤
this : ball (f x) (↑ε / 2) ∈ Filter.map f (𝓝[D] x)
⊢ 2 * (↑ε / 2) = ↑ε
state_after: no goals
tactic: exact (ENNReal.mul_div_cancel' (by norm_num) (by norm_num))
Theorem: QuotientAddGroup.eq
File: Mathlib/GroupTheory/Coset.lean

Proof steps:
state_before: α : Type u_1
inst✝ : Group α
s : Subgroup α
a b : α
⊢ Setoid.r a b ↔ a⁻¹ * b ∈ s
state_after: no goals
tactic: rw [leftRel_apply]
Theorem: SimpleGraph.induceUnivIso_symm_apply_coe
File: Mathlib/Combinatorics/SimpleGraph/Maps.lean

Proof steps:
state_before: V : Type u_1
W : Type u_2
X : Type u_3
G✝ : SimpleGraph V
G' : SimpleGraph W
u v : V
G : SimpleGraph V
⊢ ∀ {a b : ↑Set.univ}, G.Adj ((Equiv.Set.univ V) a) ((Equiv.Set.univ V) b) ↔ (induce Set.univ G).Adj a b
state_after: no goals
tactic: simp only [Equiv.Set.univ, Equiv.coe_fn_mk, comap_adj, Embedding.coe_subtype,
                                Subtype.forall, Set.mem_univ, forall_true_left, implies_true]
Theorem: ModuleCat.semilinearMapAddEquiv_symm_apply_apply
File: Mathlib/Algebra/Category/ModuleCat/ChangeOfRings.lean

Proof steps:
state_before: R : Type u₁
S : Type u₂
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
M : ModuleCat R
N : ModuleCat S
g : ↑M →ₛₗ[f] ↑N
⊢ ∀ (x y : ↑M), g (x + y) = g x + g y
state_after: no goals
tactic: simp
state_before: R : Type u₁
S : Type u₂
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
M : ModuleCat R
N : ModuleCat S
g : ↑M →ₛₗ[f] ↑N
⊢ ∀ (m : R) (x : ↑M),
    { toFun := ⇑g, map_add' := ⋯ }.toFun (m • x) = (RingHom.id R) m • { toFun := ⇑g, map_add' := ⋯ }.toFun x
state_after: no goals
tactic: simp
state_before: R : Type u₁
S : Type u₂
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
M : ModuleCat R
N : ModuleCat S
g : M ⟶ (restrictScalars f).obj N
⊢ ∀ (x y : ↑M), g (x + y) = g x + g y
state_after: no goals
tactic: simp
Theorem: List.get_insertNth_of_lt
File: Mathlib/Data/List/InsertNth.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
a : α
l : List α
x : α
n k : ℕ
hn : k < n
hk : k < l.length
hk' : optParam (k < (insertNth n x l).length) ⋯
⊢ (insertNth n x l).get ⟨k, hk'⟩ = l.get ⟨k, hk⟩
state_after: no goals
tactic: simp_all [getElem_insertNth_of_lt]
Theorem: List.Ico.map_sub
File: Mathlib/Data/List/Intervals.lean

Proof steps:
state_before: n m k : ℕ
h₁ : k ≤ n
⊢ map (fun x => x - k) (Ico n m) = Ico (n - k) (m - k)
state_after: no goals
tactic: rw [Ico, Ico, Nat.sub_sub_sub_cancel_right h₁, map_sub_range' _ _ _ h₁]
Theorem: deriv_zero_of_not_differentiableAt
File: Mathlib/Analysis/Calculus/Deriv/Basic.lean

Proof steps:
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
h : ¬DifferentiableAt 𝕜 f x
⊢ deriv f x = 0
state_after: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
h : ¬DifferentiableAt 𝕜 f x
⊢ (fderiv 𝕜 f x) 1 = 0
tactic: unfold deriv
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
h : ¬DifferentiableAt 𝕜 f x
⊢ (fderiv 𝕜 f x) 1 = 0
state_after: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
h : ¬DifferentiableAt 𝕜 f x
⊢ 0 1 = 0
tactic: rw [fderiv_zero_of_not_differentiableAt h]
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
h : ¬DifferentiableAt 𝕜 f x
⊢ 0 1 = 0
state_after: no goals
tactic: simp
Theorem: PNat.mul_div_exact
File: Mathlib/Data/PNat/Basic.lean

Proof steps:
state_before: m k : ℕ+
h : k ∣ m
⊢ k * m.divExact k = m
state_after: case a
m k : ℕ+
h : k ∣ m
⊢ ↑(k * m.divExact k) = ↑m
tactic: apply PNat.eq
state_before: case a
m k : ℕ+
h : k ∣ m
⊢ ↑(k * m.divExact k) = ↑m
state_after: case a
m k : ℕ+
h : k ∣ m
⊢ ↑k * ↑(m.divExact k) = ↑m
tactic: rw [mul_coe]
state_before: case a
m k : ℕ+
h : k ∣ m
⊢ ↑k * ↑(m.divExact k) = ↑m
state_after: case a
m k : ℕ+
h : k ∣ m
⊢ ↑k * (m.div k).succ = ↑m
tactic: change (k : ℕ) * (div m k).succ = m
state_before: case a
m k : ℕ+
h : k ∣ m
⊢ ↑k * (m.div k).succ = ↑m
state_after: no goals
tactic: rw [← div_add_mod m k, dvd_iff'.mp h, Nat.mul_succ]
Theorem: LinearLocallyFiniteOrder.le_of_lt_succFn
File: Mathlib/Order/SuccPred/LinearLocallyFinite.lean

Proof steps:
state_before: ι : Type u_1
inst✝ : LinearOrder ι
j i : ι
hij : j < succFn i
⊢ j ≤ i
state_after: ι : Type u_1
inst✝ : LinearOrder ι
j i : ι
hij : ∃ c ∈ lowerBounds (Set.Ioi i), j < c
⊢ j ≤ i
tactic: rw [lt_isGLB_iff (succFn_spec i)] at hij
state_before: ι : Type u_1
inst✝ : LinearOrder ι
j i : ι
hij : ∃ c ∈ lowerBounds (Set.Ioi i), j < c
⊢ j ≤ i
state_after: case intro.intro
ι : Type u_1
inst✝ : LinearOrder ι
j i k : ι
hk_lb : k ∈ lowerBounds (Set.Ioi i)
hk : j < k
⊢ j ≤ i
tactic: obtain ⟨k, hk_lb, hk⟩ := hij
state_before: case intro.intro
ι : Type u_1
inst✝ : LinearOrder ι
j i k : ι
hk_lb : k ∈ lowerBounds (Set.Ioi i)
hk : j < k
⊢ j ≤ i
state_after: case intro.intro
ι : Type u_1
inst✝ : LinearOrder ι
j i k : ι
hk_lb : ∀ x ∈ Set.Ioi i, k ≤ x
hk : j < k
⊢ j ≤ i
tactic: rw [mem_lowerBounds] at hk_lb
state_before: case intro.intro
ι : Type u_1
inst✝ : LinearOrder ι
j i k : ι
hk_lb : ∀ x ∈ Set.Ioi i, k ≤ x
hk : j < k
⊢ j ≤ i
state_after: no goals
tactic: exact not_lt.mp fun hi_lt_j ↦ not_le.mpr hk (hk_lb j hi_lt_j)
Theorem: Int.ldiff_bit
File: Mathlib/Data/Int/Bitwise.lean

Proof steps:
state_before: a : Bool
m : ℤ
b : Bool
n : ℤ
⊢ (bit a m).ldiff (bit b n) = bit (a && !b) (m.ldiff n)
state_after: no goals
tactic: rw [← bitwise_diff, bitwise_bit]
Theorem: OreLocalization.add_zero
File: Mathlib/RingTheory/OreLocalization/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝³ : Monoid R
S : Submonoid R
inst✝² : OreSet S
X : Type u_2
inst✝¹ : AddMonoid X
inst✝ : DistribMulAction R X
x : OreLocalization S X
⊢ x + 0 = x
state_after: case c
R : Type u_1
inst✝³ : Monoid R
S : Submonoid R
inst✝² : OreSet S
X : Type u_2
inst✝¹ : AddMonoid X
inst✝ : DistribMulAction R X
r✝ : X
s✝ : ↥S
⊢ r✝ /ₒ s✝ + 0 = r✝ /ₒ s✝
tactic: induction x
state_before: case c
R : Type u_1
inst✝³ : Monoid R
S : Submonoid R
inst✝² : OreSet S
X : Type u_2
inst✝¹ : AddMonoid X
inst✝ : DistribMulAction R X
r✝ : X
s✝ : ↥S
⊢ r✝ /ₒ s✝ + 0 = r✝ /ₒ s✝
state_after: case c
R : Type u_1
inst✝³ : Monoid R
S : Submonoid R
inst✝² : OreSet S
X : Type u_2
inst✝¹ : AddMonoid X
inst✝ : DistribMulAction R X
r✝ : X
s✝ : ↥S
⊢ (r✝ + 0) /ₒ s✝ = r✝ /ₒ s✝
tactic: rw [← zero_oreDiv, add_oreDiv]
state_before: case c
R : Type u_1
inst✝³ : Monoid R
S : Submonoid R
inst✝² : OreSet S
X : Type u_2
inst✝¹ : AddMonoid X
inst✝ : DistribMulAction R X
r✝ : X
s✝ : ↥S
⊢ (r✝ + 0) /ₒ s✝ = r✝ /ₒ s✝
state_after: no goals
tactic: simp
Theorem: Ordinal.principal_add_of_principal_mul_opow
File: Mathlib/SetTheory/Ordinal/Principal.lean

Proof steps:
state_before: o b : Ordinal.{u_1}
hb : 1 < b
ho : Principal (fun x x_1 => x * x_1) (b ^ o)
x y : Ordinal.{u_1}
hx : x < o
hy : y < o
⊢ (fun x x_1 => x + x_1) x y < o
state_after: o b : Ordinal.{u_1}
hb : 1 < b
ho : Principal (fun x x_1 => x * x_1) (b ^ o)
x y : Ordinal.{u_1}
hx : x < o
hy : y < o
this : (fun x x_1 => x * x_1) (b ^ x) (b ^ y) < b ^ o
⊢ (fun x x_1 => x + x_1) x y < o
tactic: have := ho ((opow_lt_opow_iff_right hb).2 hx) ((opow_lt_opow_iff_right hb).2 hy)
state_before: o b : Ordinal.{u_1}
hb : 1 < b
ho : Principal (fun x x_1 => x * x_1) (b ^ o)
x y : Ordinal.{u_1}
hx : x < o
hy : y < o
this : (fun x x_1 => x * x_1) (b ^ x) (b ^ y) < b ^ o
⊢ (fun x x_1 => x + x_1) x y < o
state_after: o b : Ordinal.{u_1}
hb : 1 < b
ho : Principal (fun x x_1 => x * x_1) (b ^ o)
x y : Ordinal.{u_1}
hx : x < o
hy : y < o
this : b ^ x * b ^ y < b ^ o
⊢ x + y < o
tactic: dsimp only at *
state_before: o b : Ordinal.{u_1}
hb : 1 < b
ho : Principal (fun x x_1 => x * x_1) (b ^ o)
x y : Ordinal.{u_1}
hx : x < o
hy : y < o
this : b ^ x * b ^ y < b ^ o
⊢ x + y < o
state_after: no goals
tactic: rwa [← opow_add, opow_lt_opow_iff_right hb] at this
Theorem: Polynomial.degree_add_eq_of_leadingCoeff_add_ne_zero
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✝ p q : R[X]
ι : Type u_1
h : p.leadingCoeff + q.leadingCoeff ≠ 0
hlt : p.degree < q.degree
⊢ max p.degree q.degree ≤ (p + q).degree
state_after: no goals
tactic: rw [degree_add_eq_right_of_degree_lt hlt, max_eq_right_of_lt hlt]
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
h : p.leadingCoeff + q.leadingCoeff ≠ 0
HEq : p.degree = q.degree
hlt : max p.degree q.degree > (p + q).degree
⊢ p.leadingCoeff + q.leadingCoeff = 0
state_after: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
h : p.leadingCoeff + q.leadingCoeff ≠ 0
HEq : p.degree = q.degree
hlt : q.degree > (p + q).degree
⊢ p.leadingCoeff + q.leadingCoeff = 0
tactic: rw [HEq, max_self] at hlt
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
h : p.leadingCoeff + q.leadingCoeff ≠ 0
HEq : p.degree = q.degree
hlt : q.degree > (p + q).degree
⊢ p.leadingCoeff + q.leadingCoeff = 0
state_after: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
h : p.leadingCoeff + q.leadingCoeff ≠ 0
HEq : p.degree = q.degree
hlt : q.degree > (p + q).degree
⊢ (p + q).coeff q.natDegree = 0
tactic: rw [leadingCoeff, leadingCoeff, natDegree_eq_of_degree_eq HEq, ← coeff_add]
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
h : p.leadingCoeff + q.leadingCoeff ≠ 0
HEq : p.degree = q.degree
hlt : q.degree > (p + q).degree
⊢ (p + q).coeff q.natDegree = 0
state_after: no goals
tactic: exact coeff_natDegree_eq_zero_of_degree_lt hlt
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
h : p.leadingCoeff + q.leadingCoeff ≠ 0
hlt : q.degree < p.degree
⊢ max p.degree q.degree ≤ (p + q).degree
state_after: no goals
tactic: rw [degree_add_eq_left_of_degree_lt hlt, max_eq_left_of_lt hlt]
Theorem: measurable_to_bool
File: Mathlib/MeasureTheory/MeasurableSpace/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s t u : Set α
inst✝ : MeasurableSpace α
f : α → Bool
h : MeasurableSet (f ⁻¹' {true})
⊢ Measurable f
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s t u : Set α
inst✝ : MeasurableSpace α
f : α → Bool
h : MeasurableSet (f ⁻¹' {true})
⊢ ∀ (x : Bool), MeasurableSet (f ⁻¹' {x})
tactic: apply measurable_to_countable'
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s t u : Set α
inst✝ : MeasurableSpace α
f : α → Bool
h : MeasurableSet (f ⁻¹' {true})
⊢ ∀ (x : Bool), MeasurableSet (f ⁻¹' {x})
state_after: case h.false
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s t u : Set α
inst✝ : MeasurableSpace α
f : α → Bool
h : MeasurableSet (f ⁻¹' {true})
⊢ MeasurableSet (f ⁻¹' {false})

case h.true
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s t u : Set α
inst✝ : MeasurableSpace α
f : α → Bool
h : MeasurableSet (f ⁻¹' {true})
⊢ MeasurableSet (f ⁻¹' {true})
tactic: rintro (- | -)
state_before: case h.true
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s t u : Set α
inst✝ : MeasurableSpace α
f : α → Bool
h : MeasurableSet (f ⁻¹' {true})
⊢ MeasurableSet (f ⁻¹' {true})
state_after: no goals
tactic: exact h
Theorem: le_compl_comm
File: Mathlib/Order/Heyting/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : HeytingAlgebra α
a b c : α
⊢ a ≤ bᶜ ↔ b ≤ aᶜ
state_after: no goals
tactic: rw [le_compl_iff_disjoint_right, le_compl_iff_disjoint_left]
Theorem: Nat.unpair_lt
File: Mathlib/Data/Nat/Pairing.lean

Proof steps:
state_before: n : ℕ
n1 : 1 ≤ n
⊢ (unpair n).1 < n
state_after: n : ℕ
n1 : 1 ≤ n
s : ℕ := n.sqrt
⊢ (unpair n).1 < n
tactic: let s := sqrt n
state_before: n : ℕ
n1 : 1 ≤ n
s : ℕ := n.sqrt
⊢ (unpair n).1 < n
state_after: n : ℕ
n1 : 1 ≤ n
s : ℕ := n.sqrt
⊢ (if n - n.sqrt * n.sqrt < n.sqrt then (n - n.sqrt * n.sqrt, n.sqrt) else (n.sqrt, n - n.sqrt * n.sqrt - n.sqrt)).1 < n
tactic: simp only [unpair, Nat.sub_le_iff_le_add]
state_before: n : ℕ
n1 : 1 ≤ n
s : ℕ := n.sqrt
⊢ (if n - n.sqrt * n.sqrt < n.sqrt then (n - n.sqrt * n.sqrt, n.sqrt) else (n.sqrt, n - n.sqrt * n.sqrt - n.sqrt)).1 < n
state_after: case pos
n : ℕ
n1 : 1 ≤ n
s : ℕ := n.sqrt
h : n - s * s < s
⊢ n - n.sqrt * n.sqrt < n

case neg
n : ℕ
n1 : 1 ≤ n
s : ℕ := n.sqrt
h : ¬n - s * s < s
⊢ n.sqrt < n
tactic: by_cases h : n - s * s < s <;> simp only [h, ↓reduceIte]