ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Set.chainHeight_image
File: Mathlib/Order/Height.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LT α
inst✝ : LT β
s✝ t : Set α
l : List α
a : α
f : α → β
hf : ∀ {x y : α}, x < y ↔ f x < f y
s : Set α
⊢ (f '' s).chainHeight = s.chainHeight
state_after: case a
α : Type u_1
β : Type u_2
inst✝¹ : LT α
inst✝ : LT β
s✝ t : Set α
l : List α
a : α
f : α → β
hf : ∀ {x y : α}, x < y ↔ f x < f y
s : Set α
⊢ ∀ l ∈ (f '' s).subchain, ∃ l' ∈ s.subchain, l.length = l'.length

case a
α : Type u_1
β : Type u_2
inst✝¹ : LT α
inst✝ : LT β
s✝ t : Set α
l : List α
a : α
f : α → β
hf : ∀ {x y : α}, x < y ↔ f x < f y
s : Set α
⊢ ∀ l ∈ s.subchain, ∃ l' ∈ (f '' s).subchain, l.length = l'.length
tactic: apply le_antisymm <;> rw [chainHeight_le_chainHeight_iff]
Theorem: ZMod.stdAddChar_coe
File: Mathlib/Analysis/SpecialFunctions/Complex/Circle.lean

Proof steps:
state_before: N : ℕ
inst✝ : NeZero N
j : ℤ
⊢ stdAddChar ↑j = cexp (2 * ↑π * I * ↑j / ↑N)
state_after: no goals
tactic: simp only [stdAddChar, MonoidHom.coe_compAddChar, Function.comp_apply,
    Submonoid.coe_subtype, toCircle_intCast]
Theorem: IsAdjoinRootMonic.coeff_root_pow
File: Mathlib/RingTheory/IsAdjoinRoot.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
n : ℕ
hn : n < f.natDegree
⊢ h.coeff (h.root ^ n) = Pi.single n 1
state_after: case h
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
n : ℕ
hn : n < f.natDegree
i : ℕ
⊢ h.coeff (h.root ^ n) i = Pi.single n 1 i
tactic: ext i
state_before: case h
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
n : ℕ
hn : n < f.natDegree
i : ℕ
⊢ h.coeff (h.root ^ n) i = Pi.single n 1 i
state_after: case h
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
n : ℕ
hn : n < f.natDegree
i : ℕ
⊢ (if hi : i < f.natDegree then (h.basis.repr (h.root ^ n)) ⟨i, hi⟩ else 0) = Pi.single n 1 i
tactic: rw [coeff_apply]
state_before: case h
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
n : ℕ
hn : n < f.natDegree
i : ℕ
⊢ (if hi : i < f.natDegree then (h.basis.repr (h.root ^ n)) ⟨i, hi⟩ else 0) = Pi.single n 1 i
state_after: case pos
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
n : ℕ
hn : n < f.natDegree
i : ℕ
hi : i < f.natDegree
⊢ (h.basis.repr (h.root ^ n)) ⟨i, hi⟩ = Pi.single n 1 i

case neg
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
n : ℕ
hn : n < f.natDegree
i : ℕ
hi : ¬i < f.natDegree
⊢ 0 = Pi.single n 1 i
tactic: split_ifs with hi
Theorem: NumberField.InfinitePlace.isUnramified_iff
File: Mathlib/NumberTheory/NumberField/Embeddings.lean

Proof steps:
state_before: k : Type u_1
inst✝⁷ : Field k
K : Type u_2
inst✝⁶ : Field K
F : Type u_3
inst✝⁵ : Field F
inst✝⁴ : NumberField K
inst✝³ : Algebra k K
inst✝² : Algebra k F
inst✝¹ : Algebra K F
inst✝ : IsScalarTower k K F
σ : K ≃ₐ[k] K
w : InfinitePlace K
⊢ IsUnramified k w ↔ w.IsReal ∨ (w.comap (algebraMap k K)).IsComplex
state_after: no goals
tactic: rw [← not_iff_not, not_isUnramified_iff, not_or,
    not_isReal_iff_isComplex, not_isComplex_iff_isReal]
