ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: IsUnifLocDoublingMeasure.vitaliFamily_def
File: Mathlib/MeasureTheory/Covering/DensityTheorem.lean

Proof steps:
state_before: α : Type u_1
inst✝⁵ : MetricSpace α
inst✝⁴ : MeasurableSpace α
μ : Measure α
inst✝³ : IsUnifLocDoublingMeasure μ
inst✝² : SecondCountableTopology α
inst✝¹ : BorelSpace α
inst✝ : IsLocallyFiniteMeasure μ
K : ℝ
⊢ VitaliFamily μ
state_after: α : Type u_1
inst✝⁵ : MetricSpace α
inst✝⁴ : MeasurableSpace α
μ : Measure α
inst✝³ : IsUnifLocDoublingMeasure μ
inst✝² : SecondCountableTopology α
inst✝¹ : BorelSpace α
inst✝ : IsLocallyFiniteMeasure μ
K : ℝ
R : ℝ := scalingScaleOf μ (max (4 * K + 3) 3)
⊢ VitaliFamily μ
tactic: let R := scalingScaleOf μ (max (4 * K + 3) 3)
state_before: α : Type u_1
inst✝⁵ : MetricSpace α
inst✝⁴ : MeasurableSpace α
μ : Measure α
inst✝³ : IsUnifLocDoublingMeasure μ
inst✝² : SecondCountableTopology α
inst✝¹ : BorelSpace α
inst✝ : IsLocallyFiniteMeasure μ
K : ℝ
R : ℝ := scalingScaleOf μ (max (4 * K + 3) 3)
⊢ VitaliFamily μ
state_after: α : Type u_1
inst✝⁵ : MetricSpace α
inst✝⁴ : MeasurableSpace α
μ : Measure α
inst✝³ : IsUnifLocDoublingMeasure μ
inst✝² : SecondCountableTopology α
inst✝¹ : BorelSpace α
inst✝ : IsLocallyFiniteMeasure μ
K : ℝ
R : ℝ := scalingScaleOf μ (max (4 * K + 3) 3)
Rpos : 0 < R
⊢ VitaliFamily μ
tactic: have Rpos : 0 < R := scalingScaleOf_pos _ _
state_before: α : Type u_1
inst✝⁵ : MetricSpace α
inst✝⁴ : MeasurableSpace α
μ : Measure α
inst✝³ : IsUnifLocDoublingMeasure μ
inst✝² : SecondCountableTopology α
inst✝¹ : BorelSpace α
inst✝ : IsLocallyFiniteMeasure μ
K : ℝ
R : ℝ := scalingScaleOf μ (max (4 * K + 3) 3)
Rpos : 0 < R
⊢ VitaliFamily μ
state_after: α : Type u_1
inst✝⁵ : MetricSpace α
inst✝⁴ : MeasurableSpace α
μ : Measure α
inst✝³ : IsUnifLocDoublingMeasure μ
inst✝² : SecondCountableTopology α
inst✝¹ : BorelSpace α
inst✝ : IsLocallyFiniteMeasure μ
K : ℝ
R : ℝ := scalingScaleOf μ (max (4 * K + 3) 3)
Rpos : 0 < R
A :
  ∀ (x : α),
    ∃ᶠ (r : ℝ) in 𝓝[>] 0, μ (closedBall x (3 * r)) ≤ ↑(scalingConstantOf μ (max (4 * K + 3) 3)) * μ (closedBall x r)
⊢ VitaliFamily μ
tactic: have A : ∀ x : α, ∃ᶠ r in 𝓝[>] (0 : ℝ),
      μ (closedBall x (3 * r)) ≤ scalingConstantOf μ (max (4 * K + 3) 3) * μ (closedBall x r) := by
    intro x
    apply frequently_iff.2 fun {U} hU => ?_
    obtain ⟨ε, εpos, hε⟩ := mem_nhdsWithin_Ioi_iff_exists_Ioc_subset.1 hU
    refine ⟨min ε R, hε ⟨lt_min εpos Rpos, min_le_left _ _⟩, ?_⟩
    exact measure_mul_le_scalingConstantOf_mul μ
      ⟨zero_lt_three, le_max_right _ _⟩ (min_le_right _ _)
state_before: α : Type u_1
inst✝⁵ : MetricSpace α
inst✝⁴ : MeasurableSpace α
μ : Measure α
inst✝³ : IsUnifLocDoublingMeasure μ
inst✝² : SecondCountableTopology α
inst✝¹ : BorelSpace α
inst✝ : IsLocallyFiniteMeasure μ
K : ℝ
R : ℝ := scalingScaleOf μ (max (4 * K + 3) 3)
Rpos : 0 < R
A :
  ∀ (x : α),
    ∃ᶠ (r : ℝ) in 𝓝[>] 0, μ (closedBall x (3 * r)) ≤ ↑(scalingConstantOf μ (max (4 * K + 3) 3)) * μ (closedBall x r)
