ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: PiNat.res_eq_res
File: Mathlib/Topology/MetricSpace/PiNat.lean

Proof steps:
state_before: E : ℕ → Type u_1
α : Type u_2
x y : ℕ → α
n : ℕ
⊢ res x n = res y n ↔ ∀ ⦃m : ℕ⦄, m < n → x m = y m
state_after: case mp.zero
E : ℕ → Type u_1
α : Type u_2
x y : ℕ → α
h : res x 0 = res y 0
⊢ ∀ ⦃m : ℕ⦄, m < 0 → x m = y m

case mp.succ
E : ℕ → Type u_1
α : Type u_2
x y : ℕ → α
n : ℕ
ih : res x n = res y n → ∀ ⦃m : ℕ⦄, m < n → x m = y m
h : res x (n + 1) = res y (n + 1)
⊢ ∀ ⦃m : ℕ⦄, m < n + 1 → x m = y m

case mpr.zero
E : ℕ → Type u_1
α : Type u_2
x y : ℕ → α
h : ∀ ⦃m : ℕ⦄, m < 0 → x m = y m
⊢ res x 0 = res y 0

case mpr.succ
E : ℕ → Type u_1
α : Type u_2
x y : ℕ → α
n : ℕ
ih : (∀ ⦃m : ℕ⦄, m < n → x m = y m) → res x n = res y n
h : ∀ ⦃m : ℕ⦄, m < n + 1 → x m = y m
⊢ res x (n + 1) = res y (n + 1)
tactic: constructor <;> intro h <;> induction' n with n ih
state_before: case mpr.succ
E : ℕ → Type u_1
α : Type u_2
x y : ℕ → α
n : ℕ
ih : (∀ ⦃m : ℕ⦄, m < n → x m = y m) → res x n = res y n
h : ∀ ⦃m : ℕ⦄, m < n + 1 → x m = y m
⊢ res x (n + 1) = res y (n + 1)
state_after: case mpr.succ
E : ℕ → Type u_1
α : Type u_2
x y : ℕ → α
n : ℕ
ih : (∀ ⦃m : ℕ⦄, m < n → x m = y m) → res x n = res y n
h : ∀ ⦃m : ℕ⦄, m < n + 1 → x m = y m
⊢ x n = y n ∧ res x n = res y n
tactic: simp only [res_succ, cons.injEq]
state_before: case mpr.succ
E : ℕ → Type u_1
α : Type u_2
x y : ℕ → α
n : ℕ
ih : (∀ ⦃m : ℕ⦄, m < n → x m = y m) → res x n = res y n
h : ∀ ⦃m : ℕ⦄, m < n + 1 → x m = y m
⊢ x n = y n ∧ res x n = res y n
state_after: case mpr.succ
E : ℕ → Type u_1
α : Type u_2
x y : ℕ → α
n : ℕ
ih : (∀ ⦃m : ℕ⦄, m < n → x m = y m) → res x n = res y n
h : ∀ ⦃m : ℕ⦄, m < n + 1 → x m = y m
m : ℕ
hm : m < n
⊢ x m = y m
tactic: refine ⟨h (Nat.lt_succ_self _), ih fun m hm => ?_⟩
state_before: case mpr.succ
E : ℕ → Type u_1
α : Type u_2
x y : ℕ → α
n : ℕ
ih : (∀ ⦃m : ℕ⦄, m < n → x m = y m) → res x n = res y n
h : ∀ ⦃m : ℕ⦄, m < n + 1 → x m = y m
m : ℕ
hm : m < n
⊢ x m = y m
state_after: no goals
tactic: exact h (hm.trans (Nat.lt_succ_self _))
Theorem: FirstOrder.Language.LHom.id_comp
File: Mathlib/ModelTheory/LanguageMap.lean

Proof steps:
state_before: L : Language
L' : Language
M : Type w
inst✝ : L.Structure M
ϕ : L →ᴸ L'
L'' : Language
F : L →ᴸ L'
⊢ LHom.id L' ∘ᴸ F = F
state_after: case mk
L : Language
L' : Language
M : Type w
inst✝ : L.Structure M
ϕ : L →ᴸ L'
L'' : Language
onFunction✝ : ⦃n : ℕ⦄ → L.Functions n → L'.Functions n
onRelation✝ : ⦃n : ℕ⦄ → L.Relations n → L'.Relations n
⊢ LHom.id L' ∘ᴸ { onFunction := onFunction✝, onRelation := onRelation✝ } =
    { onFunction := onFunction✝, onRelation := onRelation✝ }
