ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: MeasureTheory.pdf.IsUniform.aemeasurable
File: Mathlib/Probability/Distributions/Uniform.lean

Proof steps:
state_before: E : Type u_1
inst✝ : MeasurableSpace E
m μ : Measure E
Ω : Type u_2
x✝ : MeasurableSpace Ω
ℙ : Measure Ω
X : Ω → E
s : Set E
hns : μ s ≠ 0
hnt : μ s ≠ ⊤
hu : IsUniform X s ℙ μ
⊢ AEMeasurable X ℙ
state_after: E : Type u_1
inst✝ : MeasurableSpace E
m μ : Measure E
Ω : Type u_2
x✝ : MeasurableSpace Ω
ℙ : Measure Ω
X : Ω → E
s : Set E
hns : μ s ≠ 0
hnt : μ s ≠ ⊤
hu : Measure.map X ℙ = (μ s)⁻¹ • μ.restrict s
⊢ AEMeasurable X ℙ
tactic: dsimp [IsUniform, ProbabilityTheory.cond] at hu
state_before: E : Type u_1
inst✝ : MeasurableSpace E
m μ : Measure E
Ω : Type u_2
x✝ : MeasurableSpace Ω
ℙ : Measure Ω
X : Ω → E
s : Set E
hns : μ s ≠ 0
hnt : μ s ≠ ⊤
hu : Measure.map X ℙ = (μ s)⁻¹ • μ.restrict s
⊢ AEMeasurable X ℙ
state_after: E : Type u_1
inst✝ : MeasurableSpace E
m μ : Measure E
Ω : Type u_2
x✝ : MeasurableSpace Ω
ℙ : Measure Ω
X : Ω → E
s : Set E
hns : μ s ≠ 0
hnt : μ s ≠ ⊤
hu : Measure.map X ℙ = (μ s)⁻¹ • μ.restrict s
h : ¬AEMeasurable X ℙ
⊢ False
tactic: by_contra h
state_before: E : Type u_1
inst✝ : MeasurableSpace E
m μ : Measure E
Ω : Type u_2
x✝ : MeasurableSpace Ω
ℙ : Measure Ω
X : Ω → E
s : Set E
hns : μ s ≠ 0
hnt : μ s ≠ ⊤
hu : Measure.map X ℙ = (μ s)⁻¹ • μ.restrict s
h : ¬AEMeasurable X ℙ
⊢ False
state_after: E : Type u_1
inst✝ : MeasurableSpace E
m μ : Measure E
Ω : Type u_2
x✝ : MeasurableSpace Ω
ℙ : Measure Ω
X : Ω → E
s : Set E
hns : μ s ≠ 0
hnt : μ s ≠ ⊤
hu : 0 = (μ s)⁻¹ • μ.restrict s
h : ¬AEMeasurable X ℙ
⊢ False
tactic: rw [map_of_not_aemeasurable h] at hu
state_before: E : Type u_1
inst✝ : MeasurableSpace E
m μ : Measure E
Ω : Type u_2
x✝ : MeasurableSpace Ω
ℙ : Measure Ω
X : Ω → E
s : Set E
hns : μ s ≠ 0
hnt : μ s ≠ ⊤
hu : 0 = (μ s)⁻¹ • μ.restrict s
h : ¬AEMeasurable X ℙ
⊢ False
state_after: E : Type u_1
inst✝ : MeasurableSpace E
m μ : Measure E
Ω : Type u_2
x✝ : MeasurableSpace Ω
ℙ : Measure Ω
X : Ω → E
s : Set E
hns : μ s ≠ 0
hnt : μ s ≠ ⊤
hu : 0 = (μ s)⁻¹ • μ.restrict s
h : ¬AEMeasurable X ℙ
⊢ 0 = 1
tactic: apply zero_ne_one' ℝ≥0∞
state_before: E : Type u_1
inst✝ : MeasurableSpace E
m μ : Measure E
Ω : Type u_2
x✝ : MeasurableSpace Ω
ℙ : Measure Ω
X : Ω → E
s : Set E
hns : μ s ≠ 0
hnt : μ s ≠ ⊤
hu : 0 = (μ s)⁻¹ • μ.restrict s
h : ¬AEMeasurable X ℙ
⊢ 0 = 1
state_after: no goals
tactic: calc
    0 = (0 : Measure E) Set.univ := rfl
    _ = _ := by rw [hu, smul_apply, restrict_apply MeasurableSet.univ,
      Set.univ_inter, smul_eq_mul, ENNReal.inv_mul_cancel hns hnt]