⊢ VitaliFamily μ
state_after: no goals
tactic: exact (Vitali.vitaliFamily μ (scalingConstantOf μ (max (4 * K + 3) 3)) A).enlarge (R / 4)
    (by linarith)
Theorem: Nat.dvd_left_iff_eq
File: Mathlib/Data/Nat/Defs.lean

Proof steps:
state_before: a b c d m n✝ k : ℕ
p q : ℕ → Prop
h : m = n✝
n : ℕ
⊢ n ∣ m ↔ n ∣ n✝
state_after: no goals
tactic: rw [h]
Theorem: Associates.irreducible_mk
File: Mathlib/Algebra/Associated/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CommMonoidWithZero α
a : α
⊢ Irreducible (Associates.mk a) ↔ Irreducible a
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CommMonoidWithZero α
a : α
⊢ (¬IsUnit a ∧ ∀ (a_1 a_2 : α), a_1 * a_2 ~ᵤ a → IsUnit a_1 ∨ IsUnit a_2) ↔
    ¬IsUnit a ∧ ∀ (a_1 b : α), a = a_1 * b → IsUnit a_1 ∨ IsUnit b
tactic: simp only [irreducible_iff, isUnit_mk, forall_associated, isUnit_mk, mk_mul_mk,
    mk_eq_mk_iff_associated, Associated.comm (x := a)]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CommMonoidWithZero α
a : α
⊢ (¬IsUnit a ∧ ∀ (a_1 a_2 : α), a_1 * a_2 ~ᵤ a → IsUnit a_1 ∨ IsUnit a_2) ↔
    ¬IsUnit a ∧ ∀ (a_1 b : α), a = a_1 * b → IsUnit a_1 ∨ IsUnit b
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CommMonoidWithZero α
a : α
⊢ (∀ (a_1 a_2 : α), a_1 * a_2 ~ᵤ a → IsUnit a_1 ∨ IsUnit a_2) ↔ ∀ (a_1 b : α), a = a_1 * b → IsUnit a_1 ∨ IsUnit b
tactic: apply Iff.rfl.and
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CommMonoidWithZero α
a : α
⊢ (∀ (a_1 a_2 : α), a_1 * a_2 ~ᵤ a → IsUnit a_1 ∨ IsUnit a_2) ↔ ∀ (a_1 b : α), a = a_1 * b → IsUnit a_1 ∨ IsUnit b
state_after: case mp
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CommMonoidWithZero α
a : α
⊢ (∀ (a_1 a_2 : α), a_1 * a_2 ~ᵤ a → IsUnit a_1 ∨ IsUnit a_2) → ∀ (a_2 b : α), a = a_2 * b → IsUnit a_2 ∨ IsUnit b

case mpr
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CommMonoidWithZero α
a : α
⊢ (∀ (a_1 b : α), a = a_1 * b → IsUnit a_1 ∨ IsUnit b) → ∀ (a_2 a_3 : α), a_2 * a_3 ~ᵤ a → IsUnit a_2 ∨ IsUnit a_3
tactic: constructor
Theorem: MvQPF.Cofix.dest_mk
File: Mathlib/Data/QPF/Multivariate/Constructions/Cofix.lean

Proof steps:
state_before: n : ℕ
F : TypeVec.{u} (n + 1) → Type u
q : MvQPF F
α : TypeVec.{u} n
x : F (α ::: Cofix F α)
⊢ (mk x).dest = x
state_after: n : ℕ
F : TypeVec.{u} (n + 1) → Type u
q : MvQPF F
α : TypeVec.{u} n
x : F (α ::: Cofix F α)
this : mk ∘ dest = _root_.id
⊢ (mk x).dest = x
tactic: have : Cofix.mk ∘ Cofix.dest = @_root_.id (Cofix F α) := funext Cofix.mk_dest
state_before: n : ℕ
F : TypeVec.{u} (n + 1) → Type u
q : MvQPF F
α : TypeVec.{u} n
x : F (α ::: Cofix F α)
this : mk ∘ dest = _root_.id
⊢ (mk x).dest = x
state_after: no goals
tactic: rw [Cofix.mk, Cofix.dest_corec, ← comp_map, ← Cofix.mk, ← appendFun_comp, this, id_comp,
    appendFun_id_id, MvFunctor.id_map]
