ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: AlgHom.apply_mem_spectrum
File: Mathlib/Algebra/Algebra/Spectrum.lean

Proof steps:
state_before: F : Type u_1
R : Type u_2
A : Type u_3
B : Type u_4
inst✝⁷ : CommRing R
inst✝⁶ : Ring A
inst✝⁵ : Algebra R A
inst✝⁴ : Ring B
inst✝³ : Algebra R B
inst✝² : FunLike F A R
inst✝¹ : AlgHomClass F R A R
inst✝ : Nontrivial R
φ : F
a : A
⊢ φ a ∈ σ a
state_after: F : Type u_1
R : Type u_2
A : Type u_3
B : Type u_4
inst✝⁷ : CommRing R
inst✝⁶ : Ring A
inst✝⁵ : Algebra R A
inst✝⁴ : Ring B
inst✝³ : Algebra R B
inst✝² : FunLike F A R
inst✝¹ : AlgHomClass F R A R
inst✝ : Nontrivial R
φ : F
a : A
h : ↑ₐ (φ a) - a ∈ RingHom.ker ↑φ
⊢ φ a ∈ σ a
tactic: have h : ↑ₐ (φ a) - a ∈ RingHom.ker (φ : A →+* R) := by
    simp only [RingHom.mem_ker, map_sub, RingHom.coe_coe, AlgHomClass.commutes,
      Algebra.id.map_eq_id, RingHom.id_apply, sub_self]
state_before: F : Type u_1
R : Type u_2
A : Type u_3
B : Type u_4
inst✝⁷ : CommRing R
inst✝⁶ : Ring A
inst✝⁵ : Algebra R A
inst✝⁴ : Ring B
inst✝³ : Algebra R B
inst✝² : FunLike F A R
inst✝¹ : AlgHomClass F R A R
inst✝ : Nontrivial R
φ : F
a : A
h : ↑ₐ (φ a) - a ∈ RingHom.ker ↑φ
⊢ φ a ∈ σ a
state_after: no goals
tactic: simp only [spectrum.mem_iff, ← mem_nonunits_iff,
    coe_subset_nonunits (RingHom.ker_ne_top (φ : A →+* R)) h]
Theorem: PiLp.nndist_equiv_symm_single_same
File: Mathlib/Analysis/Normed/Lp/PiLp.lean

Proof steps:
state_before: p : ℝ≥0∞
𝕜 : Type u_1
ι : Type u_2
α : ι → Type u_3
β : ι → Type u_4
inst✝⁷ : Fact (1 ≤ p)
inst✝⁶ : Fintype ι
inst✝⁵ : Semiring 𝕜
inst✝⁴ : (i : ι) → SeminormedAddCommGroup (α i)
inst✝³ : (i : ι) → SeminormedAddCommGroup (β i)
inst✝² : (i : ι) → Module 𝕜 (α i)
inst✝¹ : (i : ι) → Module 𝕜 (β i)
c : 𝕜
inst✝ : DecidableEq ι
i : ι
b₁ b₂ : β i
⊢ nndist ((WithLp.equiv p ((i : ι) → β i)).symm (Pi.single i b₁))
      ((WithLp.equiv p ((i : ι) → β i)).symm (Pi.single i b₂)) =
    nndist b₁ b₂
state_after: no goals
tactic: rw [nndist_eq_nnnorm, nndist_eq_nnnorm, ← WithLp.equiv_symm_sub, ← Pi.single_sub,
    nnnorm_equiv_symm_single]
Theorem: TopologicalSpace.IsTopologicalBasis.nhds_basis_closure
File: Mathlib/Topology/Separation.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : RegularSpace X
x✝ : X
s : Set X
B : Set (Set X)
hB : IsTopologicalBasis B
x : X
⊢ (𝓝 x).HasBasis (fun s => x ∈ s ∧ s ∈ B) closure
state_after: no goals
tactic: simpa only [and_comm] using hB.nhds_hasBasis.nhds_closure
Theorem: ValuationRing.range_algebraMap_eq
File: Mathlib/RingTheory/Valuation/ValuationRing.lean

