ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: quadratic_eq_zero_iff
File: Mathlib/Algebra/QuadraticDiscriminant.lean

Proof steps:
state_before: K : Type u_1
inst✝¹ : Field K
inst✝ : NeZero 2
a b c x✝ : K
ha : a ≠ 0
s : K
h : discrim a b c = s * s
x : K
⊢ a * x * x + b * x + c = 0 ↔ x = (-b + s) / (2 * a) ∨ x = (-b - s) / (2 * a)
state_after: K : Type u_1
inst✝¹ : Field K
inst✝ : NeZero 2
a b c x✝ : K
ha : a ≠ 0
s : K
h : discrim a b c = s * s
x : K
⊢ s = 2 * a * x + b ∨ s = -(2 * a * x + b) ↔ x = (-b + s) / (2 * a) ∨ x = (-b - s) / (2 * a)
tactic: rw [quadratic_eq_zero_iff_discrim_eq_sq ha, h, sq, mul_self_eq_mul_self_iff]
state_before: K : Type u_1
inst✝¹ : Field K
inst✝ : NeZero 2
a b c x✝ : K
ha : a ≠ 0
s : K
h : discrim a b c = s * s
x : K
⊢ s = 2 * a * x + b ∨ s = -(2 * a * x + b) ↔ x = (-b + s) / (2 * a) ∨ x = (-b - s) / (2 * a)
state_after: K : Type u_1
inst✝¹ : Field K
inst✝ : NeZero 2
a b c x✝ : K
ha : a ≠ 0
s : K
h : discrim a b c = s * s
x : K
⊢ s = 2 * a * x + b ∨ s = -b + -(2 * a * x) ↔ x * (2 * a) = -b + s ∨ x * (2 * a) = -b - s
tactic: field_simp
state_before: K : Type u_1
inst✝¹ : Field K
inst✝ : NeZero 2
a b c x✝ : K
ha : a ≠ 0
s : K
h : discrim a b c = s * s
x : K
⊢ s = 2 * a * x + b ∨ s = -b + -(2 * a * x) ↔ x * (2 * a) = -b + s ∨ x * (2 * a) = -b - s
state_after: case h₁
K : Type u_1
inst✝¹ : Field K
inst✝ : NeZero 2
a b c x✝ : K
ha : a ≠ 0
s : K
h : discrim a b c = s * s
x : K
⊢ s = 2 * a * x + b ↔ x * (2 * a) = -b + s

case h₂
K : Type u_1
inst✝¹ : Field K
inst✝ : NeZero 2
a b c x✝ : K
ha : a ≠ 0
s : K
h : discrim a b c = s * s
x : K
⊢ s = -b + -(2 * a * x) ↔ x * (2 * a) = -b - s
tactic: apply or_congr
Theorem: SetTheory.PGame.Impartial.nonneg
File: Mathlib/SetTheory/Game/Impartial.lean