Theorem: _private.Mathlib.Combinatorics.SetFamily.AhlswedeZhang.0.Finset.infs_aux
File: Mathlib/Combinatorics/SetFamily/AhlswedeZhang.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝³ : DistribLattice α
inst✝² : BoundedOrder α
inst✝¹ : DecidableEq α
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
s t : Finset α
a : α
⊢ a ∈ lowerClosure ↑(s ⊼ t) ↔ a ∈ lowerClosure ↑s ∧ a ∈ lowerClosure ↑t
state_after: no goals
tactic: rw [coe_infs, lowerClosure_infs, LowerSet.mem_inf_iff]
Theorem: Seminorm.zero_or_exists_apply_eq_finset_sup
File: Mathlib/Analysis/Seminorm.lean

Proof steps:
state_before: R : Type u_1
R' : Type u_2
𝕜 : Type u_3
𝕜₂ : Type u_4
𝕜₃ : Type u_5
𝕝 : Type u_6
E : Type u_7
E₂ : Type u_8
E₃ : Type u_9
F : Type u_10
G : Type u_11
ι : Type u_12
inst✝¹⁸ : SeminormedRing 𝕜
inst✝¹⁷ : SeminormedRing 𝕜₂
inst✝¹⁶ : SeminormedRing 𝕜₃
σ₁₂ : 𝕜 →+* 𝕜₂
inst✝¹⁵ : RingHomIsometric σ₁₂
σ₂₃ : 𝕜₂ →+* 𝕜₃
inst✝¹⁴ : RingHomIsometric σ₂₃
σ₁₃ : 𝕜 →+* 𝕜₃
inst✝¹³ : RingHomIsometric σ₁₃
inst✝¹² : AddCommGroup E
inst✝¹¹ : AddCommGroup E₂
inst✝¹⁰ : AddCommGroup E₃
inst✝⁹ : AddCommGroup F
inst✝⁸ : AddCommGroup G
inst✝⁷ : Module 𝕜 E
inst✝⁶ : Module 𝕜₂ E₂
inst✝⁵ : Module 𝕜₃ E₃
inst✝⁴ : Module 𝕜 F
inst✝³ : Module 𝕜 G
inst✝² : SMul R ℝ
inst✝¹ : SMul R ℝ≥0
inst✝ : IsScalarTower R ℝ≥0 ℝ
p : ι → Seminorm 𝕜 E
s : Finset ι
x : E
⊢ (s.sup p) x = 0 ∨ ∃ i ∈ s, (s.sup p) x = (p i) x
state_after: case inl
R : Type u_1
R' : Type u_2
𝕜 : Type u_3
𝕜₂ : Type u_4
𝕜₃ : Type u_5
𝕝 : Type u_6
E : Type u_7
E₂ : Type u_8
E₃ : Type u_9
F : Type u_10
G : Type u_11
ι : Type u_12
inst✝¹⁸ : SeminormedRing 𝕜
inst✝¹⁷ : SeminormedRing 𝕜₂
inst✝¹⁶ : SeminormedRing 𝕜₃
σ₁₂ : 𝕜 →+* 𝕜₂
inst✝¹⁵ : RingHomIsometric σ₁₂
σ₂₃ : 𝕜₂ →+* 𝕜₃
inst✝¹⁴ : RingHomIsometric σ₂₃
σ₁₃ : 𝕜 →+* 𝕜₃
inst✝¹³ : RingHomIsometric σ₁₃
inst✝¹² : AddCommGroup E
inst✝¹¹ : AddCommGroup E₂
inst✝¹⁰ : AddCommGroup E₃
inst✝⁹ : AddCommGroup F
inst✝⁸ : AddCommGroup G
inst✝⁷ : Module 𝕜 E
inst✝⁶ : Module 𝕜₂ E₂
inst✝⁵ : Module 𝕜₃ E₃
inst✝⁴ : Module 𝕜 F
inst✝³ : Module 𝕜 G
inst✝² : SMul R ℝ
inst✝¹ : SMul R ℝ≥0
inst✝ : IsScalarTower R ℝ≥0 ℝ
p : ι → Seminorm 𝕜 E
x : E
⊢ (∅.sup p) x = 0 ∨ ∃ i ∈ ∅, (∅.sup p) x = (p i) x