Proof steps:
state_before: A : Type u
inst✝⁵ : CommRing A
K : Type v
inst✝⁴ : Field K
inst✝³ : Algebra A K
inst✝² : IsDomain A
inst✝¹ : ValuationRing A
inst✝ : IsFractionRing A K
⊢ (valuation A K).integer = (algebraMap A K).range
state_after: case h
A : Type u
inst✝⁵ : CommRing A
K : Type v
inst✝⁴ : Field K
inst✝³ : Algebra A K
inst✝² : IsDomain A
inst✝¹ : ValuationRing A
inst✝ : IsFractionRing A K
x✝ : K
⊢ x✝ ∈ (valuation A K).integer ↔ x✝ ∈ (algebraMap A K).range
tactic: ext
state_before: case h
A : Type u
inst✝⁵ : CommRing A
K : Type v
inst✝⁴ : Field K
inst✝³ : Algebra A K
inst✝² : IsDomain A
inst✝¹ : ValuationRing A
inst✝ : IsFractionRing A K
x✝ : K
⊢ x✝ ∈ (valuation A K).integer ↔ x✝ ∈ (algebraMap A K).range
state_after: no goals
tactic: exact mem_integer_iff _ _ _
Theorem: Topology.IsScott.isOpen_iff_isUpperSet_and_dirSupInacc
File: Mathlib/Topology/Order/ScottTopology.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : Preorder α
inst✝¹ : TopologicalSpace α
inst✝ : IsScott α
s : Set α
a : α
⊢ IsOpen s ↔ IsUpperSet s ∧ DirSupInacc s
state_after: α : Type u_1
β : Type u_2
inst✝² : Preorder α
inst✝¹ : TopologicalSpace α
inst✝ : IsScott α
s : Set α
a : α
⊢ IsUpperSet s ∧ IsOpen s ↔ IsUpperSet s ∧ DirSupInacc s
tactic: rw [isOpen_iff_isUpperSet_and_scottHausdorff_open]
state_before: α : Type u_1
β : Type u_2
inst✝² : Preorder α
inst✝¹ : TopologicalSpace α
inst✝ : IsScott α
s : Set α
a : α
⊢ IsUpperSet s ∧ IsOpen s ↔ IsUpperSet s ∧ DirSupInacc s
state_after: α : Type u_1
β : Type u_2
inst✝² : Preorder α
inst✝¹ : TopologicalSpace α
inst✝ : IsScott α
s : Set α
a : α
h : IsUpperSet s
h' : DirSupInacc s
d : Set α
d₁ : d.Nonempty
d₂ : DirectedOn (fun x x_1 => x ≤ x_1) d
x✝ : α
d₃ : IsLUB d x✝
ha : x✝ ∈ s
⊢ ∃ b ∈ d, Ici b ∩ d ⊆ s
tactic: refine and_congr_right fun h ↦
    ⟨@IsScottHausdorff.dirSupInacc_of_isOpen _ _ (scottHausdorff α) _ _,
      fun h' d d₁ d₂ _ d₃ ha ↦ ?_⟩
state_before: α : Type u_1
β : Type u_2
inst✝² : Preorder α
inst✝¹ : TopologicalSpace α
inst✝ : IsScott α
s : Set α
a : α
h : IsUpperSet s
h' : DirSupInacc s
d : Set α
d₁ : d.Nonempty
d₂ : DirectedOn (fun x x_1 => x ≤ x_1) d
x✝ : α
d₃ : IsLUB d x✝
ha : x✝ ∈ s
⊢ ∃ b ∈ d, Ici b ∩ d ⊆ s
state_after: case intro.intro
α : Type u_1
β : Type u_2
inst✝² : Preorder α
inst✝¹ : TopologicalSpace α
inst✝ : IsScott α
s : Set α
a : α
h : IsUpperSet s
h' : DirSupInacc s
d : Set α
d₁ : d.Nonempty
d₂ : DirectedOn (fun x x_1 => x ≤ x_1) d
x✝ : α
d₃ : IsLUB d x✝
ha : x✝ ∈ s
b : α
hbd : b ∈ d
hbu : b ∈ s
⊢ ∃ b ∈ d, Ici b ∩ d ⊆ s
tactic: obtain ⟨b, hbd, hbu⟩ := h' d₁ d₂ d₃ ha
state_before: case intro.intro
α : Type u_1
β : Type u_2
inst✝² : Preorder α
inst✝¹ : TopologicalSpace α
inst✝ : IsScott α
s : Set α
a : α
h : IsUpperSet s
h' : DirSupInacc s
d : Set α
d₁ : d.Nonempty
d₂ : DirectedOn (fun x x_1 => x ≤ x_1) d
x✝ : α
d₃ : IsLUB d x✝
ha : x✝ ∈ s
b : α
hbd : b ∈ d
hbu : b ∈ s
⊢ ∃ b ∈ d, Ici b ∩ d ⊆ s
state_after: no goals
tactic: exact ⟨b, hbd, Subset.trans inter_subset_left (h.Ici_subset hbu)⟩
Theorem: Finset.update_piecewise_of_not_mem
File: Mathlib/Data/Finset/Piecewise.lean