Proof steps:
state_before: G : PGame
inst✝ : G.Impartial
h : G < 0
⊢ False
state_after: G : PGame
inst✝ : G.Impartial
h : G < 0
h' : -0 < -G
⊢ False
tactic: have h' := neg_lt_neg_iff.2 h
state_before: G : PGame
inst✝ : G.Impartial
h : G < 0
h' : -0 < -G
⊢ False
state_after: G : PGame
inst✝ : G.Impartial
h : G < 0
h' : 0 < G
⊢ False
tactic: rw [neg_zero, lt_congr_right (Equiv.symm (neg_equiv_self G))] at h'
state_before: G : PGame
inst✝ : G.Impartial
h : G < 0
h' : 0 < G
⊢ False
state_after: no goals
tactic: exact (h.trans h').false
Theorem: CategoryTheory.Square.toArrowArrowFunctor'_map_left_left
File: Mathlib/CategoryTheory/Square.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
X✝ Y✝ : Square C
φ : X✝ ⟶ Y✝
⊢ Arrow.homMk ⋯ ≫ ((fun sq => Arrow.mk (Arrow.homMk ⋯)) Y✝).hom =
    ((fun sq => Arrow.mk (Arrow.homMk ⋯)) X✝).hom ≫ Arrow.homMk ⋯
state_after: no goals
tactic: aesop_cat
Theorem: Polynomial.coeff_update
File: Mathlib/Algebra/Polynomial/Basic.lean

Proof steps:
state_before: R : Type u
a✝ b : R
m n✝ : ℕ
inst✝ : Semiring R
p✝ q p : R[X]
n : ℕ
a : R
⊢ (p.update n a).coeff = Function.update p.coeff n a
state_after: case h
R : Type u
a✝ b : R
m n✝ : ℕ
inst✝ : Semiring R
p✝ q p : R[X]
n : ℕ
a : R
x✝ : ℕ
⊢ (p.update n a).coeff x✝ = Function.update p.coeff n a x✝
tactic: ext
state_before: case h
R : Type u
a✝ b : R
m n✝ : ℕ
inst✝ : Semiring R
p✝ q p : R[X]
n : ℕ
a : R
x✝ : ℕ
⊢ (p.update n a).coeff x✝ = Function.update p.coeff n a x✝
state_after: case h.ofFinsupp
R : Type u
a✝ b : R
m n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
n : ℕ
a : R
x✝ : ℕ
toFinsupp✝ : R[ℕ]
⊢ ({ toFinsupp := toFinsupp✝ }.update n a).coeff x✝ = Function.update { toFinsupp := toFinsupp✝ }.coeff n a x✝
tactic: cases p
state_before: case h.ofFinsupp
R : Type u
a✝ b : R
m n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
n : ℕ
a : R
x✝ : ℕ
toFinsupp✝ : R[ℕ]
⊢ ({ toFinsupp := toFinsupp✝ }.update n a).coeff x✝ = Function.update { toFinsupp := toFinsupp✝ }.coeff n a x✝
state_after: no goals
tactic: simp only [coeff, update, Function.update_apply, coe_update]
Theorem: Sum.LiftRel.swap
File: .lake/packages/batteries/Batteries/Data/Sum/Lemmas.lean

Proof steps:
state_before: α✝¹ : Type u_1
α✝ : Type u_2
r : α✝¹ → α✝ → Prop
β✝¹ : Type u_3
β✝ : Type u_4
s : β✝¹ → β✝ → Prop
x : α✝¹ ⊕ β✝¹
y : α✝ ⊕ β✝
h : LiftRel r s x y
⊢ LiftRel s r x.swap y.swap
state_after: case inl
α✝¹ : Type u_1
α✝ : Type u_2
r : α✝¹ → α✝ → Prop
β✝¹ : Type u_3
β✝ : Type u_4
s : β✝¹ → β✝ → Prop
a✝¹ : α✝¹
c✝ : α✝
a✝ : r a✝¹ c✝
⊢ LiftRel s r (inl a✝¹).swap (inl c✝).swap

case inr
α✝¹ : Type u_1
α✝ : Type u_2
r : α✝¹ → α✝ → Prop
β✝¹ : Type u_3
β✝ : Type u_4
s : β✝¹ → β✝ → Prop
b✝ : β✝¹
d✝ : β✝
a✝ : s b✝ d✝
⊢ LiftRel s r (inr b✝).swap (inr d✝).swap
tactic: cases h
Theorem: MeasurableSpace.CountablySeparated.mono
File: Mathlib/MeasureTheory/MeasurableSpace/CountablyGenerated.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m m' : MeasurableSpace α
hsep : CountablySeparated α
h : m ≤ m'
⊢ CountablySeparated α
state_after: α : Type u_1
β : Type u_2
m m' : MeasurableSpace α
h : m ≤ m'
hsep : HasCountableSeparatingOn α MeasurableSet univ
⊢ HasCountableSeparatingOn α MeasurableSet univ
tactic: simp_rw [countablySeparated_def] at *
state_before: α : Type u_1
β : Type u_2
m m' : MeasurableSpace α
h : m ≤ m'
hsep : HasCountableSeparatingOn α MeasurableSet univ
⊢ HasCountableSeparatingOn α MeasurableSet univ
state_after: case mk.intro.intro.intro
α : Type u_1
β : Type u_2
m m' : MeasurableSpace α
h : m ≤ m'
S : Set (Set α)
Sct : S.Countable
Smeas : ∀ s ∈ S, MeasurableSet s
hS : ∀ x ∈ univ, ∀ y ∈ univ, (∀ s ∈ S, x ∈ s ↔ y ∈ s) → x = y
⊢ HasCountableSeparatingOn α MeasurableSet univ
tactic: rcases hsep with ⟨S, Sct, Smeas, hS⟩
state_before: case mk.intro.intro.intro
α : Type u_1
β : Type u_2
m m' : MeasurableSpace α
h : m ≤ m'
S : Set (Set α)
Sct : S.Countable
Smeas : ∀ s ∈ S, MeasurableSet s
hS : ∀ x ∈ univ, ∀ y ∈ univ, (∀ s ∈ S, x ∈ s ↔ y ∈ s) → x = y
⊢ HasCountableSeparatingOn α MeasurableSet univ
state_after: no goals
tactic: use S, Sct, (fun s hs ↦ h _ <| Smeas _ hs), hS
Theorem: Asymptotics.IsBigO.hasFDerivWithinAt
File: Mathlib/Analysis/Calculus/FDeriv/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s✝ t : Set E
L L₁ L₂ : Filter E
s : Set E
x₀ : E
n : ℕ
h : f =O[𝓝[s] x₀] fun x => ‖x - x₀‖ ^ n
hx₀ : x₀ ∈ s
hn : 1 < n
⊢ HasFDerivWithinAt f 0 s x₀
state_after: no goals
tactic: simp_rw [HasFDerivWithinAt, hasFDerivAtFilter_iff_isLittleO,
    h.eq_zero_of_norm_pow_within hx₀ hn.ne_bot, zero_apply, sub_zero,
    h.trans_isLittleO ((isLittleO_pow_sub_sub x₀ hn).mono nhdsWithin_le_nhds)]
Theorem: gaussSum_mul_gaussSum_eq_card
File: Mathlib/NumberTheory/GaussSum.lean

Proof steps:
state_before: R : Type u
inst✝³ : Field R
inst✝² : Fintype R
R' : Type v
inst✝¹ : CommRing R'
inst✝ : IsDomain R'
χ : MulChar R R'
hχ : χ ≠ 1
ψ : AddChar R R'
hψ : ψ.IsPrimitive
⊢ gaussSum χ ψ * gaussSum χ⁻¹ ψ⁻¹ = ↑(Fintype.card R)
state_after: R : Type u
inst✝³ : Field R
inst✝² : Fintype R
R' : Type v
inst✝¹ : CommRing R'
inst✝ : IsDomain R'
χ : MulChar R R'
hχ : χ ≠ 1
ψ : AddChar R R'
hψ : ψ.IsPrimitive
⊢ ∑ x : R, ∑ i : R, χ i * ψ i * (χ x⁻¹ * ψ (-x)) = ↑(Fintype.card R)
tactic: simp only [gaussSum, AddChar.inv_apply, Finset.sum_mul, Finset.mul_sum, MulChar.inv_apply']
state_before: R : Type u
inst✝³ : Field R
inst✝² : Fintype R
R' : Type v
inst✝¹ : CommRing R'
inst✝ : IsDomain R'
χ : MulChar R R'
hχ : χ ≠ 1
ψ : AddChar R R'
hψ : ψ.IsPrimitive
⊢ ∑ x : R, ∑ i : R, χ i * ψ i * (χ x⁻¹ * ψ (-x)) = ↑(Fintype.card R)
state_after: R : Type u
inst✝³ : Field R
inst✝² : Fintype R
R' : Type v
inst✝¹ : CommRing R'
inst✝ : IsDomain R'
χ : MulChar R R'
hχ : χ ≠ 1
ψ : AddChar R R'
hψ : ψ.IsPrimitive
⊢ ∑ x : R, ∑ y : R, χ (y * x⁻¹) * ψ (y - x) = ↑(Fintype.card R)
tactic: conv =>
    enter [1, 2, x, 2, y]
    rw [mul_mul_mul_comm, ← map_mul, ← map_add_eq_mul, ← sub_eq_add_neg]
state_before: R : Type u
inst✝³ : Field R
inst✝² : Fintype R
R' : Type v
inst✝¹ : CommRing R'
inst✝ : IsDomain R'
χ : MulChar R R'
hχ : χ ≠ 1
ψ : AddChar R R'
hψ : ψ.IsPrimitive
⊢ ∑ x : R, ∑ y : R, χ (y * x⁻¹) * ψ (y - x) = ↑(Fintype.card R)
state_after: R : Type u
inst✝³ : Field R
inst✝² : Fintype R
R' : Type v
inst✝¹ : CommRing R'
inst✝ : IsDomain R'
χ : MulChar R R'
hχ : χ ≠ 1
ψ : AddChar R R'
hψ : ψ.IsPrimitive
⊢ ∑ x : R, ∑ c : R, χ c * ψ (x * (c - 1)) = ↑(Fintype.card R)
tactic: simp_rw [gaussSum_mul_aux hχ ψ]
state_before: R : Type u
inst✝³ : Field R
inst✝² : Fintype R
R' : Type v
inst✝¹ : CommRing R'
inst✝ : IsDomain R'
χ : MulChar R R'
hχ : χ ≠ 1
ψ : AddChar R R'
hψ : ψ.IsPrimitive
⊢ ∑ x : R, ∑ c : R, χ c * ψ (x * (c - 1)) = ↑(Fintype.card R)
state_after: R : Type u
inst✝³ : Field R
inst✝² : Fintype R
R' : Type v
inst✝¹ : CommRing R'
inst✝ : IsDomain R'
χ : MulChar R R'
hχ : χ ≠ 1
ψ : AddChar R R'
hψ : ψ.IsPrimitive
⊢ ∑ y : R, ∑ x : R, χ y * ψ (x * (y - 1)) = ↑(Fintype.card R)
tactic: rw [Finset.sum_comm]
state_before: R : Type u
inst✝³ : Field R
inst✝² : Fintype R
R' : Type v
inst✝¹ : CommRing R'
inst✝ : IsDomain R'
χ : MulChar R R'
hχ : χ ≠ 1
ψ : AddChar R R'
hψ : ψ.IsPrimitive
⊢ ∑ y : R, ∑ x : R, χ y * ψ (x * (y - 1)) = ↑(Fintype.card R)
state_after: no goals
tactic: classical -- to get `[DecidableEq R]` for `sum_mulShift`
  simp_rw [← Finset.mul_sum, sum_mulShift _ hψ, sub_eq_zero, apply_ite, Nat.cast_zero, mul_zero]
  rw [Finset.sum_ite_eq' Finset.univ (1 : R)]
  simp only [Finset.mem_univ, map_one, one_mul, if_true]
Theorem: rootsOfUnityEquivOfPrimitiveRoots_symm_apply
File: Mathlib/RingTheory/RootsOfUnity/Basic.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
G : Type u_3
R : Type u_4
S✝ : Type u_5
F✝ : Type u_6
inst✝⁸ : CommMonoid M
inst✝⁷ : CommMonoid N
inst✝⁶ : DivisionCommMonoid G
k l : ℕ
inst✝⁵ : CommRing R
ζ : Rˣ
h : IsPrimitiveRoot ζ k
inst✝⁴ : IsDomain R
S : Type u_7
F : Type u_8
inst✝³ : CommRing S
inst✝² : IsDomain S
inst✝¹ : FunLike F R S
inst✝ : MonoidHomClass F R S
n : ℕ+
f : F
hf : Function.Injective ⇑f
hζ : (primitiveRoots (↑n) R).Nonempty
η : ↥(rootsOfUnity n S)
⊢ f ↑↑((rootsOfUnityEquivOfPrimitiveRoots hf hζ).symm η) = ↑↑η
state_after: case intro
M : Type u_1
N : Type u_2
G : Type u_3
R : Type u_4
S✝ : Type u_5
F✝ : Type u_6
inst✝⁸ : CommMonoid M
inst✝⁷ : CommMonoid N
inst✝⁶ : DivisionCommMonoid G
k l : ℕ
inst✝⁵ : CommRing R
ζ : Rˣ
h : IsPrimitiveRoot ζ k
inst✝⁴ : IsDomain R
S : Type u_7
F : Type u_8
inst✝³ : CommRing S
inst✝² : IsDomain S
inst✝¹ : FunLike F R S
inst✝ : MonoidHomClass F R S
n : ℕ+
f : F
hf : Function.Injective ⇑f
hζ : (primitiveRoots (↑n) R).Nonempty
ε : ↥(rootsOfUnity n R)
⊢ f ↑↑((rootsOfUnityEquivOfPrimitiveRoots hf hζ).symm ((rootsOfUnityEquivOfPrimitiveRoots hf hζ) ε)) =
    ↑↑((rootsOfUnityEquivOfPrimitiveRoots hf hζ) ε)
tactic: obtain ⟨ε, rfl⟩ := (rootsOfUnityEquivOfPrimitiveRoots hf hζ).surjective η
state_before: case intro
M : Type u_1
N : Type u_2
G : Type u_3
R : Type u_4
S✝ : Type u_5
F✝ : Type u_6
inst✝⁸ : CommMonoid M
inst✝⁷ : CommMonoid N
inst✝⁶ : DivisionCommMonoid G
k l : ℕ
inst✝⁵ : CommRing R
ζ : Rˣ
h : IsPrimitiveRoot ζ k
inst✝⁴ : IsDomain R
S : Type u_7
F : Type u_8
inst✝³ : CommRing S
inst✝² : IsDomain S
inst✝¹ : FunLike F R S
inst✝ : MonoidHomClass F R S
n : ℕ+
f : F
hf : Function.Injective ⇑f
hζ : (primitiveRoots (↑n) R).Nonempty
ε : ↥(rootsOfUnity n R)
⊢ f ↑↑((rootsOfUnityEquivOfPrimitiveRoots hf hζ).symm ((rootsOfUnityEquivOfPrimitiveRoots hf hζ) ε)) =
    ↑↑((rootsOfUnityEquivOfPrimitiveRoots hf hζ) ε)
state_after: no goals
tactic: rw [MulEquiv.symm_apply_apply, val_rootsOfUnityEquivOfPrimitiveRoots_apply_coe]
Theorem: span_fourierLp_closure_eq_top
File: Mathlib/Analysis/Fourier/AddCircle.lean

Proof steps:
state_before: T : ℝ
hT : Fact (0 < T)
p : ℝ≥0∞
inst✝ : Fact (1 ≤ p)
hp : p ≠ ⊤
⊢ (span ℂ (range (fourierLp p))).topologicalClosure = ⊤
state_after: case h.e'_2.h.e'_9.h.h
T : ℝ
hT : Fact (0 < T)
p : ℝ≥0∞
inst✝ : Fact (1 ≤ p)
hp : p ≠ ⊤
e_3✝ : Complex.instSemiring = DivisionSemiring.toSemiring
he✝ : Lp.instModule = Lp.instModule
⊢ span ℂ (range (fourierLp p)) = Submodule.map (↑(toLp p haarAddCircle ℂ)) (span ℂ (range fourier))
tactic: convert
    (ContinuousMap.toLp_denseRange ℂ (@haarAddCircle T hT) hp ℂ).topologicalClosure_map_submodule
      span_fourier_closure_eq_top
state_before: case h.e'_2.h.e'_9.h.h
T : ℝ
hT : Fact (0 < T)
p : ℝ≥0∞
inst✝ : Fact (1 ≤ p)
hp : p ≠ ⊤
e_3✝ : Complex.instSemiring = DivisionSemiring.toSemiring
he✝ : Lp.instModule = Lp.instModule
⊢ span ℂ (range (fourierLp p)) = Submodule.map (↑(toLp p haarAddCircle ℂ)) (span ℂ (range fourier))
state_after: case h.e'_2.h.e'_9.h.h
T : ℝ
hT : Fact (0 < T)
p : ℝ≥0∞
inst✝ : Fact (1 ≤ p)
hp : p ≠ ⊤
e_3✝ : Complex.instSemiring = DivisionSemiring.toSemiring
he✝ : Lp.instModule = Lp.instModule
⊢ span ℂ (⇑(toLp p haarAddCircle ℂ) '' range fourier) = span ℂ (⇑↑(toLp p haarAddCircle ℂ) '' range fourier)
tactic: erw [map_span, range_comp]
state_before: case h.e'_2.h.e'_9.h.h
T : ℝ
hT : Fact (0 < T)
p : ℝ≥0∞
inst✝ : Fact (1 ≤ p)
hp : p ≠ ⊤
e_3✝ : Complex.instSemiring = DivisionSemiring.toSemiring
he✝ : Lp.instModule = Lp.instModule
⊢ span ℂ (⇑(toLp p haarAddCircle ℂ) '' range fourier) = span ℂ (⇑↑(toLp p haarAddCircle ℂ) '' range fourier)
state_after: no goals
tactic: simp only [ContinuousLinearMap.coe_coe]
Theorem: Int.eq_mul_div_of_mul_eq_mul_of_dvd_left
File: Mathlib/Data/Int/Defs.lean

Proof steps:
state_before: a b c d m n : ℤ
hb : b ≠ 0
hbc : b ∣ c
h : b * a = c * d
⊢ a = c / b * d
state_after: case intro
a b d m n : ℤ
hb : b ≠ 0
k : ℤ
h : b * a = b * k * d
⊢ a = b * k / b * d
tactic: obtain ⟨k, rfl⟩ := hbc
state_before: case intro
a b d m n : ℤ
hb : b ≠ 0
k : ℤ
h : b * a = b * k * d
⊢ a = b * k / b * d
state_after: case intro
a b d m n : ℤ
hb : b ≠ 0
k : ℤ
h : b * a = b * k * d
⊢ a = k * d
tactic: rw [Int.mul_ediv_cancel_left _ hb]
state_before: case intro
a b d m n : ℤ
hb : b ≠ 0
k : ℤ
h : b * a = b * k * d
⊢ a = k * d
state_after: no goals
tactic: rwa [Int.mul_assoc, Int.mul_eq_mul_left_iff hb] at h
Theorem: Measurable.iInf_Prop
File: Mathlib/MeasureTheory/Constructions/BorelSpace/Order.lean

Proof steps:
state_before: α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort y
s t u : Set α✝
inst✝⁸ : TopologicalSpace α✝
inst✝⁷ : MeasurableSpace α✝
inst✝⁶ : BorelSpace α✝
inst✝⁵ : TopologicalSpace β
inst✝⁴ : MeasurableSpace β
inst✝³ : BorelSpace β
inst✝² : MeasurableSpace δ
α : Type u_5
inst✝¹ : MeasurableSpace α
inst✝ : ConditionallyCompleteLattice α
p : Prop
f : δ → α
hf : Measurable f
⊢ Measurable fun b => ⨅ (_ : p), f b
state_after: α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort y
s t u : Set α✝
inst✝⁸ : TopologicalSpace α✝
inst✝⁷ : MeasurableSpace α✝
inst✝⁶ : BorelSpace α✝
inst✝⁵ : TopologicalSpace β
inst✝⁴ : MeasurableSpace β
inst✝³ : BorelSpace β
inst✝² : MeasurableSpace δ
α : Type u_5
inst✝¹ : MeasurableSpace α
inst✝ : ConditionallyCompleteLattice α
p : Prop
f : δ → α
hf : Measurable f
⊢ Measurable fun b => if h : p then f b else sInf ∅
tactic: simp_rw [ciInf_eq_ite]
state_before: α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort y
s t u : Set α✝
inst✝⁸ : TopologicalSpace α✝
inst✝⁷ : MeasurableSpace α✝
inst✝⁶ : BorelSpace α✝
inst✝⁵ : TopologicalSpace β
inst✝⁴ : MeasurableSpace β
inst✝³ : BorelSpace β
inst✝² : MeasurableSpace δ
α : Type u_5
inst✝¹ : MeasurableSpace α
inst✝ : ConditionallyCompleteLattice α
p : Prop
f : δ → α
hf : Measurable f
⊢ Measurable fun b => if h : p then f b else sInf ∅
state_after: case pos
α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort y
s t u : Set α✝
inst✝⁸ : TopologicalSpace α✝
inst✝⁷ : MeasurableSpace α✝
inst✝⁶ : BorelSpace α✝
inst✝⁵ : TopologicalSpace β
inst✝⁴ : MeasurableSpace β
inst✝³ : BorelSpace β
inst✝² : MeasurableSpace δ
α : Type u_5
inst✝¹ : MeasurableSpace α
inst✝ : ConditionallyCompleteLattice α
p : Prop
f : δ → α
hf : Measurable f
h : p
⊢ Measurable fun b => f b

case neg
α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort y
s t u : Set α✝
inst✝⁸ : TopologicalSpace α✝
inst✝⁷ : MeasurableSpace α✝
inst✝⁶ : BorelSpace α✝
inst✝⁵ : TopologicalSpace β
inst✝⁴ : MeasurableSpace β
inst✝³ : BorelSpace β
inst✝² : MeasurableSpace δ
α : Type u_5
inst✝¹ : MeasurableSpace α
inst✝ : ConditionallyCompleteLattice α
p : Prop
f : δ → α
hf : Measurable f
h : ¬p
⊢ Measurable fun b => sInf ∅
tactic: split_ifs with h
Theorem: Nat.add_le_mul
File: Mathlib/Data/Nat/Defs.lean

Proof steps:
state_before: a✝ b c d m n k : ℕ
p q : ℕ → Prop
a : ℕ
ha : 2 ≤ a
x✝ : 2 ≤ 2
⊢ a + 2 ≤ a * 2
state_after: no goals
tactic: omega
state_before: a✝ b✝ c d m n k : ℕ
p q : ℕ → Prop
a : ℕ
ha : 2 ≤ a
b : ℕ
x✝ : 2 ≤ b + 3
⊢ a + (b + 3) ≤ a * (b + 3)
state_after: a✝ b✝ c d m n k : ℕ
p q : ℕ → Prop
a : ℕ
ha : 2 ≤ a
b : ℕ
x✝ : 2 ≤ b + 3
this : a + (b + 2) ≤ a * (b + 2)
⊢ a + (b + 3) ≤ a * (b + 3)
tactic: have := Nat.add_le_mul ha (Nat.le_add_left _ b)
state_before: a✝ b✝ c d m n k : ℕ
p q : ℕ → Prop
a : ℕ
ha : 2 ≤ a
b : ℕ
x✝ : 2 ≤ b + 3
this : a + (b + 2) ≤ a * (b + 2)
⊢ a + (b + 3) ≤ a * (b + 3)
state_after: a✝ b✝ c d m n k : ℕ
p q : ℕ → Prop
a : ℕ
ha : 2 ≤ a
b : ℕ
x✝ : 2 ≤ b + 3
this : a + (b + 2) ≤ a * (b + 2)
⊢ a + (b + 3) ≤ a * (b + 2) + a
tactic: rw [mul_succ]
state_before: a✝ b✝ c d m n k : ℕ
p q : ℕ → Prop
a : ℕ
ha : 2 ≤ a
b : ℕ
x✝ : 2 ≤ b + 3
this : a + (b + 2) ≤ a * (b + 2)
⊢ a + (b + 3) ≤ a * (b + 2) + a
state_after: no goals
tactic: omega
Theorem: uniformEquicontinuousOn_iff_uniformContinuousOn
File: Mathlib/Topology/UniformSpace/Equicontinuity.lean

Proof steps:
state_before: ι : Type u_1
κ : Type u_2
X : Type u_3
X' : Type u_4
Y : Type u_5
Z : Type u_6
α : Type u_7
α' : Type u_8
β : Type u_9
β' : Type u_10
γ : Type u_11
𝓕 : Type u_12
tX : TopologicalSpace X
tY : TopologicalSpace Y
tZ : TopologicalSpace Z
uα : UniformSpace α
uβ : UniformSpace β
uγ : UniformSpace γ
F : ι → β → α
S : Set β
⊢ UniformEquicontinuousOn F S ↔ UniformContinuousOn (⇑UniformFun.ofFun ∘ swap F) S
state_after: ι : Type u_1
κ : Type u_2
X : Type u_3
X' : Type u_4
Y : Type u_5
Z : Type u_6
α : Type u_7
α' : Type u_8
β : Type u_9
β' : Type u_10
γ : Type u_11
𝓕 : Type u_12
tX : TopologicalSpace X
tY : TopologicalSpace Y
tZ : TopologicalSpace Z
uα : UniformSpace α
uβ : UniformSpace β
uγ : UniformSpace γ
F : ι → β → α
S : Set β
⊢ UniformEquicontinuousOn F S ↔
    ∀ i ∈ 𝓤 α,
      ∀ᶠ (x : β × β) in 𝓤 β ⊓ 𝓟 (S ×ˢ S),
        ((⇑UniformFun.ofFun ∘ swap F) x.1, (⇑UniformFun.ofFun ∘ swap F) x.2) ∈ UniformFun.gen ι α i
tactic: rw [UniformContinuousOn, (UniformFun.hasBasis_uniformity ι α).tendsto_right_iff]
state_before: ι : Type u_1
κ : Type u_2
X : Type u_3
X' : Type u_4
Y : Type u_5
Z : Type u_6
α : Type u_7
α' : Type u_8
β : Type u_9
β' : Type u_10
γ : Type u_11
𝓕 : Type u_12
tX : TopologicalSpace X
tY : TopologicalSpace Y
tZ : TopologicalSpace Z
uα : UniformSpace α
uβ : UniformSpace β
uγ : UniformSpace γ
F : ι → β → α
S : Set β
⊢ UniformEquicontinuousOn F S ↔
    ∀ i ∈ 𝓤 α,
      ∀ᶠ (x : β × β) in 𝓤 β ⊓ 𝓟 (S ×ˢ S),
        ((⇑UniformFun.ofFun ∘ swap F) x.1, (⇑UniformFun.ofFun ∘ swap F) x.2) ∈ UniformFun.gen ι α i
state_after: no goals
tactic: rfl
Theorem: Finset.SupIndep.le_sup_iff
File: Mathlib/Order/SupIndep.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
ι' : Type u_4
inst✝¹ : Lattice α
inst✝ : OrderBot α
s t : Finset ι
f : ι → α
i : ι
hs : s.SupIndep f
hts : t ⊆ s
hi : i ∈ s
hf : ∀ (i : ι), f i ≠ ⊥
⊢ f i ≤ t.sup f ↔ i ∈ t
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
ι' : Type u_4
inst✝¹ : Lattice α
inst✝ : OrderBot α
s t : Finset ι
f : ι → α
i : ι
hs : s.SupIndep f
hts : t ⊆ s
hi : i ∈ s
hf : ∀ (i : ι), f i ≠ ⊥
h : f i ≤ t.sup f
⊢ i ∈ t
tactic: refine ⟨fun h => ?_, le_sup⟩
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
ι' : Type u_4
inst✝¹ : Lattice α
inst✝ : OrderBot α
s t : Finset ι
f : ι → α
i : ι
hs : s.SupIndep f
hts : t ⊆ s
hi : i ∈ s
hf : ∀ (i : ι), f i ≠ ⊥
h : f i ≤ t.sup f
⊢ i ∈ t
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
ι' : Type u_4
inst✝¹ : Lattice α
inst✝ : OrderBot α
s t : Finset ι
f : ι → α
i : ι
hs : s.SupIndep f
hts : t ⊆ s
hi : i ∈ s
hf : ∀ (i : ι), f i ≠ ⊥
h : f i ≤ t.sup f
hit : i ∉ t
⊢ False
tactic: by_contra hit
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
ι' : Type u_4
inst✝¹ : Lattice α
inst✝ : OrderBot α
s t : Finset ι
f : ι → α
i : ι
hs : s.SupIndep f
hts : t ⊆ s
hi : i ∈ s
hf : ∀ (i : ι), f i ≠ ⊥
h : f i ≤ t.sup f
hit : i ∉ t
⊢ False
state_after: no goals
tactic: exact hf i (disjoint_self.1 <| (hs hts hi hit).mono_right h)
Theorem: AlgebraicGeometry.Scheme.Pullback.t'_fst_snd
File: Mathlib/AlgebraicGeometry/Pullbacks.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : X.OpenCover
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (𝒰.map i ≫ f) g
i j k : 𝒰.J
⊢ t' 𝒰 f g i j k ≫
      pullback.fst (fV 𝒰 f g j k) (fV 𝒰 f g j i) ≫ pullback.snd (pullback.fst (𝒰.map j ≫ f) g ≫ 𝒰.map j) (𝒰.map k) =
    pullback.snd (fV 𝒰 f g i j) (fV 𝒰 f g i k) ≫ pullback.snd (pullback.fst (𝒰.map i ≫ f) g ≫ 𝒰.map i) (𝒰.map k)
state_after: no goals
tactic: simp only [t', Category.assoc, pullbackSymmetry_hom_comp_fst_assoc,
    pullbackRightPullbackFstIso_inv_snd_snd, pullback.lift_snd, Category.comp_id,
    pullbackRightPullbackFstIso_hom_snd]
Theorem: ProbabilityTheory.iIndep_iff_iIndepSets
File: Mathlib/Probability/Independence/Basic.lean

Proof steps:
state_before: Ω : Type u_1
ι : Type u_2
β : Type u_3
γ : Type u_4
κ : ι → Type u_5
π : ι → Set (Set Ω)
m✝ : ι → MeasurableSpace Ω
x✝ : MeasurableSpace Ω
μ✝ : Measure Ω
S : Finset ι
s : ι → Set Ω
m : ι → MeasurableSpace Ω
_mΩ : MeasurableSpace Ω
μ : Measure Ω
⊢ iIndep m μ ↔ iIndepSets (fun x => {s | MeasurableSet s}) μ
state_after: no goals
tactic: simp only [iIndep, iIndepSets, Kernel.iIndep]
Theorem: Finset.prod_filter
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

Proof steps:
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a✝ : α
f✝ g : α → β
inst✝¹ : CommMonoid β
p : α → Prop
inst✝ : DecidablePred p
f : α → β
a : α
h : a ∈ filter p s
⊢ f a = if p a then f a else 1
state_after: case hc
ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a✝ : α
f✝ g : α → β
inst✝¹ : CommMonoid β
p : α → Prop
inst✝ : DecidablePred p
f : α → β
a : α
h : a ∈ filter p s
⊢ p a
tactic: rw [if_pos]
state_before: case hc
ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a✝ : α
f✝ g : α → β
inst✝¹ : CommMonoid β
p : α → Prop
inst✝ : DecidablePred p
f : α → β
a : α
h : a ∈ filter p s
⊢ p a
state_after: no goals
tactic: simpa using (mem_filter.1 h).2
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝¹ : CommMonoid β
p : α → Prop
inst✝ : DecidablePred p
f : α → β
⊢ (∏ a ∈ filter p s, if p a then f a else 1) = ∏ a ∈ s, if p a then f a else 1
state_after: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝¹ : CommMonoid β
p : α → Prop
inst✝ : DecidablePred p
f : α → β
x : α
hs : x ∈ s
h : x ∉ filter p s
⊢ (if p x then f x else 1) = 1
tactic: refine prod_subset (filter_subset _ s) fun x hs h => ?_
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝¹ : CommMonoid β
p : α → Prop
inst✝ : DecidablePred p
f : α → β
x : α
hs : x ∈ s
h : x ∉ filter p s
⊢ (if p x then f x else 1) = 1
state_after: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝¹ : CommMonoid β
p : α → Prop
inst✝ : DecidablePred p
f : α → β
x : α
hs : x ∈ s
h : x ∈ s → ¬p x
⊢ (if p x then f x else 1) = 1
tactic: rw [mem_filter, not_and] at h
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝¹ : CommMonoid β
p : α → Prop
inst✝ : DecidablePred p
f : α → β
x : α
hs : x ∈ s
h : x ∈ s → ¬p x
⊢ (if p x then f x else 1) = 1
state_after: no goals
tactic: exact if_neg (by simpa using h hs)