Theorem: Filter.pi_eq_bot
File: Mathlib/Order/Filter/Pi.lean

Proof steps:
state_before: ι : Type u_1
α : ι → Type u_2
f f₁ f₂ : (i : ι) → Filter (α i)
s : (i : ι) → Set (α i)
p : (i : ι) → α i → Prop
⊢ pi f = ⊥ ↔ ∃ i, f i = ⊥
state_after: no goals
tactic: simpa using @pi_inf_principal_univ_pi_eq_bot ι α f fun _ => univ
Theorem: GenContFract.nums_stable_of_terminated
File: Mathlib/Algebra/ContinuedFractions/TerminatedStable.lean

Proof steps:
state_before: K : Type u_1
g : GenContFract K
n m : ℕ
inst✝ : DivisionRing K
n_le_m : n ≤ m
terminatedAt_n : g.TerminatedAt n
⊢ g.nums m = g.nums n
state_after: no goals
tactic: simp only [num_eq_conts_a, conts_stable_of_terminated n_le_m terminatedAt_n]
Theorem: Field.primitive_element_iff_minpoly_natDegree_eq
File: Mathlib/FieldTheory/PrimitiveElement.lean

Proof steps:
state_before: F✝ : Type u_1
E✝ : Type u_2
inst✝⁸ : Field F✝
inst✝⁷ : Field E✝
inst✝⁶ : Algebra F✝ E✝
inst✝⁵ : FiniteDimensional F✝ E✝
inst✝⁴ : Algebra.IsSeparable F✝ E✝
F : Type u_3
E : Type u_4
inst✝³ : Field F
inst✝² : Field E
inst✝¹ : Algebra F E
inst✝ : FiniteDimensional F E
α : E
⊢ F⟮α⟯ = ⊤ ↔ (minpoly F α).natDegree = finrank F E
state_after: F✝ : Type u_1
E✝ : Type u_2
inst✝⁸ : Field F✝
inst✝⁷ : Field E✝
inst✝⁶ : Algebra F✝ E✝
inst✝⁵ : FiniteDimensional F✝ E✝
inst✝⁴ : Algebra.IsSeparable F✝ E✝
F : Type u_3
E : Type u_4
inst✝³ : Field F
inst✝² : Field E
inst✝¹ : Algebra F E
inst✝ : FiniteDimensional F E
α : E
⊢ F⟮α⟯ = ⊤ ↔ finrank F ↥F⟮α⟯ = finrank F ↥⊤
tactic: rw [← adjoin.finrank (IsIntegral.of_finite F α), ← finrank_top F E]
state_before: F✝ : Type u_1
E✝ : Type u_2
inst✝⁸ : Field F✝
inst✝⁷ : Field E✝
inst✝⁶ : Algebra F✝ E✝
inst✝⁵ : FiniteDimensional F✝ E✝
inst✝⁴ : Algebra.IsSeparable F✝ E✝
F : Type u_3
E : Type u_4
inst✝³ : Field F
inst✝² : Field E
inst✝¹ : Algebra F E
inst✝ : FiniteDimensional F E
α : E
⊢ F⟮α⟯ = ⊤ ↔ finrank F ↥F⟮α⟯ = finrank F ↥⊤
state_after: F✝ : Type u_1
E✝ : Type u_2
inst✝⁸ : Field F✝
inst✝⁷ : Field E✝
inst✝⁶ : Algebra F✝ E✝
inst✝⁵ : FiniteDimensional F✝ E✝
inst✝⁴ : Algebra.IsSeparable F✝ E✝
F : Type u_3
E : Type u_4
inst✝³ : Field F
inst✝² : Field E
inst✝¹ : Algebra F E
inst✝ : FiniteDimensional F E
α : E
h : F⟮α⟯ = ⊤
⊢ finrank F ↥F⟮α⟯ = finrank F ↥⊤
tactic: refine ⟨fun h => ?_, fun h => eq_of_le_of_finrank_eq le_top h⟩
state_before: F✝ : Type u_1
E✝ : Type u_2
inst✝⁸ : Field F✝
inst✝⁷ : Field E✝
inst✝⁶ : Algebra F✝ E✝
inst✝⁵ : FiniteDimensional F✝ E✝
inst✝⁴ : Algebra.IsSeparable F✝ E✝
F : Type u_3
E : Type u_4
inst✝³ : Field F
inst✝² : Field E
inst✝¹ : Algebra F E
inst✝ : FiniteDimensional F E
α : E
h : F⟮α⟯ = ⊤
⊢ finrank F ↥F⟮α⟯ = finrank F ↥⊤
state_after: no goals
tactic: exact congr_arg (fun K : IntermediateField F E => finrank F K) h
Theorem: PSigma.ext_iff
File: Mathlib/Data/Sigma/Basic.lean