Proof steps:
state_before: ι : Type u_1
π : ι → Sort u_2
s : Finset ι
f g : (i : ι) → π i
inst✝¹ : (j : ι) → Decidable (j ∈ s)
inst✝ : DecidableEq ι
i : ι
hi : i ∉ s
v : π i
⊢ update (s.piecewise f g) i v = s.piecewise f (update g i v)
state_after: ι : Type u_1
π : ι → Sort u_2
s : Finset ι
f g : (i : ι) → π i
inst✝¹ : (j : ι) → Decidable (j ∈ s)
inst✝ : DecidableEq ι
i : ι
hi : i ∉ s
v : π i
⊢ s.piecewise (update f i v) (update g i v) = s.piecewise f (update g i v)
tactic: rw [update_piecewise]
state_before: ι : Type u_1
π : ι → Sort u_2
s : Finset ι
f g : (i : ι) → π i
inst✝¹ : (j : ι) → Decidable (j ∈ s)
inst✝ : DecidableEq ι
i : ι
hi : i ∉ s
v : π i
⊢ s.piecewise (update f i v) (update g i v) = s.piecewise f (update g i v)
state_after: ι : Type u_1
π : ι → Sort u_2
s : Finset ι
f g : (i : ι) → π i
inst✝¹ : (j : ι) → Decidable (j ∈ s)
inst✝ : DecidableEq ι
i : ι
hi : i ∉ s
v : π i
j : ι
hj : j ∈ s
⊢ j ≠ i
tactic: refine s.piecewise_congr (fun j hj => update_noteq ?_ _ _) fun _ _ => rfl
state_before: ι : Type u_1
π : ι → Sort u_2
s : Finset ι
f g : (i : ι) → π i
inst✝¹ : (j : ι) → Decidable (j ∈ s)
inst✝ : DecidableEq ι
i : ι
hi : i ∉ s
v : π i
j : ι
hj : j ∈ s
⊢ j ≠ i
state_after: no goals
tactic: exact fun h => hi (h ▸ hj)
Theorem: OrderBot.ext_bot
File: Mathlib/Order/BoundedOrder.lean

Proof steps:
state_before: α✝ : Type u
β : Type v
γ : Type u_1
δ : Type u_2
α : Type u_3
hA : PartialOrder α
A : OrderBot α
hB : PartialOrder α
B : OrderBot α
H : ∀ (x y : α), x ≤ y ↔ x ≤ y
⊢ ⊥ = ⊥
state_after: case refl
α✝ : Type u
β : Type v
γ : Type u_1
δ : Type u_2
α : Type u_3
hA : PartialOrder α
A B : OrderBot α
H : ∀ (x y : α), x ≤ y ↔ x ≤ y
⊢ ⊥ = ⊥
tactic: cases PartialOrder.ext H
state_before: case refl
α✝ : Type u
β : Type v
γ : Type u_1
δ : Type u_2
α : Type u_3
hA : PartialOrder α
A B : OrderBot α
H : ∀ (x y : α), x ≤ y ↔ x ≤ y
⊢ ⊥ = ⊥
state_after: case refl.h
α✝ : Type u
β : Type v
γ : Type u_1
δ : Type u_2
α : Type u_3
hA : PartialOrder α
A B : OrderBot α
H : ∀ (x y : α), x ≤ y ↔ x ≤ y
⊢ ⊥ ≤ ⊥
tactic: apply bot_unique
state_before: case refl.h
α✝ : Type u
β : Type v
γ : Type u_1
δ : Type u_2
α : Type u_3
hA : PartialOrder α
A B : OrderBot α
H : ∀ (x y : α), x ≤ y ↔ x ≤ y
⊢ ⊥ ≤ ⊥
state_after: no goals
tactic: exact @bot_le _ _ A _
Theorem: CategoryTheory.Discrete.natIso_hom_app
File: Mathlib/CategoryTheory/DiscreteCategory.lean