case inr
R : Type u_1
R' : Type u_2
𝕜 : Type u_3
𝕜₂ : Type u_4
𝕜₃ : Type u_5
𝕝 : Type u_6
E : Type u_7
E₂ : Type u_8
E₃ : Type u_9
F : Type u_10
G : Type u_11
ι : Type u_12
inst✝¹⁸ : SeminormedRing 𝕜
inst✝¹⁷ : SeminormedRing 𝕜₂
inst✝¹⁶ : SeminormedRing 𝕜₃
σ₁₂ : 𝕜 →+* 𝕜₂
inst✝¹⁵ : RingHomIsometric σ₁₂
σ₂₃ : 𝕜₂ →+* 𝕜₃
inst✝¹⁴ : RingHomIsometric σ₂₃
σ₁₃ : 𝕜 →+* 𝕜₃
inst✝¹³ : RingHomIsometric σ₁₃
inst✝¹² : AddCommGroup E
inst✝¹¹ : AddCommGroup E₂
inst✝¹⁰ : AddCommGroup E₃
inst✝⁹ : AddCommGroup F
inst✝⁸ : AddCommGroup G
inst✝⁷ : Module 𝕜 E
inst✝⁶ : Module 𝕜₂ E₂
inst✝⁵ : Module 𝕜₃ E₃
inst✝⁴ : Module 𝕜 F
inst✝³ : Module 𝕜 G
inst✝² : SMul R ℝ
inst✝¹ : SMul R ℝ≥0
inst✝ : IsScalarTower R ℝ≥0 ℝ
p : ι → Seminorm 𝕜 E
s : Finset ι
x : E
hs : s.Nonempty
⊢ (s.sup p) x = 0 ∨ ∃ i ∈ s, (s.sup p) x = (p i) x
tactic: rcases Finset.eq_empty_or_nonempty s with (rfl|hs)
Theorem: Set.Ioo_union_both
File: Mathlib/Order/Interval/Set/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : PartialOrder α
a b c : α
h : a ≤ b
⊢ Ioo a b ∪ {a, b} = Icc a b
state_after: α : Type u_1
β : Type u_2
inst✝ : PartialOrder α
a b c : α
h : a ≤ b
this : Icc a b \ {a, b} ∪ {a, b} = Icc a b
⊢ Ioo a b ∪ {a, b} = Icc a b
tactic: have : (Icc a b \ {a, b}) ∪ {a, b} = Icc a b := diff_union_of_subset fun
    | x, .inl rfl => left_mem_Icc.mpr h
    | x, .inr rfl => right_mem_Icc.mpr h
state_before: α : Type u_1
β : Type u_2
inst✝ : PartialOrder α
a b c : α
h : a ≤ b
this : Icc a b \ {a, b} ∪ {a, b} = Icc a b
⊢ Ioo a b ∪ {a, b} = Icc a b
state_after: no goals
tactic: rw [← this, Icc_diff_both]
Theorem: Finsupp.sum_add_eq_sum_add_of_exists
File: Mathlib/Algebra/BigOperators/Finsupp.lean

Proof steps:
state_before: α : Type u_1
ι : Type u_2
γ : Type u_3
A : Type u_4
B : Type u_5
C : Type u_6
inst✝⁴ : AddCommMonoid A
inst✝³ : AddCommMonoid B
inst✝² : AddCommMonoid C
t : ι → A → C
h0 : ∀ (i : ι), t i 0 = 0
h1 : ∀ (i : ι) (x y : A), t i (x + y) = t i x + t i y
s : Finset α
f✝ : α → ι →₀ A
i : ι
g✝ : ι →₀ A
k : ι → A → γ → B
x : γ
β : Type u_7
M : Type u_8
M' : Type u_9
N : Type u_10
P : Type u_11
G : Type u_12
H : Type u_13
R : Type u_14
S : Type u_15
inst✝¹ : Zero M
inst✝ : CommMonoid N
f : α →₀ M
g : α → M → N
n₁ n₂ : N
a : α
ha : a ∈ f.support
h : g a (f a) * n₁ = g a (f a) * n₂
⊢ f.prod g * n₁ = f.prod g * n₂
state_after: no goals
tactic: classical
  exact Finset.prod_mul_eq_prod_mul_of_exists a ha h
Theorem: Fin.predAbove_right_zero
File: Mathlib/Data/Fin/Basic.lean

Proof steps:
state_before: n m : ℕ
inst✝ : NeZero n
i : Fin n
⊢ i.predAbove 0 = 0
state_after: case zero
m : ℕ
inst✝ : NeZero 0
i : Fin 0
⊢ i.predAbove 0 = 0

case succ
m n✝ : ℕ
inst✝ : NeZero (n✝ + 1)
i : Fin (n✝ + 1)
⊢ i.predAbove 0 = 0
tactic: cases n
Theorem: WittVector.polyOfInterest_vars_eq
File: Mathlib/RingTheory/WittVector/MulCoeff.lean

Proof steps:
state_before: p : ℕ
hp : Fact (Nat.Prime p)
k : Type u_1
inst✝ : CommRing k
n : ℕ
⊢ (polyOfInterest p n).vars =
    (↑p ^ (n + 1) *
        (wittMul p (n + 1) + ↑p ^ (n + 1) * X (0, n + 1) * X (1, n + 1) -
            X (0, n + 1) * (rename (Prod.mk 1)) (wittPolynomial p ℤ (n + 1)) -
          X (1, n + 1) * (rename (Prod.mk 0)) (wittPolynomial p ℤ (n + 1)))).vars
