ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: LaurentSeries.valuation_le_iff_coeff_lt_eq_zero
File: Mathlib/RingTheory/LaurentSeries.lean

Proof steps:
state_before: R : Type u_1
K : Type u_2
inst✝ : Field K
D : ℤ
f : LaurentSeries K
⊢ Valued.v f ≤ ↑(Multiplicative.ofAdd (-D)) ↔ ∀ n < D, f.coeff n = 0
state_after: R : Type u_1
K : Type u_2
inst✝ : Field K
D : ℤ
f : LaurentSeries K
h_val_f : ∀ n < D, f.coeff n = 0
⊢ Valued.v f ≤ ↑(Multiplicative.ofAdd (-D))
tactic: refine ⟨fun hnD n hn => coeff_zero_of_lt_valuation K hnD hn, fun h_val_f => ?_⟩
state_before: R : Type u_1
K : Type u_2
inst✝ : Field K
D : ℤ
f : LaurentSeries K
h_val_f : ∀ n < D, f.coeff n = 0
⊢ Valued.v f ≤ ↑(Multiplicative.ofAdd (-D))
state_after: R : Type u_1
K : Type u_2
inst✝ : Field K
D : ℤ
f : LaurentSeries K
h_val_f : ∀ n < D, f.coeff n = 0
F : K⟦X⟧ := f.powerSeriesPart
⊢ Valued.v f ≤ ↑(Multiplicative.ofAdd (-D))
tactic: let F := powerSeriesPart f
state_before: R : Type u_1
K : Type u_2
inst✝ : Field K
D : ℤ
f : LaurentSeries K
h_val_f : ∀ n < D, f.coeff n = 0
F : K⟦X⟧ := f.powerSeriesPart
⊢ Valued.v f ≤ ↑(Multiplicative.ofAdd (-D))
state_after: case pos
R : Type u_1
K : Type u_2
inst✝ : Field K
D : ℤ
f : LaurentSeries K
h_val_f : ∀ n < D, f.coeff n = 0
F : K⟦X⟧ := f.powerSeriesPart
ord_nonpos : HahnSeries.order f ≤ 0
⊢ Valued.v f ≤ ↑(Multiplicative.ofAdd (-D))

case neg
R : Type u_1
K : Type u_2
inst✝ : Field K
D : ℤ
f : LaurentSeries K
h_val_f : ∀ n < D, f.coeff n = 0
F : K⟦X⟧ := f.powerSeriesPart
ord_nonpos : ¬HahnSeries.order f ≤ 0
⊢ Valued.v f ≤ ↑(Multiplicative.ofAdd (-D))
tactic: by_cases ord_nonpos : f.order ≤ 0
Theorem: Real.IsConjExponent.conj_eq
File: Mathlib/Data/Real/ConjExponents.lean