Proof steps:
state_before: α : Type u₁
C : Type u₂
inst✝ : Category.{v₂, u₂} C
I : Type u₁
F G : Discrete I ⥤ C
f : (i : Discrete I) → F.obj i ≅ G.obj i
X✝ Y✝ : Discrete I
x✝ : X✝ ⟶ Y✝
g : X✝.as = Y✝.as
⊢ F.map { down := { down := g } } ≫ (f Y✝).hom = (f X✝).hom ≫ G.map { down := { down := g } }
state_after: case mk.mk.up.up
α : Type u₁
C : Type u₂
inst✝ : Category.{v₂, u₂} C
I : Type u₁
F G : Discrete I ⥤ C
f : (i : Discrete I) → F.obj i ≅ G.obj i
as✝¹ as✝ : I
g down✝ : { as := as✝¹ }.as = { as := as✝ }.as
⊢ F.map { down := { down := g } } ≫ (f { as := as✝ }).hom = (f { as := as✝¹ }).hom ≫ G.map { down := { down := g } }
tactic: discrete_cases
state_before: case mk.mk.up.up
α : Type u₁
C : Type u₂
inst✝ : Category.{v₂, u₂} C
I : Type u₁
F G : Discrete I ⥤ C
f : (i : Discrete I) → F.obj i ≅ G.obj i
as✝¹ as✝ : I
g down✝ : { as := as✝¹ }.as = { as := as✝ }.as
⊢ F.map { down := { down := g } } ≫ (f { as := as✝ }).hom = (f { as := as✝¹ }).hom ≫ G.map { down := { down := g } }
state_after: case mk.mk.up.up.refl
α : Type u₁
C : Type u₂
inst✝ : Category.{v₂, u₂} C
I : Type u₁
F G : Discrete I ⥤ C
f : (i : Discrete I) → F.obj i ≅ G.obj i
as✝ : I
down✝ : { as := as✝ }.as = { as := as✝ }.as
⊢ F.map { down := { down := ⋯ } } ≫ (f { as := as✝ }).hom = (f { as := as✝ }).hom ≫ G.map { down := { down := ⋯ } }
tactic: rcases g
state_before: case mk.mk.up.up.refl
α : Type u₁
C : Type u₂
inst✝ : Category.{v₂, u₂} C
I : Type u₁
F G : Discrete I ⥤ C
f : (i : Discrete I) → F.obj i ≅ G.obj i
as✝ : I
down✝ : { as := as✝ }.as = { as := as✝ }.as
⊢ F.map { down := { down := ⋯ } } ≫ (f { as := as✝ }).hom = (f { as := as✝ }).hom ≫ G.map { down := { down := ⋯ } }
state_after: case mk.mk.up.up.refl
α : Type u₁
C : Type u₂
inst✝ : Category.{v₂, u₂} C
I : Type u₁
F G : Discrete I ⥤ C
f : (i : Discrete I) → F.obj i ≅ G.obj i
as✝ : I
down✝ : { as := as✝ }.as = { as := as✝ }.as
⊢ F.map (𝟙 { as := as✝ }) ≫ (f { as := as✝ }).hom = (f { as := as✝ }).hom ≫ G.map (𝟙 { as := as✝ })
tactic: change F.map (𝟙 _) ≫ _ = _ ≫ G.map (𝟙 _)
state_before: case mk.mk.up.up.refl
α : Type u₁
C : Type u₂
inst✝ : Category.{v₂, u₂} C
I : Type u₁
F G : Discrete I ⥤ C
f : (i : Discrete I) → F.obj i ≅ G.obj i
as✝ : I
down✝ : { as := as✝ }.as = { as := as✝ }.as
⊢ F.map (𝟙 { as := as✝ }) ≫ (f { as := as✝ }).hom = (f { as := as✝ }).hom ≫ G.map (𝟙 { as := as✝ })
state_after: no goals
tactic: simp
Theorem: IsSelfAdjoint.sub
File: Mathlib/Algebra/Star/SelfAdjoint.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
inst✝¹ : AddGroup R
inst✝ : StarAddMonoid R
x y : R
hx : IsSelfAdjoint x
hy : IsSelfAdjoint y
⊢ IsSelfAdjoint (x - y)
state_after: no goals
tactic: simp only [isSelfAdjoint_iff, star_sub, hx.star_eq, hy.star_eq]
Theorem: ZMod.val_eq_ite_valMinAbs
File: Mathlib/Data/ZMod/Basic.lean