tactic: cases F
state_before: case mk
L : Language
L' : Language
M : Type w
inst✝ : L.Structure M
ϕ : L →ᴸ L'
L'' : Language
onFunction✝ : ⦃n : ℕ⦄ → L.Functions n → L'.Functions n
onRelation✝ : ⦃n : ℕ⦄ → L.Relations n → L'.Relations n
⊢ LHom.id L' ∘ᴸ { onFunction := onFunction✝, onRelation := onRelation✝ } =
    { onFunction := onFunction✝, onRelation := onRelation✝ }
state_after: no goals
tactic: rfl
Theorem: lub_Iio_eq_self_or_Iio_eq_Iic
File: Mathlib/Order/Bounds/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
s t : Set α
a b : α
inst✝ : PartialOrder γ
j i : γ
hj : IsLUB (Iio i) j
⊢ j = i ∨ Iio i = Iic j
state_after: case inl
α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
s t : Set α
a b : α
inst✝ : PartialOrder γ
j i : γ
hj : IsLUB (Iio i) j
hj_eq_i : j = i
⊢ j = i ∨ Iio i = Iic j

case inr
α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
s t : Set α
a b : α
inst✝ : PartialOrder γ
j i : γ
hj : IsLUB (Iio i) j
hj_lt_i : j < i
⊢ j = i ∨ Iio i = Iic j
tactic: cases' eq_or_lt_of_le (lub_Iio_le i hj) with hj_eq_i hj_lt_i
Theorem: IsOpenMap.id
File: Mathlib/Topology/Maps/Basic.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
ι : Type u_4
f : X → Y
g : Y → Z
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
s : Set X
hs : IsOpen s
⊢ IsOpen (id '' s)
state_after: no goals
tactic: rwa [image_id]
Theorem: Multiset.toFinset_eq_singleton_iff
File: Mathlib/Data/Finset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s✝ t s : Multiset α
a : α
⊢ s.toFinset = {a} ↔ card s ≠ 0 ∧ s = card s • {a}
state_after: case refine_1
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s✝ t s : Multiset α
a : α
H : s.toFinset = {a}
h : card s = 0
⊢ False

case refine_2
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s✝ t s : Multiset α
a : α
H : s.toFinset = {a}
x : α
⊢ count x s = count x (card s • {a})

case refine_3
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s✝ t s : Multiset α
a : α
H : card s ≠ 0 ∧ s = card s • {a}
⊢ s.toFinset = {a}
tactic: refine ⟨fun H ↦ ⟨fun h ↦ ?_, ext' fun x ↦ ?_⟩, fun H ↦ ?_⟩
state_before: case refine_3
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s✝ t s : Multiset α
a : α
H : card s ≠ 0 ∧ s = card s • {a}
⊢ s.toFinset = {a}
state_after: no goals
tactic: simpa only [toFinset_nsmul _ _ H.1, toFinset_singleton] using congr($(H.2).toFinset)
Theorem: Set.isUnit_iff
File: Mathlib/Data/Set/Pointwise/Basic.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : DivisionMonoid α
s t : Set α
⊢ IsUnit s ↔ ∃ a, s = {a} ∧ IsUnit a
state_after: case mp
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : DivisionMonoid α
s t : Set α
⊢ IsUnit s → ∃ a, s = {a} ∧ IsUnit a

case mpr
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : DivisionMonoid α
s t : Set α
⊢ (∃ a, s = {a} ∧ IsUnit a) → IsUnit s
tactic: constructor
Theorem: tendsto_div_nhds_one_iff
File: Mathlib/Topology/Algebra/Group/Basic.lean