state_after: p : ℕ
hp : Fact (Nat.Prime p)
k : Type u_1
inst✝ : CommRing k
n : ℕ
this : ↑p ^ (n + 1) = C (↑p ^ (n + 1))
⊢ (polyOfInterest p n).vars =
    (↑p ^ (n + 1) *
        (wittMul p (n + 1) + ↑p ^ (n + 1) * X (0, n + 1) * X (1, n + 1) -
            X (0, n + 1) * (rename (Prod.mk 1)) (wittPolynomial p ℤ (n + 1)) -
          X (1, n + 1) * (rename (Prod.mk 0)) (wittPolynomial p ℤ (n + 1)))).vars
tactic: have : (p : 𝕄) ^ (n + 1) = C ((p : ℤ) ^ (n + 1)) := by norm_cast
state_before: p : ℕ
hp : Fact (Nat.Prime p)
k : Type u_1
inst✝ : CommRing k
n : ℕ
this : ↑p ^ (n + 1) = C (↑p ^ (n + 1))
⊢ (polyOfInterest p n).vars =
    (↑p ^ (n + 1) *
        (wittMul p (n + 1) + ↑p ^ (n + 1) * X (0, n + 1) * X (1, n + 1) -
            X (0, n + 1) * (rename (Prod.mk 1)) (wittPolynomial p ℤ (n + 1)) -
          X (1, n + 1) * (rename (Prod.mk 0)) (wittPolynomial p ℤ (n + 1)))).vars
state_after: case ha
p : ℕ
hp : Fact (Nat.Prime p)
k : Type u_1
inst✝ : CommRing k
n : ℕ
this : ↑p ^ (n + 1) = C (↑p ^ (n + 1))
⊢ ↑p ^ (n + 1) ≠ 0
tactic: rw [polyOfInterest, this, vars_C_mul]
state_before: case ha
p : ℕ
hp : Fact (Nat.Prime p)
k : Type u_1
inst✝ : CommRing k
n : ℕ
this : ↑p ^ (n + 1) = C (↑p ^ (n + 1))
⊢ ↑p ^ (n + 1) ≠ 0
state_after: case ha.h
p : ℕ
hp : Fact (Nat.Prime p)
k : Type u_1
inst✝ : CommRing k
n : ℕ
this : ↑p ^ (n + 1) = C (↑p ^ (n + 1))
⊢ ↑p ≠ 0
tactic: apply pow_ne_zero
state_before: case ha.h
p : ℕ
hp : Fact (Nat.Prime p)
k : Type u_1
inst✝ : CommRing k
n : ℕ
this : ↑p ^ (n + 1) = C (↑p ^ (n + 1))
⊢ ↑p ≠ 0
state_after: no goals
tactic: exact mod_cast hp.out.ne_zero
Theorem: Real.tan_nonpos_of_nonpos_of_neg_pi_div_two_le
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

Proof steps:
state_before: x : ℝ
hx0 : x ≤ 0
hpx : -(π / 2) ≤ x
⊢ 0 ≤ -x
state_after: no goals
tactic: linarith
state_before: x : ℝ
hx0 : x ≤ 0
hpx : -(π / 2) ≤ x
⊢ -x ≤ π / 2
state_after: no goals
tactic: linarith
Theorem: LinearMap.isUnit_det
File: Mathlib/LinearAlgebra/Determinant.lean