Proof steps:
state_before: m n✝ n : ℕ
inst✝ : NeZero n
a : ZMod n
⊢ ↑a.val = a.valMinAbs + ↑(if a.val ≤ n / 2 then 0 else n)
state_after: m n✝ n : ℕ
inst✝ : NeZero n
a : ZMod n
⊢ ↑a.val = (if a.val ≤ n / 2 then ↑a.val else ↑a.val - ↑n) + ↑(if a.val ≤ n / 2 then 0 else n)
tactic: rw [valMinAbs_def_pos]
state_before: m n✝ n : ℕ
inst✝ : NeZero n
a : ZMod n
⊢ ↑a.val = (if a.val ≤ n / 2 then ↑a.val else ↑a.val - ↑n) + ↑(if a.val ≤ n / 2 then 0 else n)
state_after: no goals
tactic: split_ifs <;> simp [add_zero, sub_add_cancel]
Theorem: CategoryTheory.CosimplicialObject.δ_comp_δ'
File: Mathlib/AlgebraicTopology/SimplicialObject.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
n : ℕ
i : Fin (n + 2)
j : Fin (n + 3)
H : i.castSucc < j
hj : j = 0
⊢ False
state_after: no goals
tactic: simp only [hj, Fin.not_lt_zero] at H
state_before: C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
n : ℕ
i : Fin (n + 2)
j : Fin (n + 3)
H : i.castSucc < j
⊢ X.δ i ≫ X.δ j = X.δ (j.pred ⋯) ≫ X.δ i.castSucc
state_after: C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
n : ℕ
i : Fin (n + 2)
j : Fin (n + 3)
H : i.castSucc < j
⊢ X.map (SimplexCategory.δ i) ≫ X.map (SimplexCategory.δ j) =
    X.map (SimplexCategory.δ (j.pred ⋯)) ≫ X.map (SimplexCategory.δ i.castSucc)
tactic: dsimp [δ]
state_before: C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
n : ℕ
i : Fin (n + 2)
j : Fin (n + 3)
H : i.castSucc < j
⊢ X.map (SimplexCategory.δ i) ≫ X.map (SimplexCategory.δ j) =
    X.map (SimplexCategory.δ (j.pred ⋯)) ≫ X.map (SimplexCategory.δ i.castSucc)
