ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Real.sin_lt_sin_of_lt_of_le_pi_div_two
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

Proof steps:
state_before: x y : ℝ
hx₁ : -(π / 2) ≤ x
hy₂ : y ≤ π / 2
hxy : x < y
⊢ sin x < sin y
state_after: x y : ℝ
hx₁ : -(π / 2) ≤ x
hy₂ : y ≤ π / 2
hxy : x < y
⊢ 0 < 2 * sin ((y - x) / 2) * cos ((y + x) / 2)
tactic: rw [← sub_pos, sin_sub_sin]
state_before: x y : ℝ
hx₁ : -(π / 2) ≤ x
hy₂ : y ≤ π / 2
hxy : x < y
⊢ 0 < 2 * sin ((y - x) / 2) * cos ((y + x) / 2)
state_after: x y : ℝ
hx₁ : -(π / 2) ≤ x
hy₂ : y ≤ π / 2
hxy : x < y
this : 0 < sin ((y - x) / 2)
⊢ 0 < 2 * sin ((y - x) / 2) * cos ((y + x) / 2)
tactic: have : 0 < sin ((y - x) / 2) := by apply sin_pos_of_pos_of_lt_pi <;> linarith
state_before: x y : ℝ
hx₁ : -(π / 2) ≤ x
hy₂ : y ≤ π / 2
hxy : x < y
this : 0 < sin ((y - x) / 2)
⊢ 0 < 2 * sin ((y - x) / 2) * cos ((y + x) / 2)
state_after: x y : ℝ
hx₁ : -(π / 2) ≤ x
hy₂ : y ≤ π / 2
hxy : x < y
this✝ : 0 < sin ((y - x) / 2)
this : 0 < cos ((y + x) / 2)
⊢ 0 < 2 * sin ((y - x) / 2) * cos ((y + x) / 2)
tactic: have : 0 < cos ((y + x) / 2) := by refine cos_pos_of_mem_Ioo ⟨?_, ?_⟩ <;> linarith
state_before: x y : ℝ
hx₁ : -(π / 2) ≤ x
hy₂ : y ≤ π / 2
hxy : x < y
this✝ : 0 < sin ((y - x) / 2)
this : 0 < cos ((y + x) / 2)
⊢ 0 < 2 * sin ((y - x) / 2) * cos ((y + x) / 2)
state_after: no goals
tactic: positivity
Theorem: Set.pi_eq_empty
File: Mathlib/Data/Set/Prod.lean

Proof steps:
state_before: ι : Type u_1
α : ι → Type u_2
β : ι → Type u_3
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
i : ι
hs : i ∈ s
ht : t i = ∅
⊢ s.pi t = ∅
state_after: case h
ι : Type u_1
α : ι → Type u_2
β : ι → Type u_3
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
i : ι
hs : i ∈ s
ht : t i = ∅
f : (i : ι) → α i
⊢ f ∈ s.pi t ↔ f ∈ ∅
tactic: ext f
state_before: case h
ι : Type u_1
α : ι → Type u_2
β : ι → Type u_3
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
i : ι
hs : i ∈ s
ht : t i = ∅
f : (i : ι) → α i
⊢ f ∈ s.pi t ↔ f ∈ ∅
state_after: case h
ι : Type u_1
α : ι → Type u_2
β : ι → Type u_3
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
i : ι
hs : i ∈ s
ht : t i = ∅
f : (i : ι) → α i
⊢ ∃ x, ∃ (_ : x ∈ s), f x ∉ t x
tactic: simp only [mem_empty_iff_false, not_forall, iff_false_iff, mem_pi, Classical.not_imp]
state_before: case h
ι : Type u_1
α : ι → Type u_2
β : ι → Type u_3
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
i : ι
hs : i ∈ s
ht : t i = ∅
f : (i : ι) → α i
⊢ ∃ x, ∃ (_ : x ∈ s), f x ∉ t x
state_after: no goals
tactic: exact ⟨i, hs, by simp [ht]⟩
Theorem: IsUnit.inv_mul_cancel
File: Mathlib/Algebra/Group/Units.lean

Proof steps:
state_before: α : Type u
M : Type u_1
N : Type u_2
inst✝ : DivisionMonoid α
a b c : α
⊢ IsUnit a → a⁻¹ * a = 1
state_after: case intro
α : Type u
M : Type u_1
N : Type u_2
inst✝ : DivisionMonoid α
b c : α
u : αˣ
⊢ (↑u)⁻¹ * ↑u = 1
tactic: rintro ⟨u, rfl⟩
state_before: case intro
α : Type u
M : Type u_1
N : Type u_2
inst✝ : DivisionMonoid α
b c : α
u : αˣ
⊢ (↑u)⁻¹ * ↑u = 1
state_after: no goals
tactic: rw [← Units.val_inv_eq_inv_val, Units.inv_mul]
Theorem: Matrix.ker_mulVecLin_eq_bot_iff
File: Mathlib/LinearAlgebra/Matrix/ToLin.lean