Proof steps:
state_before: α : Sort u_1
β : α → Sort u_2
x₀ x₁ : PSigma β
⊢ x₀ = x₁ ↔ x₀.fst = x₁.fst ∧ HEq x₀.snd x₁.snd
state_after: case mk
α : Sort u_1
β : α → Sort u_2
x₁ : PSigma β
fst✝ : α
snd✝ : β fst✝
⊢ ⟨fst✝, snd✝⟩ = x₁ ↔ ⟨fst✝, snd✝⟩.fst = x₁.fst ∧ HEq ⟨fst✝, snd✝⟩.snd x₁.snd
tactic: cases x₀
state_before: case mk
α : Sort u_1
β : α → Sort u_2
x₁ : PSigma β
fst✝ : α
snd✝ : β fst✝
⊢ ⟨fst✝, snd✝⟩ = x₁ ↔ ⟨fst✝, snd✝⟩.fst = x₁.fst ∧ HEq ⟨fst✝, snd✝⟩.snd x₁.snd
state_after: case mk.mk
α : Sort u_1
β : α → Sort u_2
fst✝¹ : α
snd✝¹ : β fst✝¹
fst✝ : α
snd✝ : β fst✝
⊢ ⟨fst✝¹, snd✝¹⟩ = ⟨fst✝, snd✝⟩ ↔ ⟨fst✝¹, snd✝¹⟩.fst = ⟨fst✝, snd✝⟩.fst ∧ HEq ⟨fst✝¹, snd✝¹⟩.snd ⟨fst✝, snd✝⟩.snd
tactic: cases x₁
state_before: case mk.mk
α : Sort u_1
β : α → Sort u_2
fst✝¹ : α
snd✝¹ : β fst✝¹
fst✝ : α
snd✝ : β fst✝
⊢ ⟨fst✝¹, snd✝¹⟩ = ⟨fst✝, snd✝⟩ ↔ ⟨fst✝¹, snd✝¹⟩.fst = ⟨fst✝, snd✝⟩.fst ∧ HEq ⟨fst✝¹, snd✝¹⟩.snd ⟨fst✝, snd✝⟩.snd
state_after: no goals
tactic: exact PSigma.mk.inj_iff
Theorem: RingHom.map_range
File: Mathlib/Algebra/Ring/Subring/Basic.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
inst✝² : Ring R
inst✝¹ : Ring S
inst✝ : Ring T
g : S →+* T
f : R →+* S
⊢ Subring.map g f.range = (g.comp f).range
state_after: no goals
tactic: simpa only [range_eq_map] using (⊤ : Subring R).map_map g f
Theorem: HurwitzZeta.sinKernel_neg
File: Mathlib/NumberTheory/LSeries/HurwitzZetaOdd.lean