Proof steps:
state_before: R : Type u_1
inst✝¹¹ : CommRing R
M : Type u_2
inst✝¹⁰ : AddCommGroup M
inst✝⁹ : Module R M
M' : Type u_3
inst✝⁸ : AddCommGroup M'
inst✝⁷ : Module R M'
ι : Type u_4
inst✝⁶ : DecidableEq ι
inst✝⁵ : Fintype ι
e : Basis ι R M
A✝ : Type u_5
inst✝⁴ : CommRing A✝
inst✝³ : Module A✝ M
κ : Type u_6
inst✝² : Fintype κ
A : Type u_7
inst✝¹ : CommRing A
inst✝ : Module A M
f : M →ₗ[A] M
hf : IsUnit f
⊢ IsUnit (LinearMap.det f)
state_after: case intro
R : Type u_1
inst✝¹¹ : CommRing R
M : Type u_2
inst✝¹⁰ : AddCommGroup M
inst✝⁹ : Module R M
M' : Type u_3
inst✝⁸ : AddCommGroup M'
inst✝⁷ : Module R M'
ι : Type u_4
inst✝⁶ : DecidableEq ι
inst✝⁵ : Fintype ι
e : Basis ι R M
A✝ : Type u_5
inst✝⁴ : CommRing A✝
inst✝³ : Module A✝ M
κ : Type u_6
inst✝² : Fintype κ
A : Type u_7
inst✝¹ : CommRing A
inst✝ : Module A M
f : M →ₗ[A] M
hf : IsUnit f
g : M →ₗ[A] M
hg : f ∘ₗ g = 1
⊢ IsUnit (LinearMap.det f)
tactic: obtain ⟨g, hg⟩ : ∃ g, f.comp g = 1 := hf.exists_right_inv
state_before: case intro
R : Type u_1
inst✝¹¹ : CommRing R
M : Type u_2
inst✝¹⁰ : AddCommGroup M
inst✝⁹ : Module R M
M' : Type u_3
inst✝⁸ : AddCommGroup M'
inst✝⁷ : Module R M'
ι : Type u_4
inst✝⁶ : DecidableEq ι
inst✝⁵ : Fintype ι
e : Basis ι R M
A✝ : Type u_5
inst✝⁴ : CommRing A✝
inst✝³ : Module A✝ M
κ : Type u_6
inst✝² : Fintype κ
A : Type u_7
inst✝¹ : CommRing A
inst✝ : Module A M
f : M →ₗ[A] M
hf : IsUnit f
g : M →ₗ[A] M
hg : f ∘ₗ g = 1
⊢ IsUnit (LinearMap.det f)
state_after: case intro
R : Type u_1
inst✝¹¹ : CommRing R
M : Type u_2
inst✝¹⁰ : AddCommGroup M
inst✝⁹ : Module R M
M' : Type u_3
inst✝⁸ : AddCommGroup M'
inst✝⁷ : Module R M'
ι : Type u_4
inst✝⁶ : DecidableEq ι
inst✝⁵ : Fintype ι
e : Basis ι R M
A✝ : Type u_5
inst✝⁴ : CommRing A✝
inst✝³ : Module A✝ M
κ : Type u_6
inst✝² : Fintype κ
A : Type u_7
inst✝¹ : CommRing A
inst✝ : Module A M
f : M →ₗ[A] M
hf : IsUnit f
g : M →ₗ[A] M
hg : f ∘ₗ g = 1
this : LinearMap.det f * LinearMap.det g = 1
⊢ IsUnit (LinearMap.det f)
tactic: have : LinearMap.det f * LinearMap.det g = 1 := by
    simp only [← LinearMap.det_comp, hg, MonoidHom.map_one]
state_before: case intro
R : Type u_1
inst✝¹¹ : CommRing R
M : Type u_2
inst✝¹⁰ : AddCommGroup M
inst✝⁹ : Module R M
M' : Type u_3
inst✝⁸ : AddCommGroup M'
inst✝⁷ : Module R M'
ι : Type u_4
inst✝⁶ : DecidableEq ι
inst✝⁵ : Fintype ι
e : Basis ι R M
A✝ : Type u_5
inst✝⁴ : CommRing A✝
inst✝³ : Module A✝ M
κ : Type u_6
inst✝² : Fintype κ
A : Type u_7
inst✝¹ : CommRing A
inst✝ : Module A M
f : M →ₗ[A] M
hf : IsUnit f
g : M →ₗ[A] M
hg : f ∘ₗ g = 1
this : LinearMap.det f * LinearMap.det g = 1
⊢ IsUnit (LinearMap.det f)
state_after: no goals
tactic: exact isUnit_of_mul_eq_one _ _ this
Theorem: Filter.frequently_iSup
File: Mathlib/Order/Filter/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
p : α → Prop
fs : β → Filter α
⊢ (∃ᶠ (x : α) in ⨆ b, fs b, p x) ↔ ∃ b, ∃ᶠ (x : α) in fs b, p x
state_after: no goals
tactic: simp only [Filter.Frequently, eventually_iSup, not_forall]
Theorem: List.length_le_sum_of_one_le
File: Mathlib/Algebra/BigOperators/Group/List.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
L : List ℕ
h : ∀ i ∈ L, 1 ≤ i
⊢ L.length ≤ L.sum
state_after: case nil
ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
h : ∀ i ∈ [], 1 ≤ i
⊢ [].length ≤ [].sum

case cons
ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
j : ℕ
L : List ℕ
IH : (∀ i ∈ L, 1 ≤ i) → L.length ≤ L.sum
h : ∀ i ∈ j :: L, 1 ≤ i
⊢ (j :: L).length ≤ (j :: L).sum
tactic: induction' L with j L IH h
state_before: case cons
ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
j : ℕ
L : List ℕ
IH : (∀ i ∈ L, 1 ≤ i) → L.length ≤ L.sum
h : ∀ i ∈ j :: L, 1 ≤ i
⊢ (j :: L).length ≤ (j :: L).sum
state_after: case cons
ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
j : ℕ
L : List ℕ
IH : (∀ i ∈ L, 1 ≤ i) → L.length ≤ L.sum
h : ∀ i ∈ j :: L, 1 ≤ i
⊢ 1 + L.length ≤ j + L.sum
tactic: rw [sum_cons, length, add_comm]
state_before: case cons
ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
j : ℕ
L : List ℕ
IH : (∀ i ∈ L, 1 ≤ i) → L.length ≤ L.sum
h : ∀ i ∈ j :: L, 1 ≤ i
⊢ 1 + L.length ≤ j + L.sum
state_after: no goals
tactic: exact Nat.add_le_add (h _ (mem_cons_self _ _)) (IH fun i hi => h i (mem_cons.2 (Or.inr hi)))
Theorem: Cubic.degree_of_c_ne_zero
File: Mathlib/Algebra/CubicDiscriminant.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
F : Type u_3
K : Type u_4
P Q : Cubic R
a b c d a' b' c' d' : R
inst✝ : Semiring R
ha : P.a = 0
hb : P.b = 0
hc : P.c ≠ 0
⊢ P.toPoly.degree = 1
state_after: no goals
tactic: rw [of_b_eq_zero ha hb, degree_linear hc]
Theorem: SimpleGraph.subgraphOfAdj_adj
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