Proof steps:
state_before: R : Type u_1
inst✝¹ : CommSemiring R
k : Type u_2
l : Type u_3
m : Type u_4
n : Type u_5
inst✝ : Fintype n
M : Matrix m n R
⊢ ker M.mulVecLin = ⊥ ↔ ∀ (v : n → R), M *ᵥ v = 0 → v = 0
state_after: no goals
tactic: simp only [Submodule.eq_bot_iff, LinearMap.mem_ker, Matrix.mulVecLin_apply]
Theorem: CategoryTheory.Limits.Fork.app_one_eq_ι_comp_right
File: Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : C
f g : X ⟶ Y
s : Fork f g
⊢ s.π.app one = s.ι ≫ g
state_after: no goals
tactic: rw [← s.app_zero_eq_ι, ← s.w right, parallelPair_map_right]
Theorem: Nat.xor_self
File: Mathlib/Data/Nat/Bitwise.lean

Proof steps:
state_before: n i : ℕ
⊢ (n ^^^ n).testBit i = false
state_after: no goals
tactic: simp
Theorem: Set.preimage_mul_const_Ico
File: Mathlib/Data/Set/Pointwise/Interval.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedField α
a✝ a b c : α
h : 0 < c
⊢ (fun x => x * c) ⁻¹' Ico a b = Ico (a / c) (b / c)
state_after: no goals
tactic: simp [← Ici_inter_Iio, h]
Theorem: Multiset.exists_mem_of_ne_zero
File: Mathlib/Data/Multiset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type v
γ : Type u_2
s : Multiset α
l✝ : List α
hl : Quot.mk Setoid.r l✝ ≠ 0
a : α
l : List α
x✝ : Quot.mk Setoid.r (a :: l) ≠ 0
⊢ a ∈ Quot.mk Setoid.r (a :: l)
state_after: no goals
tactic: simp
Theorem: AddCon.coe_iInf
File: Mathlib/GroupTheory/Congruence/Basic.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c : Con M
ι : Sort u_4
f : ι → Con M
⊢ ⇑(iInf f) = ⨅ i, ⇑(f i)
state_after: no goals
tactic: rw [iInf, coe_sInf, ← Set.range_comp, sInf_range, Function.comp]
Theorem: Orientation.rotation_map
File: Mathlib/Geometry/Euclidean/Angle/Oriented/Rotation.lean