Proof steps:
state_before: a : UnitAddCircle
x : ℝ
⊢ sinKernel (-a) x = -sinKernel a x
state_after: case H
x a' : ℝ
⊢ sinKernel (-↑a') x = -sinKernel (↑a') x
tactic: induction' a using QuotientAddGroup.induction_on' with a'
state_before: case H
x a' : ℝ
⊢ sinKernel (-↑a') x = -sinKernel (↑a') x
state_after: no goals
tactic: rw [← ofReal_inj, ← QuotientAddGroup.mk_neg, ofReal_neg, sinKernel_def, sinKernel_def, ofReal_neg,
    jacobiTheta₂'_neg_left, neg_div]
Theorem: ZMod.intCast_eq_intCast_iff_dvd_sub
File: Mathlib/Data/ZMod/Basic.lean

Proof steps:
state_before: m n : ℕ
a b : ℤ
c : ℕ
⊢ ↑a = ↑b ↔ ↑c ∣ b - a
state_after: no goals
tactic: rw [ZMod.intCast_eq_intCast_iff, Int.modEq_iff_dvd]
Theorem: Monoid.Foldl.ofFreeMonoid_apply
File: Mathlib/Control/Fold.lean

Proof steps:
state_before: m : Type u → Type u
inst✝ : Monad m
α β : Type u
f : β → α → β
⊢ ∀ (x y : FreeMonoid α),
    { toFun := fun xs => op (flip (List.foldl f) (FreeMonoid.toList xs)), map_one' := ⋯ }.toFun (x * y) =
      { toFun := fun xs => op (flip (List.foldl f) (FreeMonoid.toList xs)), map_one' := ⋯ }.toFun x *
        { toFun := fun xs => op (flip (List.foldl f) (FreeMonoid.toList xs)), map_one' := ⋯ }.toFun y
state_after: m : Type u → Type u
inst✝ : Monad m
α β : Type u
f : β → α → β
x✝ y✝ : FreeMonoid α
⊢ { toFun := fun xs => op (flip (List.foldl f) (FreeMonoid.toList xs)), map_one' := ⋯ }.toFun (x✝ * y✝) =
    { toFun := fun xs => op (flip (List.foldl f) (FreeMonoid.toList xs)), map_one' := ⋯ }.toFun x✝ *
      { toFun := fun xs => op (flip (List.foldl f) (FreeMonoid.toList xs)), map_one' := ⋯ }.toFun y✝
tactic: intros
state_before: m : Type u → Type u
inst✝ : Monad m
α β : Type u
f : β → α → β
x✝ y✝ : FreeMonoid α
⊢ { toFun := fun xs => op (flip (List.foldl f) (FreeMonoid.toList xs)), map_one' := ⋯ }.toFun (x✝ * y✝) =
    { toFun := fun xs => op (flip (List.foldl f) (FreeMonoid.toList xs)), map_one' := ⋯ }.toFun x✝ *
      { toFun := fun xs => op (flip (List.foldl f) (FreeMonoid.toList xs)), map_one' := ⋯ }.toFun y✝
state_after: m : Type u → Type u
inst✝ : Monad m
α β : Type u
f : β → α → β
x✝ y✝ : FreeMonoid α
⊢ (op fun a => List.foldl f (List.foldl f a (FreeMonoid.toList x✝)) (FreeMonoid.toList y✝)) =
    (op fun a => List.foldl f a (FreeMonoid.toList x✝)) * op fun a => List.foldl f a (FreeMonoid.toList y✝)
tactic: simp only [FreeMonoid.toList_mul, unop_op, List.foldl_append, op_inj, Function.flip_def,
      List.foldl_append]
state_before: m : Type u → Type u
inst✝ : Monad m
α β : Type u
f : β → α → β
x✝ y✝ : FreeMonoid α
⊢ (op fun a => List.foldl f (List.foldl f a (FreeMonoid.toList x✝)) (FreeMonoid.toList y✝)) =
    (op fun a => List.foldl f a (FreeMonoid.toList x✝)) * op fun a => List.foldl f a (FreeMonoid.toList y✝)
state_after: no goals
tactic: rfl
Theorem: eq_zero_of_zero_eq_one
File: Mathlib/Algebra/GroupWithZero/Basic.lean

Proof steps:
state_before: α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝ : MulZeroOneClass M₀
h : 0 = 1
a : M₀
⊢ a = 0
state_after: no goals
tactic: rw [← mul_one a, ← h, mul_zero]
Theorem: Computation.LiftRelAux.swap
File: Mathlib/Data/Seq/Computation.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
R✝ : α → β → Prop
C✝ : Computation α → Computation β → Prop
R : α → β → Prop
C : Computation α → Computation β → Prop
a : α ⊕ Computation α
b : β ⊕ Computation β
⊢ LiftRelAux (Function.swap R) (Function.swap C) b a = LiftRelAux R C a b
state_after: no goals
tactic: cases' a with a ca <;> cases' b with b cb <;> simp only [LiftRelAux]
Theorem: CliffordAlgebra.submodule_map_mul_reverse
File: Mathlib/LinearAlgebra/CliffordAlgebra/Conjugation.lean

Proof steps:
state_before: R : Type u_1
inst✝² : CommRing R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
p q : Submodule R (CliffordAlgebra Q)
⊢ Submodule.map reverse (p * q) = Submodule.map reverse q * Submodule.map reverse p
state_after: no goals
tactic: simp_rw [reverse, Submodule.map_comp, Submodule.map_mul, Submodule.map_unop_mul]
Theorem: min_le_of_add_le_two_nsmul
File: Mathlib/Algebra/Order/Monoid/Unbundled/Pow.lean

Proof steps:
state_before: β : Type u_1
G : Type u_2
M : Type u_3
inst✝³ : Monoid M
inst✝² : LinearOrder M
inst✝¹ : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : CovariantClass M M (swap fun x x_1 => x * x_1) fun x x_1 => x < x_1
a b c : M
h : a * b ≤ c ^ 2
⊢ min a b ≤ c
state_after: no goals
tactic: simpa using min_le_max_of_mul_le_mul (h.trans_eq <| pow_two _)
Theorem: AlgebraicGeometry.Polynomial.imageOfDf_eq_comap_C_compl_zeroLocus
File: Mathlib/AlgebraicGeometry/PrimeSpectrum/IsOpenComapC.lean

Proof steps:
state_before: R : Type u_1
inst✝ : CommRing R
f : R[X]
⊢ imageOfDf f = ⇑(PrimeSpectrum.comap C) '' (zeroLocus {f})ᶜ
state_after: case h
R : Type u_1
inst✝ : CommRing R
f : R[X]
x : PrimeSpectrum R
⊢ x ∈ imageOfDf f ↔ x ∈ ⇑(PrimeSpectrum.comap C) '' (zeroLocus {f})ᶜ
tactic: ext x
state_before: case h
R : Type u_1
inst✝ : CommRing R
f : R[X]
x : PrimeSpectrum R
⊢ x ∈ imageOfDf f ↔ x ∈ ⇑(PrimeSpectrum.comap C) '' (zeroLocus {f})ᶜ
state_after: case h.refine_1
R : Type u_1
inst✝ : CommRing R
f : R[X]
x : PrimeSpectrum R
hx : x ∈ imageOfDf f
⊢ { asIdeal := Ideal.map C x.asIdeal, isPrime := ⋯ } ∈ (zeroLocus {f})ᶜ

case h.refine_2
R : Type u_1
inst✝ : CommRing R
f : R[X]
x : PrimeSpectrum R
hx : x ∈ imageOfDf f
⊢ (PrimeSpectrum.comap C) { asIdeal := Ideal.map C x.asIdeal, isPrime := ⋯ } = x

case h.refine_3
R : Type u_1
inst✝ : CommRing R
f : R[X]
x : PrimeSpectrum R
⊢ x ∈ ⇑(PrimeSpectrum.comap C) '' (zeroLocus {f})ᶜ → x ∈ imageOfDf f
tactic: refine ⟨fun hx => ⟨⟨map C x.asIdeal, isPrime_map_C_of_isPrime x.isPrime⟩, ⟨?_, ?_⟩⟩, ?_⟩
Theorem: Polynomial.le_trailingDegree_monomial
File: Mathlib/Algebra/Polynomial/Degree/TrailingDegree.lean

Proof steps:
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
this : DecidableEq R := Classical.decEq R
ha : a = 0
⊢ ↑n ≤ ((monomial n) a).trailingDegree
state_after: no goals
tactic: simp [ha]
Theorem: EReal.coe_abs
File: Mathlib/Data/Real/EReal.lean

Proof steps:
state_before: x : ℝ
⊢ ↑(↑x).abs = ↑|x|
state_after: x : ℝ
⊢ ↑↑(Real.nnabs x) = ↑↑(Real.nnabs x)
tactic: rw [abs_def, ← Real.coe_nnabs, ENNReal.ofReal_coe_nnreal]
state_before: x : ℝ
⊢ ↑↑(Real.nnabs x) = ↑↑(Real.nnabs x)
state_after: no goals
tactic: rfl
Theorem: CategoryTheory.ComposableArrows.isComplex₀
File: Mathlib/Algebra/Homology/ExactSequence.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : HasZeroMorphisms C
n : ℕ
S✝ : ComposableArrows C n
S : ComposableArrows C 0
i : ℕ
hi : autoParam (i + 2 ≤ 0) _auto✝
⊢ S.map' i (i + 1) ⋯ ⋯ ≫ S.map' (i + 1) (i + 2) ⋯ hi = 0
state_after: no goals
tactic: simp (config := {decide := true}) at hi
Theorem: TopCat.Presheaf.SheafConditionPairwiseIntersections.coneEquivUnitIsoApp_hom_hom
File: Mathlib/Topology/Sheaves/SheafCondition/EqualizerProducts.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasProducts C
X : TopCat
F : Presheaf C X
ι : Type v'
U : ι → Opens ↑X
c : Cone ((diagram U).op ⋙ F)
j : (CategoryTheory.Pairwise ι)ᵒᵖ
⊢ 𝟙 ((𝟭 (Cone ((diagram U).op ⋙ F))).obj c).pt ≫ ((coneEquivFunctor F U ⋙ coneEquivInverse F U).obj c).π.app j =
    ((𝟭 (Cone ((diagram U).op ⋙ F))).obj c).π.app j
state_after: case h
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasProducts C
X : TopCat
F : Presheaf C X
ι : Type v'
U : ι → Opens ↑X
c : Cone ((diagram U).op ⋙ F)
j : CategoryTheory.Pairwise ι
⊢ 𝟙 ((𝟭 (Cone ((diagram U).op ⋙ F))).obj c).pt ≫ ((coneEquivFunctor F U ⋙ coneEquivInverse F U).obj c).π.app (op j) =
    ((𝟭 (Cone ((diagram U).op ⋙ F))).obj c).π.app (op j)
tactic: induction j using Opposite.rec' with | h j => ?_
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasProducts C
X : TopCat
F : Presheaf C X
ι : Type v'
U : ι → Opens ↑X
c : Cone ((diagram U).op ⋙ F)
j : (CategoryTheory.Pairwise ι)ᵒᵖ
⊢ 𝟙 ((coneEquivFunctor F U ⋙ coneEquivInverse F U).obj c).pt ≫ ((𝟭 (Cone ((diagram U).op ⋙ F))).obj c).π.app j =
    ((coneEquivFunctor F U ⋙ coneEquivInverse F U).obj c).π.app j
state_after: case h
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasProducts C
X : TopCat
F : Presheaf C X
ι : Type v'
U : ι → Opens ↑X
c : Cone ((diagram U).op ⋙ F)
j : CategoryTheory.Pairwise ι
⊢ 𝟙 ((coneEquivFunctor F U ⋙ coneEquivInverse F U).obj c).pt ≫ ((𝟭 (Cone ((diagram U).op ⋙ F))).obj c).π.app (op j) =
    ((coneEquivFunctor F U ⋙ coneEquivInverse F U).obj c).π.app (op j)
tactic: induction j using Opposite.rec' with | h j => ?_
Theorem: mem_omegaLimit_iff_frequently
File: Mathlib/Dynamics/OmegaLimit.lean

Proof steps:
state_before: τ : Type u_1
α : Type u_2
β : Type u_3
ι : Type u_4
inst✝ : TopologicalSpace β
f : Filter τ
ϕ : τ → α → β
s s₁ s₂ : Set α
y : β
⊢ y ∈ ω f ϕ s ↔ ∀ n ∈ 𝓝 y, ∃ᶠ (t : τ) in f, (s ∩ ϕ t ⁻¹' n).Nonempty
state_after: τ : Type u_1
α : Type u_2
β : Type u_3
ι : Type u_4
inst✝ : TopologicalSpace β
f : Filter τ
ϕ : τ → α → β
s s₁ s₂ : Set α
y : β
⊢ (∀ i ∈ f, ∀ t ∈ 𝓝 y, (t ∩ image2 ϕ i s).Nonempty) ↔
    ∀ n ∈ 𝓝 y, ∀ {U : Set τ}, U ∈ f → ∃ x ∈ U, (s ∩ ϕ x ⁻¹' n).Nonempty
tactic: simp_rw [frequently_iff, omegaLimit_def, mem_iInter, mem_closure_iff_nhds]
state_before: τ : Type u_1
α : Type u_2
β : Type u_3
ι : Type u_4
inst✝ : TopologicalSpace β
f : Filter τ
ϕ : τ → α → β
s s₁ s₂ : Set α
y : β
⊢ (∀ i ∈ f, ∀ t ∈ 𝓝 y, (t ∩ image2 ϕ i s).Nonempty) ↔
    ∀ n ∈ 𝓝 y, ∀ {U : Set τ}, U ∈ f → ∃ x ∈ U, (s ∩ ϕ x ⁻¹' n).Nonempty
state_after: case mp
τ : Type u_1
α : Type u_2
β : Type u_3
ι : Type u_4
inst✝ : TopologicalSpace β
f : Filter τ
ϕ : τ → α → β
s s₁ s₂ : Set α
y : β
⊢ (∀ i ∈ f, ∀ t ∈ 𝓝 y, (t ∩ image2 ϕ i s).Nonempty) →
    ∀ n ∈ 𝓝 y, ∀ {U : Set τ}, U ∈ f → ∃ x ∈ U, (s ∩ ϕ x ⁻¹' n).Nonempty

case mpr
τ : Type u_1
α : Type u_2
β : Type u_3
ι : Type u_4
inst✝ : TopologicalSpace β
f : Filter τ
ϕ : τ → α → β
s s₁ s₂ : Set α
y : β
⊢ (∀ n ∈ 𝓝 y, ∀ {U : Set τ}, U ∈ f → ∃ x ∈ U, (s ∩ ϕ x ⁻¹' n).Nonempty) →
    ∀ i ∈ f, ∀ t ∈ 𝓝 y, (t ∩ image2 ϕ i s).Nonempty
tactic: constructor
Theorem: Mathlib.Tactic.NoncommRing.nat_lit_mul_eq_nsmul
File: Mathlib/Tactic/NoncommRing.lean

Proof steps:
state_before: R : Type u_1
inst✝¹ : NonAssocSemiring R
r : R
n : ℕ
inst✝ : n.AtLeastTwo
⊢ OfNat.ofNat n * r = n • r
state_after: no goals
tactic: simp only [nsmul_eq_mul, Nat.cast_eq_ofNat]
Theorem: Module.eval_ker
File: Mathlib/LinearAlgebra/Dual.lean

Proof steps:
state_before: K : Type uK
V : Type uV
inst✝³ : CommRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : Free K V
⊢ ker (eval K V) = ⊥
state_after: no goals
tactic: classical exact (Module.Free.chooseBasis K V).eval_ker
Theorem: AddCommGroup.DirectLimit.map_id
File: Mathlib/Algebra/DirectLimit.lean

Proof steps:
state_before: R : Type u
inst✝⁷ : Ring R
ι : Type v
inst✝⁶ : Preorder ι
G : ι → Type w
inst✝⁵ : DecidableEq ι
inst✝⁴ : (i : ι) → AddCommGroup (G i)
f : (i j : ι) → i ≤ j → G i →+ G j
P : Type u₁
inst✝³ : AddCommGroup P
g : (i : ι) → G i →+ P
Hg : ∀ (i j : ι) (hij : i ≤ j) (x : G i), (g j) ((f i j hij) x) = (g i) x
G' : ι → Type v'
inst✝² : (i : ι) → AddCommGroup (G' i)
f' : (i j : ι) → i ≤ j → G' i →+ G' j
G'' : ι → Type v''
inst✝¹ : (i : ι) → AddCommGroup (G'' i)
f'' : (i j : ι) → i ≤ j → G'' i →+ G'' j
inst✝ : IsDirected ι fun x x_1 => x ≤ x_1
x : DirectLimit G f
⊢ IsEmpty ι → (map (fun i => AddMonoidHom.id (G i)) ⋯) x = (AddMonoidHom.id (DirectLimit G f)) x
state_after: no goals
tactic: subsingleton
state_before: R : Type u
inst✝⁷ : Ring R
ι : Type v
inst✝⁶ : Preorder ι
G : ι → Type w
inst✝⁵ : DecidableEq ι
inst✝⁴ : (i : ι) → AddCommGroup (G i)
f : (i j : ι) → i ≤ j → G i →+ G j
P : Type u₁
inst✝³ : AddCommGroup P
g✝ : (i : ι) → G i →+ P
Hg : ∀ (i j : ι) (hij : i ≤ j) (x : G i), (g✝ j) ((f i j hij) x) = (g✝ i) x
G' : ι → Type v'
inst✝² : (i : ι) → AddCommGroup (G' i)
f' : (i j : ι) → i ≤ j → G' i →+ G' j
G'' : ι → Type v''
inst✝¹ : (i : ι) → AddCommGroup (G'' i)
f'' : (i j : ι) → i ≤ j → G'' i →+ G'' j
inst✝ : IsDirected ι fun x x_1 => x ≤ x_1
x : DirectLimit G f
x✝ : Nonempty ι
i : ι
g : G i
⊢ (map (fun i => AddMonoidHom.id (G i)) ⋯) ((of G f i) g) = (AddMonoidHom.id (DirectLimit G f)) ((of G f i) g)
state_after: no goals
tactic: simp
Theorem: Orientation.oangle_eq_zero_iff_angle_eq_zero
File: Mathlib/Geometry/Euclidean/Angle/Oriented/Basic.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)
x y : V
hx : x ≠ 0
hy : y ≠ 0
⊢ o.oangle x y = 0 ↔ InnerProductGeometry.angle x y = 0
state_after: case refine_1
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)
x y : V
hx : x ≠ 0
hy : y ≠ 0
h : o.oangle x y = 0
⊢ InnerProductGeometry.angle x y = 0

case refine_2
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)
x y : V
hx : x ≠ 0
hy : y ≠ 0
h : InnerProductGeometry.angle x y = 0
⊢ o.oangle x y = 0
tactic: refine ⟨fun h => ?_, fun h => ?_⟩
Theorem: wbtw_one_zero_iff
File: Mathlib/Analysis/Convex/Between.lean

Proof steps:
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁶ : OrderedRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x : R
⊢ Wbtw R 1 x 0 ↔ x ∈ Set.Icc 0 1
state_after: no goals
tactic: rw [wbtw_comm, wbtw_zero_one_iff]