state_after: no goals
tactic: simp only [← X.map_comp, ← op_comp, SimplexCategory.δ_comp_δ' H]
Theorem: Subgroup.IsComplement.equiv_fst_eq_one_of_mem_of_one_mem
File: Mathlib/GroupTheory/Complement.lean

Proof steps:
state_before: G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
hST : IsComplement S T
hHT : IsComplement (↑H) T
hSK : IsComplement S ↑K
g : G
h1 : 1 ∈ S
hg : g ∈ T
⊢ (hST.equiv g).1 = ⟨1, h1⟩
state_after: case a
G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
hST : IsComplement S T
hHT : IsComplement (↑H) T
hSK : IsComplement S ↑K
g : G
h1 : 1 ∈ S
hg : g ∈ T
⊢ ↑(hST.equiv g).1 = ↑⟨1, h1⟩
tactic: ext
state_before: case a
G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
hST : IsComplement S T
hHT : IsComplement (↑H) T
hSK : IsComplement S ↑K
g : G
h1 : 1 ∈ S
hg : g ∈ T
⊢ ↑(hST.equiv g).1 = ↑⟨1, h1⟩
state_after: no goals
tactic: rw [equiv_fst_eq_mul_inv, equiv_snd_eq_self_of_mem_of_one_mem _ h1 hg, mul_inv_self]
Theorem: DirectSum.IsInternal.ofBijective_coeLinearMap_same
File: Mathlib/Algebra/DirectSum/Module.lean

Proof steps:
state_before: R : Type u
inst✝² : Semiring R
ι : Type v
dec_ι : DecidableEq ι
M : Type u_1
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
A : ι → Submodule R M
h : IsInternal A
i : ι
x : ↥(A i)
⊢ ((LinearEquiv.ofBijective (coeLinearMap A) h).symm ↑x) i = x
state_after: no goals
tactic: rw [← coeLinearMap_of, LinearEquiv.ofBijective_symm_apply_apply, of_eq_same]
Theorem: Finset.Iio_subset_Iic_self
File: Mathlib/Order/Interval/Finset/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : Preorder α
inst✝ : LocallyFiniteOrderBot α
a : α
⊢ Iio a ⊆ Iic a
state_after: no goals
tactic: simpa [← coe_subset] using Set.Iio_subset_Iic_self
Theorem: Polynomial.deriv_gaussian_eq_hermite_mul_gaussian
File: Mathlib/RingTheory/Polynomial/Hermite/Gaussian.lean

Proof steps:
state_before: n : ℕ
x : ℝ
⊢ deriv^[n] (fun y => Real.exp (-(y ^ 2 / 2))) x = (-1) ^ n * (aeval x) (hermite n) * Real.exp (-(x ^ 2 / 2))
state_after: n : ℕ
x : ℝ
⊢ deriv^[n] (fun y => Real.exp (-(y ^ 2 / 2))) x = (-1) ^ n * ((aeval x) (hermite n) * Real.exp (-(x ^ 2 / 2)))
tactic: rw [mul_assoc]
state_before: n : ℕ
x : ℝ
⊢ deriv^[n] (fun y => Real.exp (-(y ^ 2 / 2))) x = (-1) ^ n * ((aeval x) (hermite n) * Real.exp (-(x ^ 2 / 2)))
state_after: case zero
x : ℝ
⊢ deriv^[0] (fun y => Real.exp (-(y ^ 2 / 2))) x = (-1) ^ 0 * ((aeval x) (hermite 0) * Real.exp (-(x ^ 2 / 2)))

case succ
n : ℕ
ih :
  ∀ (x : ℝ),
    deriv^[n] (fun y => Real.exp (-(y ^ 2 / 2))) x = (-1) ^ n * ((aeval x) (hermite n) * Real.exp (-(x ^ 2 / 2)))
x : ℝ
⊢ deriv^[n + 1] (fun y => Real.exp (-(y ^ 2 / 2))) x =
    (-1) ^ (n + 1) * ((aeval x) (hermite (n + 1)) * Real.exp (-(x ^ 2 / 2)))
tactic: induction' n with n ih generalizing x
Theorem: FirstOrder.Language.Theory.SemanticallyEquivalent.trans
File: Mathlib/ModelTheory/Satisfiability.lean

Proof steps:
state_before: L : Language
T : L.Theory
α : Type w
n : ℕ
φ ψ θ : L.BoundedFormula α n
h1 : T.SemanticallyEquivalent φ ψ
h2 : T.SemanticallyEquivalent ψ θ
M : T.ModelType
v : α → ↑M
xs : Fin n → ↑M
⊢ (φ ⇔ θ).Realize v xs
state_after: L : Language
T : L.Theory
α : Type w
n : ℕ
φ ψ θ : L.BoundedFormula α n
h1 : T.SemanticallyEquivalent φ ψ
h2 : T.SemanticallyEquivalent ψ θ
M : T.ModelType
v : α → ↑M
xs : Fin n → ↑M
h1' : (φ ⇔ ψ).Realize v xs
⊢ (φ ⇔ θ).Realize v xs
tactic: have h1' := h1 M v xs
state_before: L : Language
T : L.Theory
α : Type w
n : ℕ
φ ψ θ : L.BoundedFormula α n
h1 : T.SemanticallyEquivalent φ ψ
h2 : T.SemanticallyEquivalent ψ θ
M : T.ModelType
v : α → ↑M
xs : Fin n → ↑M
h1' : (φ ⇔ ψ).Realize v xs
⊢ (φ ⇔ θ).Realize v xs
state_after: L : Language
T : L.Theory
α : Type w
n : ℕ
φ ψ θ : L.BoundedFormula α n
h1 : T.SemanticallyEquivalent φ ψ
h2 : T.SemanticallyEquivalent ψ θ
M : T.ModelType
v : α → ↑M
xs : Fin n → ↑M
h1' : (φ ⇔ ψ).Realize v xs
h2' : (ψ ⇔ θ).Realize v xs
⊢ (φ ⇔ θ).Realize v xs
tactic: have h2' := h2 M v xs
state_before: L : Language
T : L.Theory
α : Type w
n : ℕ
φ ψ θ : L.BoundedFormula α n
h1 : T.SemanticallyEquivalent φ ψ
h2 : T.SemanticallyEquivalent ψ θ
M : T.ModelType
v : α → ↑M
xs : Fin n → ↑M
h1' : (φ ⇔ ψ).Realize v xs
h2' : (ψ ⇔ θ).Realize v xs
⊢ (φ ⇔ θ).Realize v xs
state_after: L : Language
T : L.Theory
α : Type w
n : ℕ
φ ψ θ : L.BoundedFormula α n
h1 : T.SemanticallyEquivalent φ ψ
h2 : T.SemanticallyEquivalent ψ θ
M : T.ModelType
v : α → ↑M
xs : Fin n → ↑M
h1' : φ.Realize v xs ↔ ψ.Realize v xs
h2' : ψ.Realize v xs ↔ θ.Realize v xs
⊢ φ.Realize v xs ↔ θ.Realize v xs
tactic: rw [BoundedFormula.realize_iff] at *
state_before: L : Language
T : L.Theory
α : Type w
n : ℕ
φ ψ θ : L.BoundedFormula α n
h1 : T.SemanticallyEquivalent φ ψ
h2 : T.SemanticallyEquivalent ψ θ
M : T.ModelType
v : α → ↑M
xs : Fin n → ↑M
h1' : φ.Realize v xs ↔ ψ.Realize v xs
h2' : ψ.Realize v xs ↔ θ.Realize v xs
⊢ φ.Realize v xs ↔ θ.Realize v xs
state_after: no goals
tactic: exact ⟨h2'.1 ∘ h1'.1, h1'.2 ∘ h2'.2⟩
Theorem: AddAction.nsmul_mod_period_vadd
File: Mathlib/Dynamics/PeriodicPts.lean

Proof steps:
state_before: α : Type v
G : Type u
inst✝³ : Group G
inst✝² : MulAction G α
M : Type u
inst✝¹ : Monoid M
inst✝ : MulAction M α
n : ℕ
m : M
a : α
⊢ m ^ (n % period m a) • a = m ^ n • a
state_after: no goals
tactic: conv_rhs => rw [← Nat.mod_add_div n (period m a), pow_add, mul_smul,
    pow_smul_eq_iff_period_dvd.mpr (dvd_mul_right _ _)]
Theorem: List.mem_permutationsAux2'
File: Mathlib/Data/List/Permutation.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
t : α
ts ys l : List α
⊢ l ∈ (permutationsAux2 t ts [] ys fun x => [] ++ x).2 ↔ ∃ l₁ l₂, l₂ ≠ [] ∧ ys = l₁ ++ l₂ ∧ l = l₁ ++ t :: l₂ ++ ts
state_after: no goals
tactic: apply mem_permutationsAux2
Theorem: IsAddCyclic.card_addOrderOf_eq_totient
File: Mathlib/GroupTheory/SpecificGroups/Cyclic.lean

Proof steps:
state_before: α : Type u
a : α
inst✝² : Group α
inst✝¹ : IsCyclic α
inst✝ : Fintype α
d : ℕ
hd : d ∣ Fintype.card α
⊢ (filter (fun a => orderOf a = d) univ).card = φ d
state_after: no goals
tactic: classical apply card_orderOf_eq_totient_aux₂ (fun n => IsCyclic.card_pow_eq_one_le) hd
Theorem: Polynomial.X_pow_mul_monomial
File: Mathlib/Algebra/Polynomial/Basic.lean

Proof steps:
state_before: R : Type u
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
k n : ℕ
r : R
⊢ X ^ k * (monomial n) r = (monomial (n + k)) r
state_after: no goals
tactic: rw [X_pow_mul, monomial_mul_X_pow]
Theorem: Dense.eq_zero_of_inner_right
File: Mathlib/Analysis/InnerProductSpace/Projection.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
x y : E
hK : Dense ↑K
h : ∀ (v : ↥K), ⟪↑v, x⟫_𝕜 = 0
v : ↥K
⊢ ⟪↑v, x⟫_𝕜 = ⟪↑v, 0⟫_𝕜
state_after: no goals
tactic: rw [inner_zero_right, h v]
Theorem: Finset.le_card_infs_mul_card_sups
File: Mathlib/Combinatorics/SetFamily/FourFunctions.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝³ : DistribLattice α
inst✝² : LinearOrderedCommSemiring β
inst✝¹ : ExistsAddOfLE β
f f₁ f₂ f₃ f₄ g μ : α → β
inst✝ : DecidableEq α
s t : Finset α
⊢ s.card * t.card ≤ (s ⊼ t).card * (s ⊻ t).card
state_after: no goals
tactic: simpa using four_functions_theorem (1 : α → ℕ) 1 1 1 zero_le_one zero_le_one zero_le_one
    zero_le_one (fun _ _ ↦ le_rfl) s t
Theorem: Polynomial.X_pow_eq_monomial
File: Mathlib/Algebra/Polynomial/Basic.lean

Proof steps:
state_before: R : Type u
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
n : ℕ
⊢ X ^ n = (monomial n) 1
state_after: case zero
R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
p q : R[X]
⊢ X ^ 0 = (monomial 0) 1

case succ
R : Type u
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
n : ℕ
hn : X ^ n = (monomial n) 1
⊢ X ^ (n + 1) = (monomial (n + 1)) 1
tactic: induction' n with n hn
Theorem: LieModule.traceForm_lieInvariant
File: Mathlib/Algebra/Lie/TraceForm.lean

Proof steps:
state_before: R : Type u_1
K : Type u_2
L : Type u_3
M : Type u_4
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
inst✝¹ : Module.Free R M
inst✝ : Module.Finite R M
⊢ LinearMap.BilinForm.lieInvariant L (traceForm R L M)
state_after: R : Type u_1
K : Type u_2
L : Type u_3
M : Type u_4
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
inst✝¹ : Module.Free R M
inst✝ : Module.Finite R M
x y z : L
⊢ ((traceForm R L M) ⁅x, y⁆) z = -((traceForm R L M) y) ⁅x, z⁆
tactic: intro x y z
state_before: R : Type u_1
K : Type u_2
L : Type u_3
M : Type u_4
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
inst✝¹ : Module.Free R M
inst✝ : Module.Finite R M
x y z : L
⊢ ((traceForm R L M) ⁅x, y⁆) z = -((traceForm R L M) y) ⁅x, z⁆
state_after: no goals
tactic: rw [← lie_skew, map_neg, LinearMap.neg_apply, LieModule.traceForm_apply_lie_apply R L M]
Theorem: CategoryTheory.Limits.Multifork.app_right_eq_ι_comp_fst
File: Mathlib/CategoryTheory/Limits/Shapes/Multiequalizer.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
I : MulticospanIndex C
K : Multifork I
b : I.R
⊢ K.π.app (WalkingMulticospan.right b) = K.ι (I.fstTo b) ≫ I.fst b
state_after: C : Type u
inst✝ : Category.{v, u} C
I : MulticospanIndex C
K : Multifork I
b : I.R
⊢ K.π.app (WalkingMulticospan.left (I.fstTo b)) ≫ I.multicospan.map (WalkingMulticospan.Hom.fst b) =
    K.ι (I.fstTo b) ≫ I.fst b
tactic: rw [← K.w (WalkingMulticospan.Hom.fst b)]
state_before: C : Type u
inst✝ : Category.{v, u} C
I : MulticospanIndex C
K : Multifork I
b : I.R
⊢ K.π.app (WalkingMulticospan.left (I.fstTo b)) ≫ I.multicospan.map (WalkingMulticospan.Hom.fst b) =
    K.ι (I.fstTo b) ≫ I.fst b
state_after: no goals
tactic: rfl