Proof steps:
state_before: V : Type u_1
V' : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : NormedAddCommGroup V'
inst✝³ : InnerProductSpace ℝ V
inst✝² : InnerProductSpace ℝ V'
inst✝¹ : Fact (finrank ℝ V = 2)
inst✝ : Fact (finrank ℝ V' = 2)
o : Orientation ℝ V (Fin 2)
θ : Real.Angle
f : V ≃ₗᵢ[ℝ] V'
x : V'
⊢ (((map (Fin 2) f.toLinearEquiv) o).rotation θ) x = f ((o.rotation θ) (f.symm x))
state_after: no goals
tactic: simp [rotation_apply, o.rightAngleRotation_map]
Theorem: Matroid.map_comap
File: Mathlib/Data/Matroid/Map.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
f✝ : α → β
E I s : Set α
M : Matroid α
N : Matroid β
f : α → β
h_range : N.E ⊆ range f
hf : InjOn f (f ⁻¹' N.E)
⊢ (N.comap f).map f hf = N
state_after: α : Type u_1
β : Type u_2
f✝ : α → β
E I s : Set α
M : Matroid α
N : Matroid β
f : α → β
h_range : N.E ⊆ range f
hf : InjOn f (f ⁻¹' N.E)
⊢ ∀ I ⊆ ((N.comap f).map f hf).E, ((N.comap f).map f hf).Indep I ↔ N.Indep I
tactic: refine eq_of_indep_iff_indep_forall (by simpa [image_preimage_eq_iff]) ?_
state_before: α : Type u_1
β : Type u_2
f✝ : α → β
E I s : Set α
M : Matroid α
N : Matroid β
f : α → β
h_range : N.E ⊆ range f
hf : InjOn f (f ⁻¹' N.E)
⊢ ∀ I ⊆ ((N.comap f).map f hf).E, ((N.comap f).map f hf).Indep I ↔ N.Indep I
state_after: α : Type u_1
β : Type u_2
f✝ : α → β
E I s : Set α
M : Matroid α
N : Matroid β
f : α → β
h_range : N.E ⊆ range f
hf : InjOn f (f ⁻¹' N.E)
⊢ ∀ t ⊆ f ⁻¹' N.E, (∃ I₀, (N.Indep (f '' I₀) ∧ InjOn f I₀) ∧ f '' t = f '' I₀) ↔ N.Indep (f '' t)
tactic: simp only [map_ground, comap_ground_eq, map_indep_iff, comap_indep_iff, forall_subset_image_iff]
state_before: α : Type u_1
β : Type u_2
f✝ : α → β
E I s : Set α
M : Matroid α
N : Matroid β
f : α → β
h_range : N.E ⊆ range f
hf : InjOn f (f ⁻¹' N.E)
⊢ ∀ t ⊆ f ⁻¹' N.E, (∃ I₀, (N.Indep (f '' I₀) ∧ InjOn f I₀) ∧ f '' t = f '' I₀) ↔ N.Indep (f '' t)
state_after: α : Type u_1
β : Type u_2
f✝ : α → β
E I✝ s : Set α
M : Matroid α
N : Matroid β
f : α → β
h_range : N.E ⊆ range f
hf : InjOn f (f ⁻¹' N.E)
I : Set α
hI : I ⊆ f ⁻¹' N.E
x✝ : ∃ I₀, (N.Indep (f '' I₀) ∧ InjOn f I₀) ∧ f '' I = f '' I₀
I₀ : Set α
hI₀ : N.Indep (f '' I₀)
right✝ : InjOn f I₀
hII₀ : f '' I = f '' I₀
⊢ N.Indep (f '' I)
tactic: refine fun I hI ↦ ⟨fun ⟨I₀, ⟨hI₀, _⟩, hII₀⟩ ↦ ?_, fun h ↦ ⟨_, ⟨h, hf.mono hI⟩, rfl⟩⟩
state_before: α : Type u_1
β : Type u_2
f✝ : α → β
E I✝ s : Set α
M : Matroid α
N : Matroid β
f : α → β
h_range : N.E ⊆ range f
hf : InjOn f (f ⁻¹' N.E)
I : Set α
hI : I ⊆ f ⁻¹' N.E
x✝ : ∃ I₀, (N.Indep (f '' I₀) ∧ InjOn f I₀) ∧ f '' I = f '' I₀
I₀ : Set α
hI₀ : N.Indep (f '' I₀)
right✝ : InjOn f I₀
hII₀ : f '' I = f '' I₀
⊢ N.Indep (f '' I)
state_after: α : Type u_1
β : Type u_2
f✝ : α → β
E I✝ s : Set α
M : Matroid α
N : Matroid β
f : α → β
h_range : N.E ⊆ range f
hf : InjOn f (f ⁻¹' N.E)
I : Set α
hI : I ⊆ f ⁻¹' N.E
x✝ : ∃ I₀, (N.Indep (f '' I₀) ∧ InjOn f I₀) ∧ f '' I = f '' I₀
I₀ : Set α
hI₀ : N.Indep (f '' I₀)
right✝ : InjOn f I₀
hII₀ : f '' I = f '' I₀
⊢ I₀ ⊆ f ⁻¹' N.E
tactic: suffices h : I₀ ⊆ f ⁻¹' N.E by rw [InjOn.image_eq_image_iff hf hI h] at hII₀; rwa [hII₀]
state_before: α : Type u_1
β : Type u_2
f✝ : α → β
E I✝ s : Set α
M : Matroid α
N : Matroid β
f : α → β
h_range : N.E ⊆ range f
hf : InjOn f (f ⁻¹' N.E)
I : Set α
hI : I ⊆ f ⁻¹' N.E
x✝ : ∃ I₀, (N.Indep (f '' I₀) ∧ InjOn f I₀) ∧ f '' I = f '' I₀
I₀ : Set α
hI₀ : N.Indep (f '' I₀)
right✝ : InjOn f I₀
hII₀ : f '' I = f '' I₀
⊢ I₀ ⊆ f ⁻¹' N.E
state_after: no goals
tactic: exact (subset_preimage_image f I₀).trans <| preimage_mono (f := f) hI₀.subset_ground
Theorem: NormedRing.inverse_continuousAt
File: Mathlib/Analysis/Normed/Ring/Units.lean

Proof steps:
state_before: R : Type u_1
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
x : Rˣ
⊢ ContinuousAt inverse ↑x
state_after: R : Type u_1
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
x : Rˣ
h_is_o : (fun t => inverse (↑x + t) - ↑x⁻¹) =o[𝓝 0] fun x => 1
⊢ ContinuousAt inverse ↑x
tactic: have h_is_o : (fun t : R => inverse (↑x + t) - ↑x⁻¹) =o[𝓝 0] (fun _ => 1 : R → ℝ) :=
    (inverse_add_norm_diff_first_order x).trans_isLittleO (isLittleO_id_const one_ne_zero).norm_left
state_before: R : Type u_1
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
x : Rˣ
h_is_o : (fun t => inverse (↑x + t) - ↑x⁻¹) =o[𝓝 0] fun x => 1
⊢ ContinuousAt inverse ↑x
state_after: R : Type u_1
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
x : Rˣ
h_is_o : (fun t => inverse (↑x + t) - ↑x⁻¹) =o[𝓝 0] fun x => 1
h_lim : Tendsto (fun y => y - ↑x) (𝓝 ↑x) (𝓝 0)
⊢ ContinuousAt inverse ↑x
tactic: have h_lim : Tendsto (fun y : R => y - x) (𝓝 x) (𝓝 0) := by
    refine tendsto_zero_iff_norm_tendsto_zero.mpr ?_
    exact tendsto_iff_norm_sub_tendsto_zero.mp tendsto_id
state_before: R : Type u_1
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
x : Rˣ
h_is_o : (fun t => inverse (↑x + t) - ↑x⁻¹) =o[𝓝 0] fun x => 1
h_lim : Tendsto (fun y => y - ↑x) (𝓝 ↑x) (𝓝 0)
⊢ ContinuousAt inverse ↑x
state_after: R : Type u_1
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
x : Rˣ
h_is_o : (fun t => inverse (↑x + t) - ↑x⁻¹) =o[𝓝 0] fun x => 1
h_lim : Tendsto (fun y => y - ↑x) (𝓝 ↑x) (𝓝 0)
⊢ Tendsto (fun e => ‖inverse e - ↑x⁻¹‖) (𝓝 ↑x) (𝓝 0)
tactic: rw [ContinuousAt, tendsto_iff_norm_sub_tendsto_zero, inverse_unit]
Theorem: Fin.natCast_lt_natCast
File: Mathlib/Data/Fin/Basic.lean

Proof steps:
state_before: n m a b : ℕ
han : a ≤ n
hbn : b ≤ n
⊢ ↑a < ↑b ↔ a < b
state_after: n m a b : ℕ
han : a < n.succ
hbn : b < n.succ
⊢ ↑a < ↑b ↔ a < b
tactic: rw [← Nat.lt_succ_iff] at han hbn
state_before: n m a b : ℕ
han : a < n.succ
hbn : b < n.succ
⊢ ↑a < ↑b ↔ a < b
state_after: no goals
tactic: simp [lt_iff_val_lt_val, Nat.mod_eq_of_lt, han, hbn]
Theorem: ProjectiveSpectrum.isClosed_iff_zeroLocus
File: Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Topology.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
inst✝³ : CommSemiring R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
Z : Set (ProjectiveSpectrum 𝒜)
⊢ IsClosed Z ↔ ∃ s, Z = zeroLocus 𝒜 s
state_after: no goals
tactic: rw [← isOpen_compl_iff, isOpen_iff, compl_compl]
Theorem: Stream'.Seq.join_cons_nil
File: Mathlib/Data/Seq/Seq.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
a : α
S : Seq (Seq1 α)
⊢ (cons (a, nil) S).join.destruct = some (a, S.join)
state_after: no goals
tactic: simp [join]
Theorem: smul_inv_le_iff_of_neg
File: Mathlib/Algebra/Order/Module/Defs.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
a✝ a₁ a₂ : α
b b₁✝ b₂✝ : β
inst✝³ : LinearOrderedField α
inst✝² : OrderedAddCommGroup β
inst✝¹ : Module α β
a : α
b₁ b₂ : β
inst✝ : PosSMulMono α β
h : a < 0
⊢ b₁ ≤ a⁻¹ • b₂ ↔ b₂ ≤ a • b₁
state_after: no goals
tactic: rw [← smul_le_smul_iff_of_neg_left h, smul_inv_smul₀ h.ne]
Theorem: IsPrimitiveRoot.power_basis_int'_dim
File: Mathlib/NumberTheory/Cyclotomic/Rat.lean

Proof steps:
state_before: p : ℕ+
k : ℕ
K : Type u
inst✝¹ : Field K
inst✝ : CharZero K
ζ : K
hp : Fact (Nat.Prime ↑p)
hcycl : IsCyclotomicExtension {p} ℚ K
hζ : IsPrimitiveRoot ζ ↑p
⊢ hζ.integralPowerBasis'.dim = φ ↑p
state_after: no goals
tactic: erw [@integralPowerBasis_dim p 1 K _ _ _ _ (by convert hcycl; rw [pow_one]) (by rwa [pow_one]),
    pow_one]
Theorem: CategoryTheory.Localization.SmallHom.equiv_equiv_symm
File: Mathlib/CategoryTheory/Localization/SmallHom.lean

Proof steps:
state_before: C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
W : MorphismProperty C
D : Type u₂
inst✝⁴ : Category.{v₂, u₂} D
D' : Type u₃
inst✝³ : Category.{v₃, u₃} D'
L : C ⥤ D
inst✝² : L.IsLocalization W
L' : C ⥤ D'
inst✝¹ : L'.IsLocalization W
G : D ⥤ D'
e : L ⋙ G ≅ L'
X Y : C
inst✝ : HasSmallLocalizedHom W X Y
f : L.obj X ⟶ L.obj Y
⊢ (equiv W L') ((equiv W L).symm f) = e.inv.app X ≫ G.map f ≫ e.hom.app Y
state_after: C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
W : MorphismProperty C
D : Type u₂
inst✝⁴ : Category.{v₂, u₂} D
D' : Type u₃
inst✝³ : Category.{v₃, u₃} D'
L : C ⥤ D
inst✝² : L.IsLocalization W
L' : C ⥤ D'
inst✝¹ : L'.IsLocalization W
G : D ⥤ D'
e : L ⋙ G ≅ L'
X Y : C
inst✝ : HasSmallLocalizedHom W X Y
f : L.obj X ⟶ L.obj Y
⊢ (homEquiv W W.Q L')
      ((equivShrink (W.Q.obj X ⟶ W.Q.obj Y)).symm ((equivShrink (W.Q.obj X ⟶ W.Q.obj Y)) ((homEquiv W L W.Q) f))) =
    e.inv.app X ≫ G.map f ≫ e.hom.app Y
tactic: dsimp [equiv]
state_before: C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
W : MorphismProperty C
D : Type u₂
inst✝⁴ : Category.{v₂, u₂} D
D' : Type u₃
inst✝³ : Category.{v₃, u₃} D'
L : C ⥤ D
inst✝² : L.IsLocalization W
L' : C ⥤ D'
inst✝¹ : L'.IsLocalization W
G : D ⥤ D'
e : L ⋙ G ≅ L'
X Y : C
inst✝ : HasSmallLocalizedHom W X Y
f : L.obj X ⟶ L.obj Y
⊢ (homEquiv W W.Q L')
      ((equivShrink (W.Q.obj X ⟶ W.Q.obj Y)).symm ((equivShrink (W.Q.obj X ⟶ W.Q.obj Y)) ((homEquiv W L W.Q) f))) =
    e.inv.app X ≫ G.map f ≫ e.hom.app Y
state_after: C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
W : MorphismProperty C
D : Type u₂
inst✝⁴ : Category.{v₂, u₂} D
D' : Type u₃
inst✝³ : Category.{v₃, u₃} D'
L : C ⥤ D
inst✝² : L.IsLocalization W
L' : C ⥤ D'
inst✝¹ : L'.IsLocalization W
G : D ⥤ D'
e : L ⋙ G ≅ L'
X Y : C
inst✝ : HasSmallLocalizedHom W X Y
f : L.obj X ⟶ L.obj Y
⊢ (homEquiv W L L') f = e.inv.app X ≫ G.map f ≫ e.hom.app Y
tactic: rw [Equiv.symm_apply_apply, homEquiv_trans]
state_before: C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
W : MorphismProperty C
D : Type u₂
inst✝⁴ : Category.{v₂, u₂} D
D' : Type u₃
inst✝³ : Category.{v₃, u₃} D'
L : C ⥤ D
inst✝² : L.IsLocalization W
L' : C ⥤ D'
inst✝¹ : L'.IsLocalization W
G : D ⥤ D'
e : L ⋙ G ≅ L'
X Y : C
inst✝ : HasSmallLocalizedHom W X Y
f : L.obj X ⟶ L.obj Y
⊢ (homEquiv W L L') f = e.inv.app X ≫ G.map f ≫ e.hom.app Y
state_after: no goals
tactic: apply homEquiv_eq
Theorem: PadicInt.mem_nonunits
File: Mathlib/NumberTheory/Padics/PadicIntegers.lean

Proof steps:
state_before: p : ℕ
hp : Fact (Nat.Prime p)
z : ℤ_[p]
⊢ z ∈ nonunits ℤ_[p] ↔ ‖z‖ < 1
state_after: p : ℕ
hp : Fact (Nat.Prime p)
z : ℤ_[p]
⊢ z ∈ nonunits ℤ_[p] ↔ ‖z‖ ≤ 1 ∧ ‖z‖ ≠ 1
tactic: rw [lt_iff_le_and_ne]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
z : ℤ_[p]
⊢ z ∈ nonunits ℤ_[p] ↔ ‖z‖ ≤ 1 ∧ ‖z‖ ≠ 1
state_after: no goals
tactic: simp [norm_le_one z, nonunits, isUnit_iff]
Theorem: AlgebraicGeometry.quasiSeparatedSpace_iff_affine
File: Mathlib/AlgebraicGeometry/Morphisms/QuasiSeparated.lean

Proof steps:
state_before: X✝ Y : Scheme
f : X✝ ⟶ Y
X : Scheme
⊢ QuasiSeparatedSpace ↑↑X.toPresheafedSpace ↔ ∀ (U V : ↑X.affineOpens), IsCompact (↑↑U ∩ ↑↑V)
state_after: X✝ Y : Scheme
f : X✝ ⟶ Y
X : Scheme
⊢ (∀ (U V : Set ↑↑X.toPresheafedSpace), IsOpen U → IsCompact U → IsOpen V → IsCompact V → IsCompact (U ∩ V)) ↔
    ∀ (U V : ↑X.affineOpens), IsCompact (↑↑U ∩ ↑↑V)
tactic: rw [quasiSeparatedSpace_iff]
state_before: X✝ Y : Scheme
f : X✝ ⟶ Y
X : Scheme
⊢ (∀ (U V : Set ↑↑X.toPresheafedSpace), IsOpen U → IsCompact U → IsOpen V → IsCompact V → IsCompact (U ∩ V)) ↔
    ∀ (U V : ↑X.affineOpens), IsCompact (↑↑U ∩ ↑↑V)
state_after: case mp
X✝ Y : Scheme
f : X✝ ⟶ Y
X : Scheme
⊢ (∀ (U V : Set ↑↑X.toPresheafedSpace), IsOpen U → IsCompact U → IsOpen V → IsCompact V → IsCompact (U ∩ V)) →
    ∀ (U V : ↑X.affineOpens), IsCompact (↑↑U ∩ ↑↑V)

case mpr
X✝ Y : Scheme
f : X✝ ⟶ Y
X : Scheme
⊢ (∀ (U V : ↑X.affineOpens), IsCompact (↑↑U ∩ ↑↑V)) →
    ∀ (U V : Set ↑↑X.toPresheafedSpace), IsOpen U → IsCompact U → IsOpen V → IsCompact V → IsCompact (U ∩ V)
tactic: constructor
Theorem: FormalMultilinearSeries.order_zero
File: Mathlib/Analysis/Calculus/FormalMultilinearSeries.lean

Proof steps:
state_before: 𝕜 : Type u
𝕜' : Type u'
E : Type v
F : Type w
G : Type x
inst✝¹⁰ : Ring 𝕜
n : ℕ
inst✝⁹ : AddCommGroup E
inst✝⁸ : Module 𝕜 E
inst✝⁷ : TopologicalSpace E
inst✝⁶ : TopologicalAddGroup E
inst✝⁵ : ContinuousConstSMul 𝕜 E
inst✝⁴ : AddCommGroup F
inst✝³ : Module 𝕜 F
inst✝² : TopologicalSpace F
inst✝¹ : TopologicalAddGroup F
inst✝ : ContinuousConstSMul 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
⊢ order 0 = 0
state_after: no goals
tactic: simp [order]
Theorem: Ordinal.nadd_one
File: Mathlib/SetTheory/Ordinal/NaturalOps.lean

Proof steps:
state_before: a b c : Ordinal.{u}
⊢ a ♯ 1 = succ a
state_after: case h
a✝ b c a : Ordinal.{u}
IH : ∀ k < a, k ♯ 1 = succ k
⊢ a ♯ 1 = succ a
tactic: induction' a using Ordinal.induction with a IH
state_before: case h
a✝ b c a : Ordinal.{u}
IH : ∀ k < a, k ♯ 1 = succ k
⊢ a ♯ 1 = succ a
state_after: case h
a✝ b c a : Ordinal.{u}
IH : ∀ k < a, k ♯ 1 = succ k
⊢ ∀ i < a, i ♯ 1 < succ a
tactic: rw [nadd_def, blsub_one, nadd_zero, max_eq_right_iff, blsub_le_iff]
state_before: case h
a✝ b c a : Ordinal.{u}
IH : ∀ k < a, k ♯ 1 = succ k
⊢ ∀ i < a, i ♯ 1 < succ a
state_after: case h
a✝ b c a : Ordinal.{u}
IH : ∀ k < a, k ♯ 1 = succ k
i : Ordinal.{u}
hi : i < a
⊢ i ♯ 1 < succ a
tactic: intro i hi
state_before: case h
a✝ b c a : Ordinal.{u}
IH : ∀ k < a, k ♯ 1 = succ k
i : Ordinal.{u}
hi : i < a
⊢ i ♯ 1 < succ a
state_after: no goals
tactic: rwa [IH i hi, succ_lt_succ_iff]
Theorem: RingQuot.lift_unique
File: Mathlib/Algebra/RingQuot.lean

Proof steps:
state_before: R : Type uR
inst✝⁴ : Semiring R
S : Type uS
inst✝³ : CommSemiring S
T : Type uT
A : Type uA
inst✝² : Semiring A
inst✝¹ : Algebra S A
r✝ : R → R → Prop
inst✝ : Semiring T
f : R →+* T
r : R → R → Prop
w : ∀ ⦃x y : R⦄, r x y → f x = f y
g : RingQuot r →+* T
h : g.comp (mkRingHom r) = f
⊢ g = lift ⟨f, w⟩
state_after: case w.a
R : Type uR
inst✝⁴ : Semiring R
S : Type uS
inst✝³ : CommSemiring S
T : Type uT
A : Type uA
inst✝² : Semiring A
inst✝¹ : Algebra S A
r✝ : R → R → Prop
inst✝ : Semiring T
f : R →+* T
r : R → R → Prop
w : ∀ ⦃x y : R⦄, r x y → f x = f y
g : RingQuot r →+* T
h : g.comp (mkRingHom r) = f
x✝ : R
⊢ (g.comp (mkRingHom r)) x✝ = ((lift ⟨f, w⟩).comp (mkRingHom r)) x✝
tactic: ext
state_before: case w.a
R : Type uR
inst✝⁴ : Semiring R
S : Type uS
inst✝³ : CommSemiring S
T : Type uT
A : Type uA
inst✝² : Semiring A
inst✝¹ : Algebra S A
r✝ : R → R → Prop
inst✝ : Semiring T
f : R →+* T
r : R → R → Prop
w : ∀ ⦃x y : R⦄, r x y → f x = f y
g : RingQuot r →+* T
h : g.comp (mkRingHom r) = f
x✝ : R
⊢ (g.comp (mkRingHom r)) x✝ = ((lift ⟨f, w⟩).comp (mkRingHom r)) x✝
state_after: no goals
tactic: simp [h]
Theorem: CochainComplex.HomComplex.Cochain.sub_comp
File: Mathlib/Algebra/Homology/HomotopyCategory/HomComplex.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m n₁ n₂ n₁₂ : ℤ
z₁ z₁' : Cochain F G n₁
z₂ : Cochain G K n₂
h : n₁ + n₂ = n₁₂
⊢ (z₁ - z₁').comp z₂ h = z₁.comp z₂ h - z₁'.comp z₂ h
state_after: case h
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m n₁ n₂ n₁₂ : ℤ
z₁ z₁' : Cochain F G n₁
z₂ : Cochain G K n₂
h : n₁ + n₂ = n₁₂
p q : ℤ
hpq : p + n₁₂ = q
⊢ ((z₁ - z₁').comp z₂ h).v p q hpq = (z₁.comp z₂ h - z₁'.comp z₂ h).v p q hpq
tactic: ext p q hpq
state_before: case h
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m n₁ n₂ n₁₂ : ℤ
z₁ z₁' : Cochain F G n₁
z₂ : Cochain G K n₂
h : n₁ + n₂ = n₁₂
p q : ℤ
hpq : p + n₁₂ = q
⊢ ((z₁ - z₁').comp z₂ h).v p q hpq = (z₁.comp z₂ h - z₁'.comp z₂ h).v p q hpq
state_after: no goals
tactic: simp only [comp_v _ _ h p _ q rfl (by omega), sub_v, sub_comp]
Theorem: Real.Wallis.W_eq_factorial_ratio
File: Mathlib/Data/Real/Pi/Wallis.lean

Proof steps:
state_before: n : ℕ
⊢ W n = 2 ^ (4 * n) * ↑n ! ^ 4 / (↑(2 * n)! ^ 2 * (2 * ↑n + 1))
state_after: case zero

⊢ W 0 = 2 ^ (4 * 0) * ↑0! ^ 4 / (↑(2 * 0)! ^ 2 * (2 * ↑0 + 1))

case succ
n : ℕ
IH : W n = 2 ^ (4 * n) * ↑n ! ^ 4 / (↑(2 * n)! ^ 2 * (2 * ↑n + 1))
⊢ W (n + 1) = 2 ^ (4 * (n + 1)) * ↑(n + 1)! ^ 4 / (↑(2 * (n + 1))! ^ 2 * (2 * ↑(n + 1) + 1))
tactic: induction' n with n IH
Theorem: DomAddAct.vadd_Lp_sub
File: Mathlib/MeasureTheory/Function/LpSpace/DomAct/Basic.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
α : Type u_3
E : Type u_4
inst✝⁶ : MeasurableSpace M
inst✝⁵ : MeasurableSpace N
inst✝⁴ : MeasurableSpace α
inst✝³ : NormedAddCommGroup E
μ : Measure α
p : ℝ≥0∞
inst✝² : SMul M α
inst✝¹ : SMulInvariantMeasure M α μ
inst✝ : MeasurableSMul M α
c : Mᵈᵐᵃ
⊢ ∀ (f g : ↥(Lp E p μ)), c • (f - g) = c • f - c • g
state_after: case mk.mk.mk.mk
M : Type u_1
N : Type u_2
α : Type u_3
E : Type u_4
inst✝⁶ : MeasurableSpace M
inst✝⁵ : MeasurableSpace N
inst✝⁴ : MeasurableSpace α
inst✝³ : NormedAddCommGroup E
μ : Measure α
p : ℝ≥0∞
inst✝² : SMul M α
inst✝¹ : SMulInvariantMeasure M α μ
inst✝ : MeasurableSMul M α
c : Mᵈᵐᵃ
val✝¹ : α →ₘ[μ] E
a✝¹ : { f // AEStronglyMeasurable f μ }
property✝¹ : Quot.mk Setoid.r a✝¹ ∈ Lp E p μ
val✝ : α →ₘ[μ] E
a✝ : { f // AEStronglyMeasurable f μ }
property✝ : Quot.mk Setoid.r a✝ ∈ Lp E p μ
⊢ c • (⟨Quot.mk Setoid.r a✝¹, property✝¹⟩ - ⟨Quot.mk Setoid.r a✝, property✝⟩) =
    c • ⟨Quot.mk Setoid.r a✝¹, property✝¹⟩ - c • ⟨Quot.mk Setoid.r a✝, property✝⟩
tactic: rintro ⟨⟨⟩, _⟩ ⟨⟨⟩, _⟩
state_before: case mk.mk.mk.mk
M : Type u_1
N : Type u_2
α : Type u_3
E : Type u_4
inst✝⁶ : MeasurableSpace M
inst✝⁵ : MeasurableSpace N
inst✝⁴ : MeasurableSpace α
inst✝³ : NormedAddCommGroup E
μ : Measure α
p : ℝ≥0∞
inst✝² : SMul M α
inst✝¹ : SMulInvariantMeasure M α μ
inst✝ : MeasurableSMul M α
c : Mᵈᵐᵃ
val✝¹ : α →ₘ[μ] E
a✝¹ : { f // AEStronglyMeasurable f μ }
property✝¹ : Quot.mk Setoid.r a✝¹ ∈ Lp E p μ
val✝ : α →ₘ[μ] E
a✝ : { f // AEStronglyMeasurable f μ }
property✝ : Quot.mk Setoid.r a✝ ∈ Lp E p μ
⊢ c • (⟨Quot.mk Setoid.r a✝¹, property✝¹⟩ - ⟨Quot.mk Setoid.r a✝, property✝⟩) =
    c • ⟨Quot.mk Setoid.r a✝¹, property✝¹⟩ - c • ⟨Quot.mk Setoid.r a✝, property✝⟩
state_after: no goals
tactic: rfl
Theorem: AlgebraicGeometry.exists_sigmaι_eq
File: Mathlib/AlgebraicGeometry/Limits.lean

Proof steps:
state_before: ι : Type u
f : ι → Scheme
x : ↑↑(∐ f).toPresheafedSpace
⊢ ∃ i y, (Sigma.ι f i).val.base y = x
state_after: case intro.intro
ι : Type u
f : ι → Scheme
x : ↑↑(∐ f).toPresheafedSpace
i : (disjointGlueData f).J
y : ↑↑((disjointGlueData f).U i).toPresheafedSpace
e : ((disjointGlueData f).ι i).val.base y = (sigmaIsoGlued f).hom.val.base x
⊢ ∃ i y, (Sigma.ι f i).val.base y = x
tactic: obtain ⟨i, y, e⟩ := (disjointGlueData f).ι_jointly_surjective ((sigmaIsoGlued f).hom.1.base x)
state_before: case intro.intro
ι : Type u
f : ι → Scheme
x : ↑↑(∐ f).toPresheafedSpace
i : (disjointGlueData f).J
y : ↑↑((disjointGlueData f).U i).toPresheafedSpace
e : ((disjointGlueData f).ι i).val.base y = (sigmaIsoGlued f).hom.val.base x
⊢ ∃ i y, (Sigma.ι f i).val.base y = x
state_after: case intro.intro
ι : Type u
f : ι → Scheme
x : ↑↑(∐ f).toPresheafedSpace
i : (disjointGlueData f).J
y : ↑↑((disjointGlueData f).U i).toPresheafedSpace
e : ((disjointGlueData f).ι i).val.base y = (sigmaIsoGlued f).hom.val.base x
⊢ (sigmaIsoGlued f).hom.val.base ((Sigma.ι f i).val.base y) = (sigmaIsoGlued f).hom.val.base x
tactic: refine ⟨i, y, (sigmaIsoGlued f).hom.openEmbedding.inj ?_⟩
state_before: case intro.intro
ι : Type u
f : ι → Scheme
x : ↑↑(∐ f).toPresheafedSpace
i : (disjointGlueData f).J
y : ↑↑((disjointGlueData f).U i).toPresheafedSpace
e : ((disjointGlueData f).ι i).val.base y = (sigmaIsoGlued f).hom.val.base x
⊢ (sigmaIsoGlued f).hom.val.base ((Sigma.ι f i).val.base y) = (sigmaIsoGlued f).hom.val.base x
state_after: no goals
tactic: rwa [← Scheme.comp_val_base_apply, ι_sigmaIsoGlued_hom]