Proof steps:
state_before: G : Type w
H : Type x
α✝ : Type u
β : Type v
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
α : Type u_1
l : Filter α
x : G
u : α → G
A : Tendsto (fun x_1 => x) l (𝓝 x)
h : Tendsto (fun x_1 => u x_1 / x) l (𝓝 1)
⊢ Tendsto u l (𝓝 x)
state_after: no goals
tactic: simpa using h.mul A
state_before: G : Type w
H : Type x
α✝ : Type u
β : Type v
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
α : Type u_1
l : Filter α
x : G
u : α → G
A : Tendsto (fun x_1 => x) l (𝓝 x)
h : Tendsto u l (𝓝 x)
⊢ Tendsto (fun x_1 => u x_1 / x) l (𝓝 1)
state_after: no goals
tactic: simpa using h.div' A
Theorem: FreeGroup.norm_mul_le
File: Mathlib/GroupTheory/FreeGroup/Basic.lean

Proof steps:
state_before: α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
inst✝ : DecidableEq α
x y : FreeGroup α
⊢ (x * y).norm = (mk (x.toWord ++ y.toWord)).norm
state_after: no goals
tactic: rw [← mul_mk, mk_toWord, mk_toWord]
Theorem: Finset.sum_insert_sub
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 β
M : Type u_6
inst✝¹ : CommGroup M
inst✝ : DecidableEq α
ha : a ∉ s
f : α → M
⊢ (∏ x ∈ insert a s, f x) / f a = ∏ x ∈ s, f x
state_after: no goals
tactic: simp [ha]
Theorem: Finset.mem_compls
File: Mathlib/Data/Finset/Sups.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝² : DecidableEq α
inst✝¹ : DecidableEq β
inst✝ : BooleanAlgebra α
s s₁ s₂ t t₁ t₂ u v : Finset α
a b c : α
⊢ a ∈ sᶜˢ ↔ aᶜ ∈ s
state_after: no goals
tactic: rw [Iff.comm, ← mem_map' ⟨compl, compl_injective⟩, Embedding.coeFn_mk, compl_compl, compls]
Theorem: CategoryTheory.toQuotientPaths_map
File: Mathlib/CategoryTheory/PathCategory.lean

Proof steps:
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
X : C
⊢ pathsHomRel C (𝟙 X).toPath
    (𝟙
      ({ obj := fun X => { as := X },
              map := fun {X Y} f => Quot.mk (Quotient.CompClosure (pathsHomRel C)) f.toPath }.obj
          X).as)
state_after: no goals
tactic: simp
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
X✝ Y✝ Z✝ : C
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
⊢ pathsHomRel C (f ≫ g).toPath (f.toPath ≫ g.toPath)
state_after: no goals
tactic: simp
Theorem: Set.Finite.lowerClosure
File: Mathlib/Order/UpperLower/LocallyFinite.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : Preorder α
s : Set α
inst✝ : LocallyFiniteOrderBot α
hs : s.Finite
⊢ (↑(lowerClosure s)).Finite
state_after: α : Type u_1
inst✝¹ : Preorder α
s : Set α
inst✝ : LocallyFiniteOrderBot α
hs : s.Finite
⊢ (⋃ a ∈ s, Iic a).Finite
tactic: rw [coe_lowerClosure]
state_before: α : Type u_1
inst✝¹ : Preorder α
s : Set α
inst✝ : LocallyFiniteOrderBot α
hs : s.Finite
⊢ (⋃ a ∈ s, Iic a).Finite
state_after: no goals
tactic: exact hs.biUnion fun _ _ => finite_Iic _
Theorem: padicNorm.zero
File: Mathlib/NumberTheory/Padics/PadicNorm.lean

Proof steps:
state_before: p : ℕ
⊢ padicNorm p 0 = 0
state_after: no goals
tactic: simp [padicNorm]
Theorem: Int.fract_div_mul_self_add_zsmul_eq
File: Mathlib/Algebra/Order/Floor.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝³ : LinearOrderedRing α
inst✝² : FloorRing α
z : ℤ
a✝ : α
k : Type u_4
inst✝¹ : LinearOrderedField k
inst✝ : FloorRing k
b✝ a b : k
ha : a ≠ 0
⊢ fract (b / a) * a + ⌊b / a⌋ • a = b
state_after: no goals
tactic: rw [zsmul_eq_mul, ← add_mul, fract_add_floor, div_mul_cancel₀ b ha]
Theorem: WeierstrassCurve.Jacobian.dblU_of_Z_eq_zero
File: Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean

Proof steps:
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : Fin 3 → R
hPz : P z = 0
⊢ W'.dblU P = -3 * P x ^ 2
state_after: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : Fin 3 → R
hPz : P z = 0
⊢ W'.a₁ * P y * 0 - (3 * P x ^ 2 + 2 * W'.a₂ * P x * 0 ^ 2 + W'.a₄ * 0 ^ 4) = -3 * P x ^ 2
tactic: rw [dblU_eq, hPz]
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : Fin 3 → R
hPz : P z = 0
⊢ W'.a₁ * P y * 0 - (3 * P x ^ 2 + 2 * W'.a₂ * P x * 0 ^ 2 + W'.a₄ * 0 ^ 4) = -3 * P x ^ 2
state_after: no goals
tactic: ring1
Theorem: Polynomial.isUnit_leadingCoeff_mul_left_eq_zero_iff
File: Mathlib/Algebra/Polynomial/Monic.lean

Proof steps:
state_before: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p : R[X]
h : IsUnit p.leadingCoeff
q : R[X]
⊢ q * p = 0 ↔ q = 0
state_after: case mp
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p : R[X]
h : IsUnit p.leadingCoeff
q : R[X]
⊢ q * p = 0 → q = 0

case mpr
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p : R[X]
h : IsUnit p.leadingCoeff
q : R[X]
⊢ q = 0 → q * p = 0
tactic: constructor
Theorem: TopologicalSpace.NoetherianSpace.iUnion
File: Mathlib/Topology/NoetherianSpace.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
ι : Type u_3
f : ι → Set α
inst✝ : Finite ι
hf : ∀ (i : ι), NoetherianSpace ↑(f i)
⊢ NoetherianSpace ↑(⋃ i, f i)
state_after: α : Type u_1
β : Type u_2
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
ι : Type u_3
f : ι → Set α
inst✝ : Finite ι
hf : ∀ (i : ι), ∀ t ⊆ f i, IsCompact t
⊢ ∀ t ⊆ ⋃ i, f i, IsCompact t
tactic: simp_rw [noetherianSpace_set_iff] at hf ⊢
state_before: α : Type u_1
β : Type u_2
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
ι : Type u_3
f : ι → Set α
inst✝ : Finite ι
hf : ∀ (i : ι), ∀ t ⊆ f i, IsCompact t
⊢ ∀ t ⊆ ⋃ i, f i, IsCompact t
state_after: α : Type u_1
β : Type u_2
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
ι : Type u_3
f : ι → Set α
inst✝ : Finite ι
hf : ∀ (i : ι), ∀ t ⊆ f i, IsCompact t
t : Set α
ht : t ⊆ ⋃ i, f i
⊢ IsCompact t
tactic: intro t ht
state_before: α : Type u_1
β : Type u_2
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
ι : Type u_3
f : ι → Set α
inst✝ : Finite ι
hf : ∀ (i : ι), ∀ t ⊆ f i, IsCompact t
t : Set α
ht : t ⊆ ⋃ i, f i
⊢ IsCompact t
state_after: α : Type u_1
β : Type u_2
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
ι : Type u_3
f : ι → Set α
inst✝ : Finite ι
hf : ∀ (i : ι), ∀ t ⊆ f i, IsCompact t
t : Set α
ht : t ⊆ ⋃ i, f i
⊢ IsCompact (⋃ i, t ∩ f i)
tactic: rw [← Set.inter_eq_left.mpr ht, Set.inter_iUnion]
state_before: α : Type u_1
β : Type u_2
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
ι : Type u_3
f : ι → Set α
inst✝ : Finite ι
hf : ∀ (i : ι), ∀ t ⊆ f i, IsCompact t
t : Set α
ht : t ⊆ ⋃ i, f i
⊢ IsCompact (⋃ i, t ∩ f i)
state_after: no goals
tactic: exact isCompact_iUnion fun i => hf i _ Set.inter_subset_right
Theorem: MultilinearMap.map_coord_zero
File: Mathlib/LinearAlgebra/Multilinear/Basic.lean

Proof steps:
state_before: R : Type uR
S : Type uS
ι : Type uι
n : ℕ
M : Fin n.succ → Type v
M₁ : ι → Type v₁
M₂ : Type v₂
M₃ : Type v₃
M' : Type v'
inst✝¹⁰ : Semiring R
inst✝⁹ : (i : Fin n.succ) → AddCommMonoid (M i)
inst✝⁸ : (i : ι) → AddCommMonoid (M₁ i)
inst✝⁷ : AddCommMonoid M₂
inst✝⁶ : AddCommMonoid M₃
inst✝⁵ : AddCommMonoid M'
inst✝⁴ : (i : Fin n.succ) → Module R (M i)
inst✝³ : (i : ι) → Module R (M₁ i)
inst✝² : Module R M₂
inst✝¹ : Module R M₃
inst✝ : Module R M'
f f' : MultilinearMap R M₁ M₂
m : (i : ι) → M₁ i
i : ι
h : m i = 0
⊢ f m = 0
state_after: no goals
tactic: classical
    have : (0 : R) • (0 : M₁ i) = 0 := by simp
    rw [← update_eq_self i m, h, ← this, f.map_smul, zero_smul R (M := M₂)]
Theorem: Submodule.toLocalized'_apply_coe
File: Mathlib/Algebra/Module/Submodule/Localization.lean

Proof steps:
state_before: R : Type u
S : Type u'
M : Type v
N : Type v'
inst✝¹⁰ : CommRing R
inst✝⁹ : CommRing S
inst✝⁸ : AddCommGroup M
inst✝⁷ : AddCommGroup N
inst✝⁶ : Module R M
inst✝⁵ : Module R N
inst✝⁴ : Algebra R S
inst✝³ : Module S N
inst✝² : IsScalarTower R S N
p : Submonoid R
inst✝¹ : IsLocalization p S
f : M →ₗ[R] N
inst✝ : IsLocalizedModule p f
hp : p ≤ R⁰
M' : Submodule R M
x : M
hx : x ∈ M'
⊢ IsLocalizedModule.mk' f x 1 = f x
state_after: no goals
tactic: simp
Theorem: CategoryTheory.GrothendieckTopology.top_covers
File: Mathlib/CategoryTheory/Sites/Grothendieck.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : C
S✝ R : Sieve X
J : GrothendieckTopology C
S : Sieve X
f : Y ⟶ X
⊢ ⊤.Covers S f
state_after: no goals
tactic: simp [covers_iff]
Theorem: orderBornology_isBounded
File: Mathlib/Topology/Order/Bornology.lean

Proof steps:
state_before: α : Type u_1
inst✝² : Bornology α
s t : Set α
inst✝¹ : Lattice α
inst✝ : Nonempty α
⊢ IsBounded s ↔ BddBelow s ∧ BddAbove s
state_after: no goals
tactic: simp [IsBounded, IsCobounded, -isCobounded_compl_iff]
Theorem: TrivSqZeroExt.nnnorm_def
File: Mathlib/Analysis/Normed/Algebra/TrivSqZeroExt.lean

Proof steps:
state_before: 𝕜 : Type u_1
S : Type u_2
R : Type u_3
M : Type u_4
inst✝¹³ : SeminormedCommRing S
inst✝¹² : SeminormedRing R
inst✝¹¹ : SeminormedAddCommGroup M
inst✝¹⁰ : Algebra S R
inst✝⁹ : Module S M
inst✝⁸ : Module R M
inst✝⁷ : Module Rᵐᵒᵖ M
inst✝⁶ : BoundedSMul S R
inst✝⁵ : BoundedSMul S M
inst✝⁴ : BoundedSMul R M
inst✝³ : BoundedSMul Rᵐᵒᵖ M
inst✝² : SMulCommClass R Rᵐᵒᵖ M
inst✝¹ : IsScalarTower S R M
inst✝ : IsScalarTower S Rᵐᵒᵖ M
x : tsze R M
⊢ ‖x‖₊ = ‖x.fst‖₊ + ‖x.snd‖₊
state_after: case a
𝕜 : Type u_1
S : Type u_2
R : Type u_3
M : Type u_4
inst✝¹³ : SeminormedCommRing S
inst✝¹² : SeminormedRing R
inst✝¹¹ : SeminormedAddCommGroup M
inst✝¹⁰ : Algebra S R
inst✝⁹ : Module S M
inst✝⁸ : Module R M
inst✝⁷ : Module Rᵐᵒᵖ M
inst✝⁶ : BoundedSMul S R
inst✝⁵ : BoundedSMul S M
inst✝⁴ : BoundedSMul R M
inst✝³ : BoundedSMul Rᵐᵒᵖ M
inst✝² : SMulCommClass R Rᵐᵒᵖ M
inst✝¹ : IsScalarTower S R M
inst✝ : IsScalarTower S Rᵐᵒᵖ M
x : tsze R M
⊢ ↑‖x‖₊ = ↑(‖x.fst‖₊ + ‖x.snd‖₊)
tactic: ext
state_before: case a
𝕜 : Type u_1
S : Type u_2
R : Type u_3
M : Type u_4
inst✝¹³ : SeminormedCommRing S
inst✝¹² : SeminormedRing R
inst✝¹¹ : SeminormedAddCommGroup M
inst✝¹⁰ : Algebra S R
inst✝⁹ : Module S M
inst✝⁸ : Module R M
inst✝⁷ : Module Rᵐᵒᵖ M
inst✝⁶ : BoundedSMul S R
inst✝⁵ : BoundedSMul S M
inst✝⁴ : BoundedSMul R M
inst✝³ : BoundedSMul Rᵐᵒᵖ M
inst✝² : SMulCommClass R Rᵐᵒᵖ M
inst✝¹ : IsScalarTower S R M
inst✝ : IsScalarTower S Rᵐᵒᵖ M
x : tsze R M
⊢ ↑‖x‖₊ = ↑(‖x.fst‖₊ + ‖x.snd‖₊)
state_after: no goals
tactic: simp [norm_def]
Theorem: Nat.primeFactorsList_eq_nil
File: Mathlib/Data/Nat/Factors.lean

Proof steps:
state_before: n : ℕ
⊢ n.primeFactorsList = [] ↔ n = 0 ∨ n = 1
state_after: case mp
n : ℕ
h : n.primeFactorsList = []
⊢ n = 0 ∨ n = 1

case mpr
n : ℕ
h : n = 0 ∨ n = 1
⊢ n.primeFactorsList = []
tactic: constructor <;> intro h
Theorem: ULower.up_down
File: Mathlib/Logic/Encodable/Basic.lean

Proof steps:
state_before: α : Type u_1
inst✝ : Encodable α
a : α
⊢ (down a).up = a
state_after: no goals
tactic: simp [up, down,Equiv.left_inv _ _, Equiv.symm_apply_apply]
Theorem: Set.neg_mem_centralizer
File: Mathlib/Algebra/Ring/Centralizer.lean

Proof steps:
state_before: M : Type u_1
S T : Set M
a : M
b : ?m.797
inst✝¹ : Mul M
inst✝ : HasDistribNeg M
ha : a ∈ S.centralizer
c : M
hc : c ∈ S
⊢ c * -a = -a * c
state_after: no goals
tactic: rw [mul_neg, ha c hc, neg_mul]
Theorem: LieSubmodule.Quotient.range_mk'
File: Mathlib/Algebra/Lie/Quotient.lean

Proof steps:
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N N' : LieSubmodule R L M
I J : LieIdeal R L
⊢ (mk' N).range = ⊤
state_after: no goals
tactic: simp [LieModuleHom.range_eq_top]
Theorem: FirstOrder.Language.Formula.realize_relabel_sum_inr
File: Mathlib/ModelTheory/Semantics.lean

Proof steps:
state_before: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n : ℕ
φ✝ ψ : L.Formula α
v✝ : α → M
φ : L.Formula (Fin n)
v : Empty → M
x : Fin n → M
⊢ (BoundedFormula.relabel Sum.inr φ).Realize v x ↔ φ.Realize x
state_after: no goals
tactic: rw [BoundedFormula.realize_relabel, Formula.Realize, Sum.elim_comp_inr, Fin.castAdd_zero,
    cast_refl, Function.comp_id,
    Subsingleton.elim (x ∘ (natAdd n : Fin 0 → Fin n)) default]
Theorem: zpow_right_strictMono
File: Mathlib/Algebra/Order/Group/Basic.lean

Proof steps:
state_before: α : Type u_1
M : Type u_2
R : Type u_3
inst✝ : OrderedCommGroup α
m✝ n✝ : ℤ
a b : α
ha : 1 < a
m n : ℤ
h : m < n
⊢ a ^ m * a ^ (n - m) = a ^ n
state_after: no goals
tactic: simp [← zpow_add, m.add_comm]
Theorem: MeasureTheory.IsFundamentalDomain.projection_respects_measure_apply
File: Mathlib/MeasureTheory/Group/FundamentalDomain.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
α : Type u_3
β : Type u_4
E : Type u_5
inst✝² : Group G
inst✝¹ : MulAction G α
inst✝ : MeasurableSpace α
ν : Measure α
μ : Measure (Quotient α_mod_G)
i : QuotientMeasureEqMeasurePreimage ν μ
t : Set α
fund_dom_t : IsFundamentalDomain G t ν
U : Set (Quotient α_mod_G)
meas_U : MeasurableSet U
⊢ μ U = ν (Quotient.mk α_mod_G ⁻¹' U ∩ t)
state_after: no goals
tactic: rw [fund_dom_t.projection_respects_measure (μ := μ), measure_map_restrict_apply ν t meas_U]
Theorem: Mathlib.Meta.NormNum.IsRat.to_raw_eq
File: Mathlib/Tactic/NormNum/Result.lean

Proof steps:
state_before: α : Type u
u : Level
n : ℤ
d : ℕ
inst✝ : DivisionRing α
inv : Invertible ↑d
⊢ ↑n * ⅟↑d = Rat.rawCast n d
state_after: no goals
tactic: simp [div_eq_mul_inv]
Theorem: sq_add_sq_mul_sq_add_sq
File: Mathlib/Algebra/Ring/Identities.lean

Proof steps:
state_before: R : Type u_1
inst✝ : CommRing R
a b x₁ x₂ x₃ x₄ x₅ x₆ x₇ x₈ y₁ y₂ y₃ y₄ y₅ y₆ y₇ y₈ n : R
⊢ (x₁ ^ 2 + x₂ ^ 2) * (y₁ ^ 2 + y₂ ^ 2) = (x₁ * y₁ - x₂ * y₂) ^ 2 + (x₁ * y₂ + x₂ * y₁) ^ 2
state_after: no goals
tactic: ring
Theorem: _private.Mathlib.RingTheory.Polynomial.Dickson.0.Polynomial.C_half_mul_two_eq_one
File: Mathlib/RingTheory/Polynomial/Dickson.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
inst✝² : CommRing R
inst✝¹ : CommRing S
k : ℕ
a : R
inst✝ : Invertible 2
⊢ C ⅟2 * 2 = 1
state_after: no goals
tactic: rw [mul_comm, two_mul_C_half_eq_one]
Theorem: Set.pi_univ_Ici
File: Mathlib/Order/Interval/Set/Pi.lean

Proof steps:
state_before: ι : Type u_1
α : ι → Type u_2
inst✝ : (i : ι) → Preorder (α i)
x y✝ y : (i : ι) → α i
⊢ (y ∈ univ.pi fun i => Ici (x i)) ↔ y ∈ Ici x
state_after: no goals
tactic: simp [Pi.le_def]
Theorem: CochainComplex.mappingCone.id
File: Mathlib/Algebra/Homology/HomotopyCategory/MappingCone.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝⁴ : Category.{u_3, u_1} C
inst✝³ : Category.{?u.77613, u_2} D
inst✝² : Preadditive C
inst✝¹ : Preadditive D
F G : CochainComplex C ℤ
φ : F ⟶ G
inst✝ : HasHomotopyCofiber φ
⊢ (↑(fst φ)).comp (inl φ) ⋯ + (snd φ).comp (Cochain.ofHom (inr φ)) ⋯ = Cochain.ofHom (𝟙 (mappingCone φ))
state_after: no goals
tactic: simp [ext_cochain_from_iff φ (-1) 0 (neg_add_self 1)]
Theorem: FreeGroup.lift.range_le
File: Mathlib/GroupTheory/FreeGroup/Basic.lean

Proof steps:
state_before: α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
β : Type v
inst✝ : Group β
f : α → β
x y : FreeGroup α
s : Subgroup β
H : Set.range f ⊆ ↑s
⊢ (lift f).range ≤ s
state_after: case intro.mk
α : Type u
L✝ L₁ L₂ L₃ L₄ : List (α × Bool)
β : Type v
inst✝ : Group β
f : α → β
x y : FreeGroup α
s : Subgroup β
H : Set.range f ⊆ ↑s
w✝ : FreeGroup α
L : List (α × Bool)
⊢ (lift f) (Quot.mk Red.Step L) ∈ s
tactic: rintro _ ⟨⟨L⟩, rfl⟩
state_before: case intro.mk
α : Type u
L✝ L₁ L₂ L₃ L₄ : List (α × Bool)
β : Type v
inst✝ : Group β
f : α → β
x y : FreeGroup α
s : Subgroup β
H : Set.range f ⊆ ↑s
w✝ : FreeGroup α
L : List (α × Bool)
⊢ (lift f) (Quot.mk Red.Step L) ∈ s
state_after: no goals
tactic: exact List.recOn L s.one_mem fun ⟨x, b⟩ tl ih ↦
    Bool.recOn b (by simpa using s.mul_mem (s.inv_mem <| H ⟨x, rfl⟩) ih)
      (by simpa using s.mul_mem (H ⟨x, rfl⟩) ih)
Theorem: Matrix.conjTranspose_neg
File: Mathlib/Data/Matrix/Basic.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝¹ : AddGroup α
inst✝ : StarAddMonoid α
M : Matrix m n α
⊢ ∀ (i : n) (j : m), (-M)ᴴ i j = (-Mᴴ) i j
state_after: no goals
tactic: simp
Theorem: Filter.comap_neBot_iff
File: Mathlib/Order/Filter/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m✝ : α → β
m' : β → γ
s : Set α
t : Set β
f : Filter β
m : α → β
⊢ (comap m f).NeBot ↔ ∀ t ∈ f, ∃ a, m a ∈ t
state_after: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m✝ : α → β
m' : β → γ
s : Set α
t : Set β
f : Filter β
m : α → β
⊢ (∀ (s : Set α), ∀ x ∈ f, m ⁻¹' x ⊆ s → s.Nonempty) ↔ ∀ t ∈ f, ∃ a, m a ∈ t
tactic: simp only [← forall_mem_nonempty_iff_neBot, mem_comap, forall_exists_index, and_imp]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m✝ : α → β
m' : β → γ
s : Set α
t : Set β
f : Filter β
m : α → β
⊢ (∀ (s : Set α), ∀ x ∈ f, m ⁻¹' x ⊆ s → s.Nonempty) ↔ ∀ t ∈ f, ∃ a, m a ∈ t
state_after: no goals
tactic: exact ⟨fun h t t_in => h (m ⁻¹' t) t t_in Subset.rfl, fun h s t ht hst => (h t ht).imp hst⟩
Theorem: Stream'.WSeq.join_cons
File: Mathlib/Data/Seq/WSeq.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
s : WSeq α
S : WSeq (WSeq α)
⊢ (cons s S).join = (s.append S.join).think
state_after: α : Type u
β : Type v
γ : Type w
s : WSeq α
S : WSeq (WSeq α)
⊢ ((fun o =>
          match o with
          | none => Seq1.ret none
          | some s => (none, s)) <$>
        cons s S).join =
    Seq.cons none
      (s.append
        ((fun o =>
              match o with
              | none => Seq1.ret none
              | some s => (none, s)) <$>
            S).join)
tactic: simp only [join, think]
state_before: α : Type u
β : Type v
γ : Type w
s : WSeq α
S : WSeq (WSeq α)
⊢ (Seq.map
        (fun o =>
          match o with
          | none => Seq1.ret none
          | some s => (none, s))
        (cons s S)).join =
    Seq.cons none
      (s.append
        (Seq.map
            (fun o =>
              match o with
              | none => Seq1.ret none
              | some s => (none, s))
            S).join)
state_after: no goals
tactic: simp [join, cons, append]