Proof steps:
state_before: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
v w : V
hvw : G.Adj v w
v✝ w✝ : V
h : (fun a b => s(v, w) = s(a, b)) v✝ w✝
⊢ G.Adj v✝ w✝
state_after: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
v w : V
hvw : G.Adj v w
v✝ w✝ : V
h : (fun a b => s(v, w) = s(a, b)) v✝ w✝
⊢ s(v, w) ∈ G.edgeSet
tactic: rw [← G.mem_edgeSet, ← h]
state_before: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
v w : V
hvw : G.Adj v w
v✝ w✝ : V
h : (fun a b => s(v, w) = s(a, b)) v✝ w✝
⊢ s(v, w) ∈ G.edgeSet
state_after: no goals
tactic: exact hvw
state_before: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
v w : V
hvw : G.Adj v w
a b : V
h : (fun a b => s(v, w) = s(a, b)) a b
⊢ a ∈ {v, w}
state_after: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
v w : V
hvw : G.Adj v w
a b : V
h : (a ∈ s(v, w)) = (a ∈ s(a, b))
⊢ a ∈ {v, w}
tactic: apply_fun fun e ↦ a ∈ e at h
state_before: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
v w : V
hvw : G.Adj v w
a b : V
h : (a ∈ s(v, w)) = (a ∈ s(a, b))
⊢ a ∈ {v, w}
state_after: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
v w : V
hvw : G.Adj v w
a b : V
h : a = v ∨ a = w
⊢ a ∈ {v, w}
tactic: simp only [Sym2.mem_iff, true_or, eq_iff_iff, iff_true] at h
state_before: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
v w : V
hvw : G.Adj v w
a b : V
h : a = v ∨ a = w
⊢ a ∈ {v, w}
state_after: no goals
tactic: exact h
Theorem: RatFunc.liftOn_condition_of_liftOn'_condition
File: Mathlib/FieldTheory/RatFunc/Defs.lean