Theorem: preNormEDS'_even
File: Mathlib/NumberTheory/EllipticDivisibilitySequence.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : ℤ → R
f : R →+* S
b c d : R
m : ℕ
⊢ preNormEDS' b c d (2 * (m + 3)) =
    preNormEDS' b c d (m + 2) ^ 2 * preNormEDS' b c d (m + 3) * preNormEDS' b c d (m + 5) -
      preNormEDS' b c d (m + 1) * preNormEDS' b c d (m + 3) * preNormEDS' b c d (m + 4) ^ 2
state_after: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : ℤ → R
f : R →+* S
b c d : R
m : ℕ
⊢ (let_fun h5 := ⋯;
    preNormEDS' b c d ((2 * m + 1) / 2 + 2) ^ 2 * preNormEDS' b c d ((2 * m + 1) / 2 + 3) *
        preNormEDS' b c d ((2 * m + 1) / 2 + 5) -
      preNormEDS' b c d ((2 * m + 1) / 2 + 1) * preNormEDS' b c d ((2 * m + 1) / 2 + 3) *
        preNormEDS' b c d ((2 * m + 1) / 2 + 4) ^ 2) =
    preNormEDS' b c d (m + 2) ^ 2 * preNormEDS' b c d (m + 3) * preNormEDS' b c d (m + 5) -
      preNormEDS' b c d (m + 1) * preNormEDS' b c d (m + 3) * preNormEDS' b c d (m + 4) ^ 2
tactic: rw [show 2 * (m + 3) = 2 * m + 1 + 5 by rfl, preNormEDS', dif_neg m.not_even_two_mul_add_one]
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : ℤ → R
f : R →+* S
b c d : R
m : ℕ
⊢ (let_fun h5 := ⋯;
    preNormEDS' b c d ((2 * m + 1) / 2 + 2) ^ 2 * preNormEDS' b c d ((2 * m + 1) / 2 + 3) *
        preNormEDS' b c d ((2 * m + 1) / 2 + 5) -
      preNormEDS' b c d ((2 * m + 1) / 2 + 1) * preNormEDS' b c d ((2 * m + 1) / 2 + 3) *
        preNormEDS' b c d ((2 * m + 1) / 2 + 4) ^ 2) =
    preNormEDS' b c d (m + 2) ^ 2 * preNormEDS' b c d (m + 3) * preNormEDS' b c d (m + 5) -
      preNormEDS' b c d (m + 1) * preNormEDS' b c d (m + 3) * preNormEDS' b c d (m + 4) ^ 2
state_after: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : ℤ → R
f : R →+* S
b c d : R
m : ℕ
⊢ preNormEDS' b c d (m + 1 / 2 + 2) ^ 2 * preNormEDS' b c d (m + 1 / 2 + 3) * preNormEDS' b c d (m + 1 / 2 + 5) -
      preNormEDS' b c d (m + 1 / 2 + 1) * preNormEDS' b c d (m + 1 / 2 + 3) * preNormEDS' b c d (m + 1 / 2 + 4) ^ 2 =
    preNormEDS' b c d (m + 2) ^ 2 * preNormEDS' b c d (m + 3) * preNormEDS' b c d (m + 5) -
      preNormEDS' b c d (m + 1) * preNormEDS' b c d (m + 3) * preNormEDS' b c d (m + 4) ^ 2
tactic: simp only [Nat.mul_add_div two_pos]
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : ℤ → R
f : R →+* S
b c d : R
m : ℕ
⊢ preNormEDS' b c d (m + 1 / 2 + 2) ^ 2 * preNormEDS' b c d (m + 1 / 2 + 3) * preNormEDS' b c d (m + 1 / 2 + 5) -
      preNormEDS' b c d (m + 1 / 2 + 1) * preNormEDS' b c d (m + 1 / 2 + 3) * preNormEDS' b c d (m + 1 / 2 + 4) ^ 2 =
    preNormEDS' b c d (m + 2) ^ 2 * preNormEDS' b c d (m + 3) * preNormEDS' b c d (m + 5) -
      preNormEDS' b c d (m + 1) * preNormEDS' b c d (m + 3) * preNormEDS' b c d (m + 4) ^ 2
state_after: no goals
tactic: rfl
Theorem: Interval.coe_iInf
File: Mathlib/Order/Interval/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
κ : ι → Sort u_6
inst✝¹ : CompleteLattice α
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
f : ι → Interval α
⊢ ↑(⨅ i, f i) = ⋂ i, ↑(f i)
state_after: no goals
tactic: simp [iInf]
Theorem: IntermediateField.adjoin_finset_isCompactElement
File: Mathlib/FieldTheory/Adjoin.lean

Proof steps:
state_before: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S✝ : Set E
α : E
S : Finset E
⊢ IsCompactElement (adjoin F ↑S)
state_after: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S✝ : Set E
α : E
S : Finset E
⊢ IsCompactElement (⨆ x ∈ ↑S, F⟮x⟯)
tactic: rw [← biSup_adjoin_simple]
state_before: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S✝ : Set E
α : E
S : Finset E
⊢ IsCompactElement (⨆ x ∈ ↑S, F⟮x⟯)
state_after: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S✝ : Set E
α : E
S : Finset E
⊢ IsCompactElement (S.sup fun a => F⟮a⟯)
tactic: simp_rw [Finset.mem_coe, ← Finset.sup_eq_iSup]
state_before: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S✝ : Set E
α : E
S : Finset E
⊢ IsCompactElement (S.sup fun a => F⟮a⟯)
state_after: no goals
tactic: exact isCompactElement_finsetSup S fun x _ => adjoin_simple_isCompactElement x
Theorem: CategoryTheory.Limits.isoZeroOfEpiZero_hom
File: Mathlib/CategoryTheory/Limits/Shapes/ZeroMorphisms.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
X Y : C
h : Epi 0
⊢ 0 ≫ 0 ≫ 0 = 0 ≫ 𝟙 Y
state_after: no goals
tactic: simp
Theorem: FirstOrder.Language.Theory.IsComplete.models_not_iff
File: Mathlib/ModelTheory/Satisfiability.lean

Proof steps:
state_before: L : Language
T : L.Theory
α : Type w
n : ℕ
h : T.IsComplete
φ : L.Sentence
⊢ T ⊨ᵇ Formula.not φ ↔ ¬T ⊨ᵇ φ
state_after: case inl
L : Language
T : L.Theory
α : Type w
n : ℕ
h : T.IsComplete
φ : L.Sentence
hφ : T ⊨ᵇ φ
⊢ T ⊨ᵇ Formula.not φ ↔ ¬T ⊨ᵇ φ

case inr
L : Language
T : L.Theory
α : Type w
n : ℕ
h : T.IsComplete
φ : L.Sentence
hφn : T ⊨ᵇ Formula.not φ
⊢ T ⊨ᵇ Formula.not φ ↔ ¬T ⊨ᵇ φ
tactic: cases' h.2 φ with hφ hφn
Theorem: Set.image_mono
File: Mathlib/Data/Set/Image.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f : α → β
s t : Set α
h : s ⊆ t
⊢ f '' s ⊆ f '' t
state_after: case intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f : α → β
s t : Set α
h : s ⊆ t
a : α
ha : a ∈ s
⊢ f a ∈ f '' t
tactic: rintro - ⟨a, ha, rfl⟩
state_before: case intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f : α → β
s t : Set α
h : s ⊆ t
a : α
ha : a ∈ s
⊢ f a ∈ f '' t
state_after: no goals
tactic: exact mem_image_of_mem f (h ha)
Theorem: Basis.toDual_eq_equivFun
File: Mathlib/LinearAlgebra/Dual.lean

Proof steps:
state_before: R : Type uR
M : Type uM
K : Type uK
V : Type uV
ι : Type uι
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : DecidableEq ι
b : Basis ι R M
inst✝ : _root_.Finite ι
m : M
i : ι
⊢ (b.toDual m) (b i) = b.equivFun m i
state_after: no goals
tactic: rw [b.equivFun_apply, toDual_eq_repr]
Theorem: Set.sigma_singleton
File: Mathlib/Data/Set/Sigma.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
β : ι → Type u_4
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
u : Set ((i : ι) × α i)
x : (i : ι) × α i
i j : ι
a✝ : α i
a : (i : ι) → α i
⊢ (s.sigma fun i => {a i}) = (fun i => ⟨i, a i⟩) '' s
state_after: case h.mk
ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
β : ι → Type u_4
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
u : Set ((i : ι) × α i)
x✝ : (i : ι) × α i
i j : ι
a✝ : α i
a : (i : ι) → α i
x : ι
y : α x
⊢ (⟨x, y⟩ ∈ s.sigma fun i => {a i}) ↔ ⟨x, y⟩ ∈ (fun i => ⟨i, a i⟩) '' s
tactic: ext ⟨x, y⟩
state_before: case h.mk
ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
β : ι → Type u_4
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
u : Set ((i : ι) × α i)
x✝ : (i : ι) × α i
i j : ι
a✝ : α i
a : (i : ι) → α i
x : ι
y : α x
⊢ (⟨x, y⟩ ∈ s.sigma fun i => {a i}) ↔ ⟨x, y⟩ ∈ (fun i => ⟨i, a i⟩) '' s
state_after: no goals
tactic: simp [and_left_comm, eq_comm]
Theorem: StrictConvex.eq_of_openSegment_subset_frontier
File: Mathlib/Analysis/Convex/Strict.lean

Proof steps:
state_before: 𝕜 : Type u_1
𝕝 : Type u_2
E : Type u_3
F : Type u_4
β : Type u_5
inst✝⁸ : OrderedRing 𝕜
inst✝⁷ : TopologicalSpace E
inst✝⁶ : TopologicalSpace F
inst✝⁵ : AddCommGroup E
inst✝⁴ : AddCommGroup F
inst✝³ : Module 𝕜 E
inst✝² : Module 𝕜 F
s t : Set E
x y : E
inst✝¹ : Nontrivial 𝕜
inst✝ : DenselyOrdered 𝕜
hs : StrictConvex 𝕜 s
hx : x ∈ s
hy : y ∈ s
h : openSegment 𝕜 x y ⊆ frontier s
⊢ x = y
state_after: case intro.intro
𝕜 : Type u_1
𝕝 : Type u_2
E : Type u_3
F : Type u_4
β : Type u_5
inst✝⁸ : OrderedRing 𝕜
inst✝⁷ : TopologicalSpace E
inst✝⁶ : TopologicalSpace F
inst✝⁵ : AddCommGroup E
inst✝⁴ : AddCommGroup F
inst✝³ : Module 𝕜 E
inst✝² : Module 𝕜 F
s t : Set E
x y : E
inst✝¹ : Nontrivial 𝕜
inst✝ : DenselyOrdered 𝕜
hs : StrictConvex 𝕜 s
hx : x ∈ s
hy : y ∈ s
h : openSegment 𝕜 x y ⊆ frontier s
a : 𝕜
ha₀ : 0 < a
ha₁ : a < 1
⊢ x = y
tactic: obtain ⟨a, ha₀, ha₁⟩ := DenselyOrdered.dense (0 : 𝕜) 1 zero_lt_one
state_before: case intro.intro
𝕜 : Type u_1
𝕝 : Type u_2
E : Type u_3
F : Type u_4
β : Type u_5
inst✝⁸ : OrderedRing 𝕜
inst✝⁷ : TopologicalSpace E
inst✝⁶ : TopologicalSpace F
inst✝⁵ : AddCommGroup E
inst✝⁴ : AddCommGroup F
inst✝³ : Module 𝕜 E
inst✝² : Module 𝕜 F
s t : Set E
x y : E
inst✝¹ : Nontrivial 𝕜
inst✝ : DenselyOrdered 𝕜
hs : StrictConvex 𝕜 s
hx : x ∈ s
hy : y ∈ s
h : openSegment 𝕜 x y ⊆ frontier s
a : 𝕜
ha₀ : 0 < a
ha₁ : a < 1
⊢ x = y
state_after: no goals
tactic: classical
    by_contra hxy
    exact
      (h ⟨a, 1 - a, ha₀, sub_pos_of_lt ha₁, add_sub_cancel _ _, rfl⟩).2
        (hs hx hy hxy ha₀ (sub_pos_of_lt ha₁) <| add_sub_cancel _ _)
Theorem: continuousOn_iff_continuous_restrict
File: Mathlib/Topology/ContinuousOn.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁴ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝³ : (i : ι) → TopologicalSpace (π i)
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
s : Set α
⊢ ContinuousOn f s ↔ Continuous (s.restrict f)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁴ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝³ : (i : ι) → TopologicalSpace (π i)
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
s : Set α
⊢ (∀ x ∈ s, ContinuousWithinAt f s x) ↔ ∀ (x : ↑s), ContinuousAt (s.restrict f) x
tactic: rw [ContinuousOn, continuous_iff_continuousAt]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁴ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝³ : (i : ι) → TopologicalSpace (π i)
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
s : Set α
⊢ (∀ x ∈ s, ContinuousWithinAt f s x) ↔ ∀ (x : ↑s), ContinuousAt (s.restrict f) x
state_after: case mp
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁴ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝³ : (i : ι) → TopologicalSpace (π i)
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
s : Set α
⊢ (∀ x ∈ s, ContinuousWithinAt f s x) → ∀ (x : ↑s), ContinuousAt (s.restrict f) x

case mpr
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁴ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝³ : (i : ι) → TopologicalSpace (π i)
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
s : Set α
⊢ (∀ (x : ↑s), ContinuousAt (s.restrict f) x) → ∀ x ∈ s, ContinuousWithinAt f s x
tactic: constructor
state_before: case mpr
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁴ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝³ : (i : ι) → TopologicalSpace (π i)
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
s : Set α
⊢ (∀ (x : ↑s), ContinuousAt (s.restrict f) x) → ∀ x ∈ s, ContinuousWithinAt f s x
state_after: case mpr
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁴ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝³ : (i : ι) → TopologicalSpace (π i)
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
s : Set α
h : ∀ (x : ↑s), ContinuousAt (s.restrict f) x
x : α
xs : x ∈ s
⊢ ContinuousWithinAt f s x
tactic: intro h x xs
state_before: case mpr
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁴ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝³ : (i : ι) → TopologicalSpace (π i)
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
s : Set α
h : ∀ (x : ↑s), ContinuousAt (s.restrict f) x
x : α
xs : x ∈ s
⊢ ContinuousWithinAt f s x
state_after: no goals
tactic: exact (continuousWithinAt_iff_continuousAt_restrict f xs).mpr (h ⟨x, xs⟩)
Theorem: SetTheory.PGame.Domineering.fst_pred_mem_erase_of_mem_right
File: Mathlib/SetTheory/Game/Domineering.lean

Proof steps:
state_before: b : Board
m : ℤ × ℤ
h : m ∈ right b
⊢ (m.1 - 1, m.2) ∈ Finset.erase b m
state_after: b : Board
m : ℤ × ℤ
h : m ∈ b ∧ (m.1 - 1, m.2) ∈ b
⊢ (m.1 - 1, m.2) ∈ Finset.erase b m
tactic: rw [mem_right] at h
state_before: b : Board
m : ℤ × ℤ
h : m ∈ b ∧ (m.1 - 1, m.2) ∈ b
⊢ (m.1 - 1, m.2) ∈ Finset.erase b m
state_after: b : Board
m : ℤ × ℤ
h : m ∈ b ∧ (m.1 - 1, m.2) ∈ b
⊢ (m.1 - 1, m.2) ≠ m
tactic: apply Finset.mem_erase_of_ne_of_mem _ h.2
state_before: b : Board
m : ℤ × ℤ
h : m ∈ b ∧ (m.1 - 1, m.2) ∈ b
⊢ (m.1 - 1, m.2) ≠ m
state_after: no goals
tactic: exact ne_of_apply_ne Prod.fst (pred_ne_self m.1)
Theorem: finsuppTensorFinsuppLid_apply_apply
File: Mathlib/LinearAlgebra/DirectSum/Finsupp.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
M : Type u_3
N : Type u_4
ι : Type u_5
κ : Type u_6
inst✝⁸ : CommSemiring R
inst✝⁷ : AddCommMonoid M
inst✝⁶ : Module R M
inst✝⁵ : AddCommMonoid N
inst✝⁴ : Module R N
inst✝³ : Semiring S
inst✝² : Algebra R S
inst✝¹ : Module S M
inst✝ : IsScalarTower R S M
f : ι →₀ R
g : κ →₀ N
a : ι
b : κ
⊢ ((finsuppTensorFinsuppLid R N ι κ) (f ⊗ₜ[R] g)) (a, b) = f a • g b
state_after: no goals
tactic: simp [finsuppTensorFinsuppLid]
Theorem: Finset.exists_lt_sum_fiber_of_sum_fiber_nonpos_of_nsmul_lt_sum
File: Mathlib/Combinatorics/Pigeonhole.lean

Proof steps:
state_before: α : Type u
β : Type v
M : Type w
inst✝¹ : DecidableEq β
s : Finset α
t : Finset β
f : α → β
w : α → M
b : M
n : ℕ
inst✝ : LinearOrderedCancelAddCommMonoid M
ht : ∀ y ∉ t, ∑ x ∈ filter (fun x => f x = y) s, w x ≤ 0
hb : t.card • b < ∑ x ∈ s, w x
⊢ ∑ _y ∈ t, b < ∑ x ∈ s, w x
state_after: no goals
tactic: simpa
Theorem: inf_left_idem
File: Mathlib/Order/Lattice.lean

Proof steps:
state_before: α : Type u
β : Type v
inst✝ : SemilatticeInf α
a✝ b✝ c d a b : α
⊢ a ⊓ (a ⊓ b) = a ⊓ b
state_after: no goals
tactic: simp
Theorem: AkraBazziRecurrence.isEquivalent_smoothingFn_sub_self
File: Mathlib/Computability/AkraBazzi/AkraBazzi.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
i : α
⊢ (fun n => ε (b i * ↑n) - ε ↑n) ~[atTop] fun n => -log (b i) / log ↑n ^ 2
state_after: no goals
tactic: calc (fun (n : ℕ) => 1 / log (b i * n) - 1 / log n)
        =ᶠ[atTop] fun (n : ℕ) => (log n - log (b i * n)) / (log (b i * n) * log n) := by
            filter_upwards [eventually_gt_atTop 1, R.eventually_log_b_mul_pos] with n hn hn'
            have h_log_pos : 0 < log n := Real.log_pos <| by aesop
            simp only [one_div]
            rw [inv_sub_inv (by have := hn' i; positivity) (by aesop)]
      _ =ᶠ[atTop] (fun (n : ℕ) ↦ (log n - log (b i) - log n) / ((log (b i) + log n) * log n)) := by
            filter_upwards [eventually_ne_atTop 0] with n hn
            have : 0 < b i := R.b_pos i
            rw [log_mul (by positivity) (by aesop), sub_add_eq_sub_sub]
      _ = (fun (n : ℕ) => -log (b i) / ((log (b i) + log n) * log n)) := by ext; congr; ring
      _ ~[atTop] (fun (n : ℕ) => -log (b i) / (log n * log n)) := by
            refine IsEquivalent.div (IsEquivalent.refl) <| IsEquivalent.mul ?_ (IsEquivalent.refl)
            have : (fun (n : ℕ) => log (b i) + log n) = fun (n : ℕ) => log n + log (b i) := by
              ext; simp [add_comm]
            rw [this]
            exact IsEquivalent.add_isLittleO IsEquivalent.refl
              <| IsLittleO.natCast_atTop (f := fun (_ : ℝ) => log (b i))
                isLittleO_const_log_atTop
      _ = (fun (n : ℕ) => -log (b i) / (log n)^2) := by ext; congr 1; rw [← pow_two]
Theorem: TopCat.Presheaf.pushforward_eq'
File: Mathlib/Topology/Sheaves/Presheaf.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : TopCat
f g : X ⟶ Y
h : f = g
ℱ : Presheaf C X
⊢ (pushforward C f).obj ℱ = (pushforward C g).obj ℱ
state_after: no goals
tactic: rw [h]
Theorem: EuclideanGeometry.oangle_swap₂₃_sign
File: Mathlib/Geometry/Euclidean/Angle/Oriented/Affine.lean

Proof steps:
state_before: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
p₁ p₂ p₃ : P
⊢ -(∡ p₁ p₂ p₃).sign = (∡ p₁ p₃ p₂).sign
state_after: no goals
tactic: rw [oangle_swap₁₃_sign, ← oangle_swap₁₂_sign, oangle_swap₁₃_sign]
Theorem: Function.IsPeriodicPt.add
File: Mathlib/Dynamics/PeriodicPts.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
f fa : α → α
fb : β → β
x y : α
m n : ℕ
hn : IsPeriodicPt f n x
hm : IsPeriodicPt f m x
⊢ IsPeriodicPt f (n + m) x
state_after: α : Type u_1
β : Type u_2
f fa : α → α
fb : β → β
x y : α
m n : ℕ
hn : IsPeriodicPt f n x
hm : IsPeriodicPt f m x
⊢ IsFixedPt (f^[n] ∘ f^[m]) x
tactic: rw [IsPeriodicPt, iterate_add]
state_before: α : Type u_1
β : Type u_2
f fa : α → α
fb : β → β
x y : α
m n : ℕ
hn : IsPeriodicPt f n x
hm : IsPeriodicPt f m x
⊢ IsFixedPt (f^[n] ∘ f^[m]) x
state_after: no goals
tactic: exact hn.comp hm
Theorem: Finset.card_eq_iff_eq_univ
File: Mathlib/Data/Fintype/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : Fintype α
s : Finset α
⊢ s = univ → s.card = Fintype.card α
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : Fintype α
⊢ univ.card = Fintype.card α
tactic: rintro rfl
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : Fintype α
⊢ univ.card = Fintype.card α
state_after: no goals
tactic: exact Finset.card_univ
Theorem: AList.keys_subset_keys_of_entries_subset_entries
File: Mathlib/Data/List/AList.lean

Proof steps:
state_before: α : Type u
β : α → Type v
s₁ s₂ : AList β
h : s₁.entries ⊆ s₂.entries
⊢ s₁.keys ⊆ s₂.keys
state_after: α : Type u
β : α → Type v
s₁ s₂ : AList β
h : s₁.entries ⊆ s₂.entries
k : α
hk : k ∈ s₁.keys
⊢ k ∈ s₂.keys
tactic: intro k hk
state_before: α : Type u
β : α → Type v
s₁ s₂ : AList β
h : s₁.entries ⊆ s₂.entries
k : α
hk : k ∈ s₁.keys
⊢ k ∈ s₂.keys
state_after: α : Type u
β : α → Type v
s₁ s₂ : AList β
h : s₁.entries ⊆ s₂.entries
k : α
hk : k ∈ s₁.keys
this : DecidableEq α := Classical.decEq α
⊢ k ∈ s₂.keys
tactic: letI : DecidableEq α := Classical.decEq α
state_before: α : Type u
β : α → Type v
s₁ s₂ : AList β
h : s₁.entries ⊆ s₂.entries
k : α
hk : k ∈ s₁.keys
this : DecidableEq α := Classical.decEq α
⊢ k ∈ s₂.keys
state_after: α : Type u
β : α → Type v
s₁ s₂ : AList β
h : s₁.entries ⊆ s₂.entries
k : α
hk : k ∈ s₁.keys
this✝ : DecidableEq α := Classical.decEq α
this : ⟨k, (lookup k s₁).get ⋯⟩ ∈ s₂.entries
⊢ k ∈ s₂.keys
tactic: have := h (mem_lookup_iff.1 (Option.get_mem (lookup_isSome.2 hk)))
state_before: α : Type u
β : α → Type v
s₁ s₂ : AList β
h : s₁.entries ⊆ s₂.entries
k : α
hk : k ∈ s₁.keys
this✝ : DecidableEq α := Classical.decEq α
this : ⟨k, (lookup k s₁).get ⋯⟩ ∈ s₂.entries
⊢ k ∈ s₂.keys
state_after: α : Type u
β : α → Type v
s₁ s₂ : AList β
h : s₁.entries ⊆ s₂.entries
k : α
hk : k ∈ s₁.keys
this✝ : DecidableEq α := Classical.decEq α
this : lookup k s₂ = some ((lookup k s₁).get ⋯)
⊢ k ∈ s₂.keys
tactic: rw [← mem_lookup_iff, Option.mem_def] at this
state_before: α : Type u
β : α → Type v
s₁ s₂ : AList β
h : s₁.entries ⊆ s₂.entries
k : α
hk : k ∈ s₁.keys
this✝ : DecidableEq α := Classical.decEq α
this : lookup k s₂ = some ((lookup k s₁).get ⋯)
⊢ k ∈ s₂.keys
state_after: α : Type u
β : α → Type v
s₁ s₂ : AList β
h : s₁.entries ⊆ s₂.entries
k : α
hk : k ∈ s₁.keys
this✝ : DecidableEq α := Classical.decEq α
this : lookup k s₂ = some ((lookup k s₁).get ⋯)
⊢ (some ((lookup k s₁).get ⋯)).isSome = true
tactic: rw [← mem_keys, ← lookup_isSome, this]
state_before: α : Type u
β : α → Type v
s₁ s₂ : AList β
h : s₁.entries ⊆ s₂.entries
k : α
hk : k ∈ s₁.keys
this✝ : DecidableEq α := Classical.decEq α
this : lookup k s₂ = some ((lookup k s₁).get ⋯)
⊢ (some ((lookup k s₁).get ⋯)).isSome = true
state_after: no goals
tactic: exact Option.isSome_some
Theorem: dite_dite_distrib_left
File: Mathlib/Logic/Lemmas.lean

Proof steps:
state_before: α : Sort u_1
p q r : Prop
inst✝¹ : Decidable p
inst✝ : Decidable q
a✝ b✝ c✝ : α
a : p → α
b : ¬p → q → α
c : ¬p → ¬q → α
⊢ (dite p a fun hp => dite q (b hp) (c hp)) = if hq : q then dite p a fun hp => b hp hq else dite p a fun hp => c hp hq
state_after: no goals
tactic: split_ifs <;> rfl
Theorem: integral_one_div
File: Mathlib/Analysis/SpecialFunctions/Integrals.lean

Proof steps:
state_before: a b : ℝ
n : ℕ
h : 0 ∉ [[a, b]]
⊢ ∫ (x : ℝ) in a..b, 1 / x = Real.log (b / a)
state_after: no goals
tactic: simp only [one_div, integral_inv h]