Proof steps:
state_before: a b p q : ℝ
h✝ h : p.IsConjExponent q
⊢ q = p / (p - 1)
state_after: a b p q : ℝ
h✝ h : p.IsConjExponent q
this : p⁻¹ + q⁻¹ = 1
⊢ q = p / (p - 1)
tactic: have := h.inv_add_inv_conj
state_before: a b p q : ℝ
h✝ h : p.IsConjExponent q
this : p⁻¹ + q⁻¹ = 1
⊢ q = p / (p - 1)
state_after: a b p q : ℝ
h✝ h : p.IsConjExponent q
this : q = (1 - p⁻¹)⁻¹
⊢ q = p / (p - 1)
tactic: rw [← eq_sub_iff_add_eq', inv_eq_iff_eq_inv] at this
state_before: a b p q : ℝ
h✝ h : p.IsConjExponent q
this : q = (1 - p⁻¹)⁻¹
⊢ q = p / (p - 1)
state_after: no goals
tactic: field_simp [this, h.ne_zero]
Theorem: HurwitzZeta.isBigO_atTop_evenKernel_sub
File: Mathlib/NumberTheory/LSeries/HurwitzZetaEven.lean

Proof steps:
state_before: a : UnitAddCircle
⊢ ∃ p, 0 < p ∧ (fun x => evenKernel a x - if a = 0 then 1 else 0) =O[atTop] fun x => rexp (-p * x)
state_after: case H
b : ℝ
⊢ ∃ p, 0 < p ∧ (fun x => evenKernel (↑b) x - if ↑b = 0 then 1 else 0) =O[atTop] fun x => rexp (-p * x)
tactic: induction' a using QuotientAddGroup.induction_on with b
state_before: case H
b : ℝ
⊢ ∃ p, 0 < p ∧ (fun x => evenKernel (↑b) x - if ↑b = 0 then 1 else 0) =O[atTop] fun x => rexp (-p * x)
state_after: case H.intro.intro
b p : ℝ
hp : 0 < p
hp' : (fun t => HurwitzKernelBounds.F_int 0 (↑b) t - if ↑b = 0 then 1 else 0) =O[atTop] fun t => rexp (-p * t)
⊢ ∃ p, 0 < p ∧ (fun x => evenKernel (↑b) x - if ↑b = 0 then 1 else 0) =O[atTop] fun x => rexp (-p * x)
tactic: obtain ⟨p, hp, hp'⟩ := HurwitzKernelBounds.isBigO_atTop_F_int_zero_sub b
state_before: case H.intro.intro
b p : ℝ
hp : 0 < p
hp' : (fun t => HurwitzKernelBounds.F_int 0 (↑b) t - if ↑b = 0 then 1 else 0) =O[atTop] fun t => rexp (-p * t)
⊢ ∃ p, 0 < p ∧ (fun x => evenKernel (↑b) x - if ↑b = 0 then 1 else 0) =O[atTop] fun x => rexp (-p * x)
state_after: case H.intro.intro
b p : ℝ
hp : 0 < p
hp' : (fun t => HurwitzKernelBounds.F_int 0 (↑b) t - if ↑b = 0 then 1 else 0) =O[atTop] fun t => rexp (-p * t)
⊢ (fun x => evenKernel (↑b) x - if ↑b = 0 then 1 else 0) =ᶠ[atTop] fun t =>
    HurwitzKernelBounds.F_int 0 (↑b) t - if ↑b = 0 then 1 else 0
tactic: refine ⟨p, hp, (EventuallyEq.isBigO ?_).trans hp'⟩
state_before: case H.intro.intro
b p : ℝ
hp : 0 < p
hp' : (fun t => HurwitzKernelBounds.F_int 0 (↑b) t - if ↑b = 0 then 1 else 0) =O[atTop] fun t => rexp (-p * t)
⊢ (fun x => evenKernel (↑b) x - if ↑b = 0 then 1 else 0) =ᶠ[atTop] fun t =>
    HurwitzKernelBounds.F_int 0 (↑b) t - if ↑b = 0 then 1 else 0
state_after: case h
b p : ℝ
hp : 0 < p
hp' : (fun t => HurwitzKernelBounds.F_int 0 (↑b) t - if ↑b = 0 then 1 else 0) =O[atTop] fun t => rexp (-p * t)
t : ℝ
ht : 0 < t
⊢ (evenKernel (↑b) t - if ↑b = 0 then 1 else 0) = HurwitzKernelBounds.F_int 0 (↑b) t - if ↑b = 0 then 1 else 0
tactic: filter_upwards [eventually_gt_atTop 0] with t ht
state_before: case h
b p : ℝ
hp : 0 < p
hp' : (fun t => HurwitzKernelBounds.F_int 0 (↑b) t - if ↑b = 0 then 1 else 0) =O[atTop] fun t => rexp (-p * t)
t : ℝ
ht : 0 < t
⊢ (evenKernel (↑b) t - if ↑b = 0 then 1 else 0) = HurwitzKernelBounds.F_int 0 (↑b) t - if ↑b = 0 then 1 else 0
state_after: no goals
tactic: simp only [← (hasSum_int_evenKernel b ht).tsum_eq, HurwitzKernelBounds.F_int,
    HurwitzKernelBounds.f_int, pow_zero, one_mul, Function.Periodic.lift_coe]
Theorem: PNat.find_comp_succ
File: Mathlib/Data/PNat/Find.lean

Proof steps:
state_before: p q : ℕ+ → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
h✝ : ∃ n, p n
n m : ℕ+
h : ∃ n, p n
h₂ : ∃ n, p (n + 1)
h1 : ¬p 1
⊢ PNat.find h = PNat.find h₂ + 1
state_after: case refine_1
p q : ℕ+ → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
h✝ : ∃ n, p n
n✝ m : ℕ+
h : ∃ n, p n
h₂ : ∃ n, p (n + 1)
h1 : ¬p 1
n : ℕ+
⊢ 1 < PNat.find h₂ + 1 → ¬p 1

case refine_2
p q : ℕ+ → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
h✝ : ∃ n, p n
n✝ m : ℕ+
h : ∃ n, p n
h₂ : ∃ n, p (n + 1)
h1 : ¬p 1
n : ℕ+
⊢ ∀ (n : ℕ+), (n < PNat.find h₂ + 1 → ¬p n) → n + 1 < PNat.find h₂ + 1 → ¬p (n + 1)
tactic: refine (find_eq_iff _).2 ⟨PNat.find_spec h₂, fun n => PNat.recOn n ?_ ?_⟩
state_before: case refine_2
p q : ℕ+ → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
h✝ : ∃ n, p n
n✝ m : ℕ+
h : ∃ n, p n
h₂ : ∃ n, p (n + 1)
h1 : ¬p 1
n : ℕ+
⊢ ∀ (n : ℕ+), (n < PNat.find h₂ + 1 → ¬p n) → n + 1 < PNat.find h₂ + 1 → ¬p (n + 1)
state_after: case refine_2
p q : ℕ+ → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
h✝ : ∃ n, p n
n✝ m✝ : ℕ+
h : ∃ n, p n
h₂ : ∃ n, p (n + 1)
h1 : ¬p 1
n m : ℕ+
a✝ : m < PNat.find h₂ + 1 → ¬p m
hm : m + 1 < PNat.find h₂ + 1
⊢ ¬p (m + 1)
tactic: intro m _ hm
state_before: case refine_2
p q : ℕ+ → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
h✝ : ∃ n, p n
n✝ m✝ : ℕ+
h : ∃ n, p n
h₂ : ∃ n, p (n + 1)
h1 : ¬p 1
n m : ℕ+
a✝ : m < PNat.find h₂ + 1 → ¬p m
hm : m + 1 < PNat.find h₂ + 1
⊢ ¬p (m + 1)
state_after: case refine_2
p q : ℕ+ → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
h✝ : ∃ n, p n
n✝ m✝ : ℕ+
h : ∃ n, p n
h₂ : ∃ n, p (n + 1)
h1 : ¬p 1
n m : ℕ+
a✝ : m < PNat.find h₂ + 1 → ¬p m
hm : ∀ m_1 ≤ m, ¬p (m_1 + 1)
⊢ ¬p (m + 1)
tactic: simp only [add_lt_add_iff_right, lt_find_iff] at hm
state_before: case refine_2
p q : ℕ+ → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
h✝ : ∃ n, p n
n✝ m✝ : ℕ+
h : ∃ n, p n
h₂ : ∃ n, p (n + 1)
h1 : ¬p 1
n m : ℕ+
a✝ : m < PNat.find h₂ + 1 → ¬p m
hm : ∀ m_1 ≤ m, ¬p (m_1 + 1)
⊢ ¬p (m + 1)
state_after: no goals
tactic: exact hm _ le_rfl
Theorem: QuotientAddGroup.addSubgroup_eq_top_of_subsingleton
File: Mathlib/GroupTheory/QuotientGroup.lean

Proof steps:
state_before: G : Type u
inst✝² : Group G
N : Subgroup G
nN : N.Normal
H✝ : Type v
inst✝¹ : Group H✝
M : Type x
inst✝ : Monoid M
φ : G →* H✝
H : Subgroup G
h : Subsingleton (G ⧸ H)
x : G
x✝ : x ∈ ⊤
⊢ x ∈ H
state_after: G : Type u
inst✝² : Group G
N : Subgroup G
nN : N.Normal
H✝ : Type v
inst✝¹ : Group H✝
M : Type x
inst✝ : Monoid M
φ : G →* H✝
H : Subgroup G
h : Subsingleton (G ⧸ H)
x : G
x✝ : x ∈ ⊤
this : 1⁻¹ * x ∈ H
⊢ x ∈ H
tactic: have this : 1⁻¹ * x ∈ H := QuotientGroup.eq.1 (Subsingleton.elim _ _)
state_before: G : Type u
inst✝² : Group G
N : Subgroup G
nN : N.Normal
H✝ : Type v
inst✝¹ : Group H✝
M : Type x
inst✝ : Monoid M
φ : G →* H✝
H : Subgroup G
h : Subsingleton (G ⧸ H)
x : G
x✝ : x ∈ ⊤
this : 1⁻¹ * x ∈ H
⊢ x ∈ H
state_after: no goals
tactic: rwa [inv_one, one_mul] at this
Theorem: smul_ball''
File: Mathlib/Analysis/Normed/Group/Basic.lean

Proof steps:
state_before: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
⊢ a • ball b r = ball (a • b) r
state_after: case h
𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
x✝ : E
⊢ x✝ ∈ a • ball b r ↔ x✝ ∈ ball (a • b) r
tactic: ext
state_before: case h
𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
x✝ : E
⊢ x✝ ∈ a • ball b r ↔ x✝ ∈ ball (a • b) r
state_after: no goals
tactic: simp [mem_ball, Set.mem_smul_set, dist_eq_norm_div, _root_.div_eq_inv_mul,
    ← eq_inv_mul_iff_mul_eq, mul_assoc]
Theorem: LipschitzOnWith.mk_one
File: Mathlib/Topology/MetricSpace/Lipschitz.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝² : PseudoMetricSpace α
inst✝¹ : PseudoMetricSpace β
inst✝ : PseudoMetricSpace γ
K : ℝ≥0
s : Set α
f : α → β
h : ∀ x ∈ s, ∀ y ∈ s, dist (f x) (f y) ≤ dist x y
⊢ ∀ x ∈ s, ∀ y ∈ s, dist (f x) (f y) ≤ ↑1 * dist x y
state_after: no goals
tactic: simpa only [NNReal.coe_one, one_mul] using h
Theorem: CategoryTheory.Functor.ShiftSequence.shiftIso_add
File: Mathlib/CategoryTheory/Shift/ShiftSequence.lean

Proof steps:
state_before: C : Type u_1
A : Type u_2
inst✝⁵ : Category.{?u.225, u_1} C
inst✝⁴ : Category.{?u.229, u_2} A
F : C ⥤ A
M : Type u_3
inst✝³ : AddMonoid M
inst✝² : HasShift C M
G : Type u_4
inst✝¹ : AddGroup G
inst✝ : HasShift C G
sequence : M → C ⥤ A
isoZero : sequence 0 ≅ F
shiftIso : (n a a' : M) → n + a = a' → (shiftFunctor C n ⋙ sequence a ≅ sequence a')
shiftIso_zero :
  ∀ (a : M), shiftIso 0 a a ⋯ = isoWhiskerRight (shiftFunctorZero C M) (sequence a) ≪≫ (sequence a).leftUnitor
n m a a' a'' : M
ha' : n + a = a'
ha'' : m + a' = a''
⊢ m + n + a = a''
state_after: no goals
tactic: rw [add_assoc, ha', ha'']
Theorem: MvPowerSeries.coeff_mul
File: Mathlib/RingTheory/MvPowerSeries/Basic.lean

Proof steps:
state_before: σ : Type u_1
R : Type u_2
inst✝¹ : Semiring R
m n : σ →₀ ℕ
φ ψ : MvPowerSeries σ R
inst✝ : DecidableEq σ
⊢ (coeff R n) (φ * ψ) = ∑ p ∈ antidiagonal n, (coeff R p.1) φ * (coeff R p.2) ψ
state_after: σ : Type u_1
R : Type u_2
inst✝¹ : Semiring R
m n : σ →₀ ℕ
φ ψ : MvPowerSeries σ R
inst✝ : DecidableEq σ
⊢ antidiagonal n = antidiagonal n
tactic: refine Finset.sum_congr ?_ fun _ _ => rfl
state_before: σ : Type u_1
R : Type u_2
inst✝¹ : Semiring R
m n : σ →₀ ℕ
φ ψ : MvPowerSeries σ R
inst✝ : DecidableEq σ
⊢ antidiagonal n = antidiagonal n
state_after: no goals
tactic: rw [Subsingleton.elim (Classical.decEq σ) ‹DecidableEq σ›]
Theorem: Semiquot.mem_bind
File: Mathlib/Data/Semiquot.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
q : Semiquot α
f : α → Semiquot β
b : β
⊢ b ∈ q.bind f ↔ ∃ a ∈ q, b ∈ f a
state_after: α : Type u_1
β : Type u_2
q : Semiquot α
f : α → Semiquot β
b : β
⊢ b ∈ q.bind f ↔ ∃ a, ∃ (_ : a ∈ q), b ∈ f a
tactic: simp_rw [← exists_prop]
state_before: α : Type u_1
β : Type u_2
q : Semiquot α
f : α → Semiquot β
b : β
⊢ b ∈ q.bind f ↔ ∃ a, ∃ (_ : a ∈ q), b ∈ f a
state_after: no goals
tactic: exact Set.mem_iUnion₂
Theorem: CategoryTheory.MonoidalCategory.fullBraidedSubcategoryInclusion_ε
File: Mathlib/CategoryTheory/Monoidal/Subcategory.lean

Proof steps:
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : MonoidalCategory C
P : C → Prop
inst✝² : MonoidalPredicate P
P' : C → Prop
inst✝¹ : MonoidalPredicate P'
inst✝ : BraidedCategory C
X Y : FullSubcategory P
⊢ (fullMonoidalSubcategoryInclusion P).map (β_ X Y).hom =
    inv ((fullMonoidalSubcategoryInclusion P).μ X Y) ≫
      (β_ ((fullMonoidalSubcategoryInclusion P).obj X) ((fullMonoidalSubcategoryInclusion P).obj Y)).hom ≫
        (fullMonoidalSubcategoryInclusion P).μ Y X
state_after: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : MonoidalCategory C
P : C → Prop
inst✝² : MonoidalPredicate P
P' : C → Prop
inst✝¹ : MonoidalPredicate P'
inst✝ : BraidedCategory C
X Y : FullSubcategory P
⊢ (fullMonoidalSubcategoryInclusion P).μ X Y ≫ (fullMonoidalSubcategoryInclusion P).map (β_ X Y).hom =
    (β_ ((fullMonoidalSubcategoryInclusion P).obj X) ((fullMonoidalSubcategoryInclusion P).obj Y)).hom ≫
      (fullMonoidalSubcategoryInclusion P).μ Y X
tactic: rw [IsIso.eq_inv_comp]
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : MonoidalCategory C
P : C → Prop
inst✝² : MonoidalPredicate P
P' : C → Prop
inst✝¹ : MonoidalPredicate P'
inst✝ : BraidedCategory C
X Y : FullSubcategory P
⊢ (fullMonoidalSubcategoryInclusion P).μ X Y ≫ (fullMonoidalSubcategoryInclusion P).map (β_ X Y).hom =
    (β_ ((fullMonoidalSubcategoryInclusion P).obj X) ((fullMonoidalSubcategoryInclusion P).obj Y)).hom ≫
      (fullMonoidalSubcategoryInclusion P).μ Y X
state_after: no goals
tactic: aesop_cat
Theorem: Nat.one_lt_pow_iff
File: Mathlib/Data/Nat/Defs.lean

Proof steps:
state_before: a b c d m n✝ k : ℕ
p q : ℕ → Prop
n : ℕ
hn : n ≠ 0
⊢ 1 < 0 ^ n ↔ 1 < 0
state_after: no goals
tactic: simp [Nat.zero_pow (Nat.pos_of_ne_zero hn)]
state_before: a b c d m n✝ k : ℕ
p q : ℕ → Prop
n : ℕ
hn : n ≠ 0
⊢ 1 < 1 ^ n ↔ 1 < 1
state_after: no goals
tactic: simp
state_before: a✝ b c d m n✝ k : ℕ
p q : ℕ → Prop
n : ℕ
hn : n ≠ 0
a : ℕ
⊢ 1 < (a + 2) ^ n ↔ 1 < a + 2
state_after: no goals
tactic: simp [one_lt_pow hn]
Theorem: Real.sq_cos_pi_div_six
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

Proof steps:
state_before: x : ℝ
⊢ cos (π / 6) ^ 2 = 3 / 4
state_after: no goals
tactic: rw [cos_pi_div_six, div_pow, sq_sqrt] <;> norm_num
Theorem: Primrec.ite
File: Mathlib/Computability/Primrec.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
σ : Type u_5
inst✝⁵ : Primcodable α
inst✝⁴ : Primcodable β
inst✝³ : Primcodable γ
inst✝² : Primcodable δ
inst✝¹ : Primcodable σ
c : α → Prop
inst✝ : DecidablePred c
f g : α → σ
hc : PrimrecPred c
hf : Primrec f
hg : Primrec g
⊢ Primrec fun a => if c a then f a else g a
state_after: no goals
tactic: simpa [Bool.cond_decide] using cond hc hf hg
Theorem: CategoryTheory.CategoryOfElements.structuredArrowEquivalence_inverse_obj
File: Mathlib/CategoryTheory/Elements.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
F : C ⥤ Type w
X : F.Elements
⊢ (𝟭 F.Elements).obj X = (toStructuredArrow F ⋙ fromStructuredArrow F).obj X
state_after: no goals
tactic: aesop_cat
Theorem: Ordnode.Sized.rotateL
File: Mathlib/Data/Ordmap/Ordset.lean

Proof steps:
state_before: α : Type u_1
l : Ordnode α
x : α
r : Ordnode α
hl : l.Sized
hr : r.Sized
⊢ (l.rotateL x r).Sized
state_after: case nil
α : Type u_1
l : Ordnode α
x : α
hl : l.Sized
hr : nil.Sized
⊢ (l.rotateL x nil).Sized

case node
α : Type u_1
l : Ordnode α
x : α
hl : l.Sized
size✝ : ℕ
l✝ : Ordnode α
x✝ : α
r✝ : Ordnode α
hr : (node size✝ l✝ x✝ r✝).Sized
⊢ (l.rotateL x (node size✝ l✝ x✝ r✝)).Sized
tactic: cases r
state_before: case node
α : Type u_1
l : Ordnode α
x : α
hl : l.Sized
size✝ : ℕ
l✝ : Ordnode α
x✝ : α
r✝ : Ordnode α
hr : (node size✝ l✝ x✝ r✝).Sized
⊢ (l.rotateL x (node size✝ l✝ x✝ r✝)).Sized
state_after: case node
α : Type u_1
l : Ordnode α
x : α
hl : l.Sized
size✝ : ℕ
l✝ : Ordnode α
x✝ : α
r✝ : Ordnode α
hr : (node size✝ l✝ x✝ r✝).Sized
⊢ (if l✝.size < ratio * r✝.size then l.node3L x l✝ x✝ r✝ else l.node4L x l✝ x✝ r✝).Sized
tactic: rw [Ordnode.rotateL_node]
state_before: case node
α : Type u_1
l : Ordnode α
x : α
hl : l.Sized
size✝ : ℕ
l✝ : Ordnode α
x✝ : α
r✝ : Ordnode α
hr : (node size✝ l✝ x✝ r✝).Sized
⊢ (if l✝.size < ratio * r✝.size then l.node3L x l✝ x✝ r✝ else l.node4L x l✝ x✝ r✝).Sized
state_after: case pos
α : Type u_1
l : Ordnode α
x : α
hl : l.Sized
size✝ : ℕ
l✝ : Ordnode α
x✝ : α
r✝ : Ordnode α
hr : (node size✝ l✝ x✝ r✝).Sized
h✝ : l✝.size < ratio * r✝.size
⊢ (l.node3L x l✝ x✝ r✝).Sized

case neg
α : Type u_1
l : Ordnode α
x : α
hl : l.Sized
size✝ : ℕ
l✝ : Ordnode α
x✝ : α
r✝ : Ordnode α
hr : (node size✝ l✝ x✝ r✝).Sized
h✝ : ¬l✝.size < ratio * r✝.size
⊢ (l.node4L x l✝ x✝ r✝).Sized
tactic: split_ifs
Theorem: AffineSubspace.vadd_mem_iff_mem_direction
File: Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean

Proof steps:
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : AffineSubspace k P
v : V
p : P
hp : p ∈ s
h : v +ᵥ p ∈ s
⊢ v ∈ s.direction
state_after: no goals
tactic: simpa using vsub_mem_direction h hp
Theorem: interior_union_isClosed_of_interior_empty
File: Mathlib/Topology/Basic.lean

Proof steps:
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x✝¹ : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
h₁ : IsClosed s
h₂ : interior t = ∅
x : X
x✝ : x ∈ interior (s ∪ t)
u : Set X
hu₁ : IsOpen u
hu₂ : u ⊆ s ∪ t
hx₁ : x ∈ u
hx₂ : x ∉ s
this : u \ s ⊆ t
⊢ u \ s ⊆ interior t
state_after: no goals
tactic: rwa [(IsOpen.sdiff hu₁ h₁).subset_interior_iff]
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x✝¹ : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
h₁ : IsClosed s
h₂ : interior t = ∅
x : X
x✝ : x ∈ interior (s ∪ t)
u : Set X
hu₁ : IsOpen u
hu₂ : u ⊆ s ∪ t
hx₁ : x ∈ u
hx₂ : x ∉ s
this✝ : u \ s ⊆ t
this : u \ s ⊆ interior t
⊢ u \ s ⊆ ∅
state_after: no goals
tactic: rwa [h₂] at this
Theorem: FreeAbelianGroup.support_zero
File: Mathlib/GroupTheory/FreeAbelianGroupFinsupp.lean

Proof steps:
state_before: X : Type u_1
⊢ support 0 = ∅
state_after: no goals
tactic: simp only [support, Finsupp.support_zero, AddMonoidHom.map_zero]
Theorem: affineCombination_mem_affineSpan_pair
File: Mathlib/LinearAlgebra/AffineSpace/Independent.lean

Proof steps:
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
s✝ : Finset ι
w✝ w₁✝ w₂✝ : ι → k
p✝ : ι → V
p : ι → P
h : AffineIndependent k p
w w₁ w₂ : ι → k
s : Finset ι
x✝ : ∑ i ∈ s, w i = 1
hw₁ : ∑ i ∈ s, w₁ i = 1
hw₂ : ∑ i ∈ s, w₂ i = 1
⊢ (affineCombination k s p) w ∈ affineSpan k {(affineCombination k s p) w₁, (affineCombination k s p) w₂} ↔
    ∃ r, ∀ i ∈ s, w i = r * (w₂ i - w₁ i) + w₁ i
state_after: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
s✝ : Finset ι
w✝ w₁✝ w₂✝ : ι → k
p✝ : ι → V
p : ι → P
h : AffineIndependent k p
w w₁ w₂ : ι → k
s : Finset ι
x✝ : ∑ i ∈ s, w i = 1
hw₁ : ∑ i ∈ s, w₁ i = 1
hw₂ : ∑ i ∈ s, w₂ i = 1
⊢ (∃ r, ∀ i ∈ s, (w - w₁) i = r * (w₂ i - w₁ i)) ↔ ∃ r, ∀ i ∈ s, w i = r * (w₂ i - w₁ i) + w₁ i

k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
s✝ : Finset ι
w✝ w₁✝ w₂✝ : ι → k
p✝ : ι → V
p : ι → P
h : AffineIndependent k p
w w₁ w₂ : ι → k
s : Finset ι
x✝ : ∑ i ∈ s, w i = 1
hw₁ : ∑ i ∈ s, w₁ i = 1
hw₂ : ∑ i ∈ s, w₂ i = 1
⊢ ∑ i ∈ s, (w - w₁) i = 0
tactic: rw [← vsub_vadd (s.affineCombination k p w) (s.affineCombination k p w₁),
    AffineSubspace.vadd_mem_iff_mem_direction _ (left_mem_affineSpan_pair _ _ _),
    direction_affineSpan, s.affineCombination_vsub, Set.pair_comm,
    weightedVSub_mem_vectorSpan_pair h _ hw₂ hw₁]
Theorem: TopologicalSpace.Closeds.complOrderIso_apply
File: Mathlib/Topology/Sets/Closeds.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s : Closeds α
⊢ (Opens.compl ∘ ⇑ofDual) ((⇑toDual ∘ compl) s) = s
state_after: no goals
tactic: simp [Closeds.compl_compl]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s : (Opens α)ᵒᵈ
⊢ (⇑toDual ∘ compl) ((Opens.compl ∘ ⇑ofDual) s) = s
state_after: no goals
tactic: simp [Opens.compl_compl]
Theorem: Finsupp.antidiagonal_single
File: Mathlib/Data/Finsupp/Antidiagonal.lean

Proof steps:
state_before: α : Type u
inst✝ : DecidableEq α
a : α
n : ℕ
⊢ antidiagonal (single a n) =
    map ({ toFun := single a, inj' := ⋯ }.prodMap { toFun := single a, inj' := ⋯ }) (antidiagonal n)
state_after: case a.mk
α : Type u
inst✝ : DecidableEq α
a : α
n : ℕ
x y : α →₀ ℕ
⊢ (x, y) ∈ antidiagonal (single a n) ↔
    (x, y) ∈ map ({ toFun := single a, inj' := ⋯ }.prodMap { toFun := single a, inj' := ⋯ }) (antidiagonal n)
tactic: ext ⟨x, y⟩
state_before: case a.mk
α : Type u
inst✝ : DecidableEq α
a : α
n : ℕ
x y : α →₀ ℕ
⊢ (x, y) ∈ antidiagonal (single a n) ↔
    (x, y) ∈ map ({ toFun := single a, inj' := ⋯ }.prodMap { toFun := single a, inj' := ⋯ }) (antidiagonal n)
state_after: case a.mk
α : Type u
inst✝ : DecidableEq α
a : α
n : ℕ
x y : α →₀ ℕ
⊢ x + y = single a n ↔ ∃ a_1 b, a_1 + b = n ∧ single a a_1 = x ∧ single a b = y
tactic: simp only [mem_antidiagonal, mem_map, mem_antidiagonal, Function.Embedding.coe_prodMap,
    Function.Embedding.coeFn_mk, Prod.map_apply, Prod.mk.injEq, Prod.exists]
state_before: case a.mk
α : Type u
inst✝ : DecidableEq α
a : α
n : ℕ
x y : α →₀ ℕ
⊢ x + y = single a n ↔ ∃ a_1 b, a_1 + b = n ∧ single a a_1 = x ∧ single a b = y
state_after: case a.mk.mp
α : Type u
inst✝ : DecidableEq α
a : α
n : ℕ
x y : α →₀ ℕ
⊢ x + y = single a n → ∃ a_2 b, a_2 + b = n ∧ single a a_2 = x ∧ single a b = y

case a.mk.mpr
α : Type u
inst✝ : DecidableEq α
a : α
n : ℕ
x y : α →₀ ℕ
⊢ (∃ a_1 b, a_1 + b = n ∧ single a a_1 = x ∧ single a b = y) → x + y = single a n
tactic: constructor
Theorem: Mathlib.Vector.map_eq_mapAccumr
File: Mathlib/Data/Vector/MapLemmas.lean

Proof steps:
state_before: α : Type u_2
n : ℕ
β : Type ?u.28475
xs : Vector α n
ys : Vector β n
α✝ : Type u_1
f : α → α✝
⊢ map f xs = (mapAccumr (fun x x_1 => ((), f x)) xs ()).2
state_after: α : Type u_2
n : ℕ
β : Type ?u.28475
xs : Vector α n
α✝ : Type u_1
f : α → α✝
⊢ map f xs = (mapAccumr (fun x x_1 => ((), f x)) xs ()).2
tactic: clear ys
state_before: α : Type u_2
n : ℕ
β : Type ?u.28475
xs : Vector α n
α✝ : Type u_1
f : α → α✝
⊢ map f xs = (mapAccumr (fun x x_1 => ((), f x)) xs ()).2
state_after: no goals
tactic: induction xs using Vector.revInductionOn <;> simp_all
Theorem: EuclideanGeometry.Sphere.mk_center_radius
File: Mathlib/Geometry/Euclidean/Sphere/Basic.lean

Proof steps:
state_before: V : Type u_1
P : Type u_2
inst✝ : MetricSpace P
s : Sphere P
⊢ { center := s.center, radius := s.radius } = s
state_after: no goals
tactic: ext <;> rfl
Theorem: MeasureTheory.Measure.ae_smul_measure_eq
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
c : ℝ≥0∞
hc : c ≠ 0
⊢ ae (c • μ) = ae μ
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
c : ℝ≥0∞
hc : c ≠ 0
s✝ : Set α
⊢ s✝ ∈ ae (c • μ) ↔ s✝ ∈ ae μ
tactic: ext
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
c : ℝ≥0∞
hc : c ≠ 0
s✝ : Set α
⊢ s✝ ∈ ae (c • μ) ↔ s✝ ∈ ae μ
state_after: no goals
tactic: exact ae_smul_measure_iff hc
Theorem: Functor.Comp.applicative_comp_id
File: Mathlib/Control/Applicative.lean

Proof steps:
state_before: F✝ : Type u → Type w
G : Type v → Type u
inst✝⁴ : Applicative F✝
inst✝³ : Applicative G
inst✝² : LawfulApplicative F✝
inst✝¹ : LawfulApplicative G
α β γ : Type v
F : Type u_1 → Type u_2
AF : Applicative F
inst✝ : LawfulApplicative F
α✝ β✝ : Type u_1
f : F (α✝ → β✝)
x : F α✝
⊢ (Seq.seq (id <$> f) fun x_1 => x) = Seq.seq f fun x_1 => x
state_after: no goals
tactic: rw [id_map]