Proof steps:
state_before: K : Type u
inst✝ : CommRing K
P : Sort v
f : K[X] → K[X] → P
H : ∀ {p q a : K[X]}, q ≠ 0 → a ≠ 0 → f (a * p) (a * q) = f p q
p q p' q' : K[X]
hq : q ≠ 0
hq' : q' ≠ 0
h : q' * p = q * p'
⊢ f (q' * p) (q' * q) = f (q * p') (q * q')
state_after: no goals
tactic: rw [h, mul_comm q']
Theorem: LeftOrdContinuous.lt_iff
File: Mathlib/Order/OrdContinuous.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝¹ : SemilatticeSup α
inst✝ : SemilatticeSup β
f : α → β
hf : LeftOrdContinuous f
h : Injective f
x y : α
⊢ f x < f y ↔ x < y
state_after: no goals
tactic: simp only [lt_iff_le_not_le, hf.le_iff h]
Theorem: CategoryTheory.hom_ext_yoneda
File: Mathlib/CategoryTheory/Yoneda.lean

Proof steps:
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
P Q : Cᵒᵖ ⥤ Type v₁
f g : P ⟶ Q
h : ∀ (X : C) (p : yoneda.obj X ⟶ P), p ≫ f = p ≫ g
⊢ f = g
state_after: case w.h.h
C : Type u₁
inst✝ : Category.{v₁, u₁} C
P Q : Cᵒᵖ ⥤ Type v₁
f g : P ⟶ Q
h : ∀ (X : C) (p : yoneda.obj X ⟶ P), p ≫ f = p ≫ g
X : Cᵒᵖ
x : P.obj X
⊢ f.app X x = g.app X x
tactic: ext X x
state_before: case w.h.h
C : Type u₁
inst✝ : Category.{v₁, u₁} C
P Q : Cᵒᵖ ⥤ Type v₁
f g : P ⟶ Q
h : ∀ (X : C) (p : yoneda.obj X ⟶ P), p ≫ f = p ≫ g
X : Cᵒᵖ
x : P.obj X
⊢ f.app X x = g.app X x
state_after: no goals
tactic: simpa only [yonedaEquiv_comp, Equiv.apply_symm_apply]
    using congr_arg (yonedaEquiv) (h _ (yonedaEquiv.symm x))
Theorem: CategoryTheory.Abelian.factorThruImage_comp_coimageIsoImage'_inv
File: Mathlib/CategoryTheory/Abelian/Basic.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Abelian C
X Y : C
f : X ⟶ Y
⊢ factorThruImage f ≫ (coimageIsoImage' f).inv = cokernel.π (kernel.ι f)
state_after: no goals
tactic: simp only [IsImage.isoExt_inv, image.isImage_lift, image.fac_lift,
    coimageStrongEpiMonoFactorisation_e]
Theorem: Zsqrtd.sqLe_add
File: Mathlib/NumberTheory/Zsqrtd/Basic.lean

Proof steps:
state_before: d✝ : ℤ
c d x y z w : ℕ
xy : SqLe x c y d
zw : SqLe z c w d
⊢ SqLe (x + z) c (y + w) d
state_after: d✝ : ℤ
c d x y z w : ℕ
xy : SqLe x c y d
zw : SqLe z c w d
xz : c * (x * z) ≤ d * (y * w)
⊢ SqLe (x + z) c (y + w) d
tactic: have xz := sqLe_add_mixed xy zw
state_before: d✝ : ℤ
c d x y z w : ℕ
xy : SqLe x c y d
zw : SqLe z c w d
xz : c * (x * z) ≤ d * (y * w)
⊢ SqLe (x + z) c (y + w) d
state_after: d✝ : ℤ
c d x y z w : ℕ
xz : c * (x * z) ≤ d * (y * w)
xy : c * (x * x) ≤ d * (y * y)
zw : c * (z * z) ≤ d * (w * w)
⊢ SqLe (x + z) c (y + w) d
tactic: simp? [SqLe, mul_assoc] at xy zw says simp only [SqLe, mul_assoc] at xy zw
state_before: d✝ : ℤ
c d x y z w : ℕ
xz : c * (x * z) ≤ d * (y * w)
xy : c * (x * x) ≤ d * (y * y)
zw : c * (z * z) ≤ d * (w * w)
⊢ SqLe (x + z) c (y + w) d
state_after: no goals
tactic: simp [SqLe, mul_add, mul_comm, mul_left_comm, add_le_add, *]
Theorem: TensorAlgebra.equivFreeAlgebra_ι_apply
File: Mathlib/LinearAlgebra/TensorAlgebra/Basis.lean

Proof steps:
state_before: κ : Type uκ
R : Type uR
M : Type uM
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
b : Basis κ R M
i : κ
⊢ (Finsupp.total κ (FreeAlgebra R κ) R (FreeAlgebra.ι R) ∘ₗ ↑b.repr) (b i) = FreeAlgebra.ι R i
state_after: no goals
tactic: simp
Theorem: Cubic.degree_of_d_ne_zero
File: Mathlib/Algebra/CubicDiscriminant.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
F : Type u_3
K : Type u_4
P Q : Cubic R
a b c d a' b' c' d' : R
inst✝ : Semiring R
ha : P.a = 0
hb : P.b = 0
hc : P.c = 0
hd : P.d ≠ 0
⊢ P.toPoly.degree = 0
state_after: no goals
tactic: rw [of_c_eq_zero ha hb hc, degree_C hd]
Theorem: FreeAddGroup.Red.append_append_left_iff
File: Mathlib/GroupTheory/FreeGroup/Basic.lean

Proof steps:
state_before: α : Type u
L✝ L₁ L₂ L₃ L₄ : List (α × Bool)
p : α × Bool
L : List (α × Bool)
⊢ Red (p :: L ++ L₁) (p :: L ++ L₂) ↔ Red L₁ L₂
state_after: no goals
tactic: simp [append_append_left_iff L, cons_cons_iff]
Theorem: Basis.orientation_map
File: Mathlib/LinearAlgebra/Orientation.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
ι : Type u_4
ι' : Type u_5
inst✝³ : Fintype ι
inst✝² : DecidableEq ι
inst✝¹ : Fintype ι'
inst✝ : DecidableEq ι'
e : Basis ι R M
f : M ≃ₗ[R] N
⊢ (e.map f).orientation = (Orientation.map ι f) e.orientation
state_after: no goals
tactic: simp_rw [Basis.orientation, Orientation.map_apply, Basis.det_map']
Theorem: Complex.div_ofReal_im
File: Mathlib/Data/Complex/Basic.lean

Proof steps:
state_before: z : ℂ
x : ℝ
⊢ (z / ↑x).im = z.im / x
state_after: no goals
tactic: rw [div_ofReal]
Theorem: Unitization.antilipschitzWith_addEquiv
File: Mathlib/Analysis/Normed/Algebra/Unitization.lean

Proof steps:
state_before: 𝕜 : Type u_1
A : Type u_2
inst✝⁵ : NontriviallyNormedField 𝕜
inst✝⁴ : NonUnitalNormedRing A
inst✝³ : NormedSpace 𝕜 A
inst✝² : IsScalarTower 𝕜 A A
inst✝¹ : SMulCommClass 𝕜 A A
inst✝ : RegularNormedAlgebra 𝕜 A
⊢ AntilipschitzWith 2 ⇑(addEquiv 𝕜 A)
state_after: 𝕜 : Type u_1
A : Type u_2
inst✝⁵ : NontriviallyNormedField 𝕜
inst✝⁴ : NonUnitalNormedRing A
inst✝³ : NormedSpace 𝕜 A
inst✝² : IsScalarTower 𝕜 A A
inst✝¹ : SMulCommClass 𝕜 A A
inst✝ : RegularNormedAlgebra 𝕜 A
x : Unitization 𝕜 A
⊢ ‖x‖ ≤ ↑2 * ‖(addEquiv 𝕜 A) x‖
tactic: refine AddMonoidHomClass.antilipschitz_of_bound (addEquiv 𝕜 A) fun x => ?_
state_before: 𝕜 : Type u_1
A : Type u_2
inst✝⁵ : NontriviallyNormedField 𝕜
inst✝⁴ : NonUnitalNormedRing A
inst✝³ : NormedSpace 𝕜 A
inst✝² : IsScalarTower 𝕜 A A
inst✝¹ : SMulCommClass 𝕜 A A
inst✝ : RegularNormedAlgebra 𝕜 A
x : Unitization 𝕜 A
⊢ ‖x‖ ≤ ↑2 * ‖(addEquiv 𝕜 A) x‖
state_after: 𝕜 : Type u_1
A : Type u_2
inst✝⁵ : NontriviallyNormedField 𝕜
inst✝⁴ : NonUnitalNormedRing A
inst✝³ : NormedSpace 𝕜 A
inst✝² : IsScalarTower 𝕜 A A
inst✝¹ : SMulCommClass 𝕜 A A
inst✝ : RegularNormedAlgebra 𝕜 A
x : Unitization 𝕜 A
⊢ ‖x.fst‖ ⊔ ‖(algebraMap 𝕜 (A →L[𝕜] A)) x.fst + (mul 𝕜 A) x.snd‖ ≤ 2 * max ‖((addEquiv 𝕜 A) x).1‖ ‖((addEquiv 𝕜 A) x).2‖
tactic: rw [norm_eq_sup, Prod.norm_def, NNReal.coe_two]
state_before: 𝕜 : Type u_1
A : Type u_2
inst✝⁵ : NontriviallyNormedField 𝕜
inst✝⁴ : NonUnitalNormedRing A
inst✝³ : NormedSpace 𝕜 A
inst✝² : IsScalarTower 𝕜 A A
inst✝¹ : SMulCommClass 𝕜 A A
inst✝ : RegularNormedAlgebra 𝕜 A
x : Unitization 𝕜 A
⊢ ‖x.fst‖ ⊔ ‖(algebraMap 𝕜 (A →L[𝕜] A)) x.fst + (mul 𝕜 A) x.snd‖ ≤ 2 * max ‖((addEquiv 𝕜 A) x).1‖ ‖((addEquiv 𝕜 A) x).2‖
state_after: case refine_1
𝕜 : Type u_1
A : Type u_2
inst✝⁵ : NontriviallyNormedField 𝕜
inst✝⁴ : NonUnitalNormedRing A
inst✝³ : NormedSpace 𝕜 A
inst✝² : IsScalarTower 𝕜 A A
inst✝¹ : SMulCommClass 𝕜 A A
inst✝ : RegularNormedAlgebra 𝕜 A
x : Unitization 𝕜 A
⊢ ‖x.fst‖ ≤ 2 * max ‖((addEquiv 𝕜 A) x).1‖ ‖((addEquiv 𝕜 A) x).2‖

case refine_2
𝕜 : Type u_1
A : Type u_2
inst✝⁵ : NontriviallyNormedField 𝕜
inst✝⁴ : NonUnitalNormedRing A
inst✝³ : NormedSpace 𝕜 A
inst✝² : IsScalarTower 𝕜 A A
inst✝¹ : SMulCommClass 𝕜 A A
inst✝ : RegularNormedAlgebra 𝕜 A
x : Unitization 𝕜 A
⊢ ‖(algebraMap 𝕜 (A →L[𝕜] A)) x.fst + (mul 𝕜 A) x.snd‖ ≤ 2 * max ‖((addEquiv 𝕜 A) x).1‖ ‖((addEquiv 𝕜 A) x).2‖
tactic: refine max_le ?_ ?_