ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Polynomial.Monic.irreducible_iff_natDegree'
File: Mathlib/Algebra/Polynomial/RingDivision.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommSemiring R
inst✝ : NoZeroDivisors R
p q : R[X]
hp : p.Monic
⊢ Irreducible p ↔ p ≠ 1 ∧ ∀ (f g : R[X]), f.Monic → g.Monic → f * g = p → g.natDegree ∉ Ioc 0 (p.natDegree / 2)
state_after: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommSemiring R
inst✝ : NoZeroDivisors R
p q : R[X]
hp : p.Monic
⊢ (p ≠ 1 ∧ ∀ (f g : R[X]), f.Monic → g.Monic → f * g = p → f.natDegree = 0 ∨ g.natDegree = 0) ↔
    p ≠ 1 ∧ ∀ (f g : R[X]), f.Monic → g.Monic → f * g = p → ¬(0 < g.natDegree ∧ g.natDegree + g.natDegree ≤ p.natDegree)
tactic: simp_rw [hp.irreducible_iff_natDegree, mem_Ioc, Nat.le_div_iff_mul_le zero_lt_two, mul_two]
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommSemiring R
inst✝ : NoZeroDivisors R
p q : R[X]
hp : p.Monic
⊢ (p ≠ 1 ∧ ∀ (f g : R[X]), f.Monic → g.Monic → f * g = p → f.natDegree = 0 ∨ g.natDegree = 0) ↔
    p ≠ 1 ∧ ∀ (f g : R[X]), f.Monic → g.Monic → f * g = p → ¬(0 < g.natDegree ∧ g.natDegree + g.natDegree ≤ p.natDegree)
state_after: case h
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommSemiring R
inst✝ : NoZeroDivisors R
p q : R[X]
hp : p.Monic
⊢ (∀ (f g : R[X]), f.Monic → g.Monic → f * g = p → f.natDegree = 0 ∨ g.natDegree = 0) ↔
    ∀ (f g : R[X]), f.Monic → g.Monic → f * g = p → ¬(0 < g.natDegree ∧ g.natDegree + g.natDegree ≤ p.natDegree)
tactic: apply and_congr_right'
state_before: case h
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommSemiring R
inst✝ : NoZeroDivisors R
p q : R[X]
hp : p.Monic
⊢ (∀ (f g : R[X]), f.Monic → g.Monic → f * g = p → f.natDegree = 0 ∨ g.natDegree = 0) ↔
    ∀ (f g : R[X]), f.Monic → g.Monic → f * g = p → ¬(0 < g.natDegree ∧ g.natDegree + g.natDegree ≤ p.natDegree)
state_after: case h.mp
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommSemiring R
inst✝ : NoZeroDivisors R
q f g : R[X]
hf : f.Monic
hg : g.Monic
hp : (f * g).Monic
h : ∀ (f_1 g_1 : R[X]), f_1.Monic → g_1.Monic → f_1 * g_1 = f * g → f_1.natDegree = 0 ∨ g_1.natDegree = 0
⊢ ¬(0 < g.natDegree ∧ g.natDegree + g.natDegree ≤ (f * g).natDegree)

case h.mpr
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommSemiring R
inst✝ : NoZeroDivisors R
q f g : R[X]
hf : f.Monic
hg : g.Monic
hp : (f * g).Monic
h :
  ∀ (f_1 g_1 : R[X]),
    f_1.Monic → g_1.Monic → f_1 * g_1 = f * g → ¬(0 < g_1.natDegree ∧ g_1.natDegree + g_1.natDegree ≤ (f * g).natDegree)
⊢ f.natDegree = 0 ∨ g.natDegree = 0
tactic: constructor <;> intro h f g hf hg he <;> subst he
Theorem: PerfectionMap.lift_apply
File: Mathlib/RingTheory/Perfection.lean

Proof steps:
state_before: p : ℕ
inst✝¹¹ : Fact (Nat.Prime p)
R : Type u₁
inst✝¹⁰ : CommSemiring R
inst✝⁹ : CharP R p
P✝ : Type u₃
inst✝⁸ : CommSemiring P✝
inst✝⁷ : CharP P✝ p
inst✝⁶ : PerfectRing P✝ p
inst✝⁵ : PerfectRing R p
S : Type u₂
inst✝⁴ : CommSemiring S
inst✝³ : CharP S p
P : Type u₃
inst✝² : CommSemiring P
inst✝¹ : CharP P p
inst✝ : PerfectRing P p
π : P →+* S
m : PerfectionMap p π
f : R →+* S
⊢ (fun f => π.comp f) ((fun f => (↑m.equiv.symm).comp ((Perfection.lift p R S) f)) f) = f
state_after: p : ℕ
inst✝¹¹ : Fact (Nat.Prime p)
R : Type u₁
inst✝¹⁰ : CommSemiring R
inst✝⁹ : CharP R p
P✝ : Type u₃
inst✝⁸ : CommSemiring P✝
inst✝⁷ : CharP P✝ p
inst✝⁶ : PerfectRing P✝ p
inst✝⁵ : PerfectRing R p
S : Type u₂
inst✝⁴ : CommSemiring S
inst✝³ : CharP S p
P : Type u₃
inst✝² : CommSemiring P
inst✝¹ : CharP P p
inst✝ : PerfectRing P p
π : P →+* S
m : PerfectionMap p π
f : R →+* S
⊢ (Perfection.coeff S p 0).comp ((Perfection.lift p R S) f) = f
tactic: simp_rw [← RingHom.comp_assoc, comp_symm_equiv']
state_before: p : ℕ
inst✝¹¹ : Fact (Nat.Prime p)
R : Type u₁
inst✝¹⁰ : CommSemiring R
inst✝⁹ : CharP R p
P✝ : Type u₃
inst✝⁸ : CommSemiring P✝
inst✝⁷ : CharP P✝ p
inst✝⁶ : PerfectRing P✝ p
inst✝⁵ : PerfectRing R p
S : Type u₂
inst✝⁴ : CommSemiring S
inst✝³ : CharP S p
P : Type u₃
inst✝² : CommSemiring P
inst✝¹ : CharP P p
inst✝ : PerfectRing P p
π : P →+* S
m : PerfectionMap p π
f : R →+* S
⊢ (Perfection.coeff S p 0).comp ((Perfection.lift p R S) f) = f
state_after: no goals
tactic: exact (Perfection.lift p R S).symm_apply_apply f
state_before: p : ℕ
inst✝¹¹ : Fact (Nat.Prime p)
R : Type u₁
inst✝¹⁰ : CommSemiring R
inst✝⁹ : CharP R p
P✝ : Type u₃
inst✝⁸ : CommSemiring P✝
inst✝⁷ : CharP P✝ p
inst✝⁶ : PerfectRing P✝ p
inst✝⁵ : PerfectRing R p
S : Type u₂
inst✝⁴ : CommSemiring S
inst✝³ : CharP S p
P : Type u₃
inst✝² : CommSemiring P
inst✝¹ : CharP P p
inst✝ : PerfectRing P p
π : P →+* S
m : PerfectionMap p π
f : R →+* P
⊢ (fun f => (↑m.equiv.symm).comp ((Perfection.lift p R S) f)) ((fun f => π.comp f) f) = f
state_after: no goals
tactic: exact RingHom.ext fun x => m.equiv.injective <| (m.equiv.apply_symm_apply _).trans
      <| show Perfection.lift p R S (π.comp f) x = RingHom.comp (↑m.equiv) f x from
        RingHom.ext_iff.1 (by rw [Equiv.apply_eq_iff_eq_symm_apply]; rfl) _
Theorem: neg_one_pow_mul_eq_zero_iff
File: Mathlib/Algebra/Ring/Commute.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝ : Ring R
a b : R
n : ℕ
⊢ (-1) ^ n * a = 0 ↔ a = 0
state_after: no goals
tactic: rcases neg_one_pow_eq_or R n with h | h <;> simp [h]
Theorem: Ordnode.raised_iff
File: Mathlib/Data/Ordmap/Ordset.lean

Proof steps:
state_before: α : Type u_1
n m : ℕ
⊢ Raised n m ↔ n ≤ m ∧ m ≤ n + 1
state_after: case mp
α : Type u_1
n m : ℕ
⊢ Raised n m → n ≤ m ∧ m ≤ n + 1

case mpr
α : Type u_1
n m : ℕ
⊢ n ≤ m ∧ m ≤ n + 1 → Raised n m
tactic: constructor
Theorem: Cardinal.mk_embedding_eq_arrow_of_lift_le
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

Proof steps:
state_before: α β : Type u
β' : Type v
inst✝ : Infinite α
lle : lift.{u, v} #β' ≤ lift.{v, u} #α
⊢ #(β' → α) ≤ #(β' ↪ α)
state_after: α β : Type u
β' : Type v
inst✝ : Infinite α
lle : lift.{u, v} #β' ≤ lift.{v, u} #α
⊢ #(β' → α) ≤ #(β' ↪ α × α)
tactic: conv_rhs => rw [← (Equiv.embeddingCongr (.refl _)
      (Cardinal.eq.mp <| mul_eq_self <| aleph0_le_mk α).some).cardinal_eq]
state_before: α β : Type u
β' : Type v
inst✝ : Infinite α
lle : lift.{u, v} #β' ≤ lift.{v, u} #α
⊢ #(β' → α) ≤ #(β' ↪ α × α)
state_after: case intro
α β : Type u
β' : Type v
inst✝ : Infinite α
lle : lift.{u, v} #β' ≤ lift.{v, u} #α
e : β' ↪ α
⊢ #(β' → α) ≤ #(β' ↪ α × α)
tactic: obtain ⟨e⟩ := lift_mk_le'.mp lle
state_before: case intro
α β : Type u
β' : Type v
inst✝ : Infinite α
lle : lift.{u, v} #β' ≤ lift.{v, u} #α
e : β' ↪ α
⊢ #(β' → α) ≤ #(β' ↪ α × α)
state_after: no goals
tactic: exact ⟨⟨fun f ↦ ⟨fun b ↦ ⟨e b, f b⟩, fun _ _ h ↦ e.injective congr(Prod.fst $h)⟩,
      fun f g h ↦ funext fun b ↦ congr(Prod.snd <| $h b)⟩⟩
Theorem: MeasureTheory.Content.empty
File: Mathlib/MeasureTheory/Measure/Content.lean

Proof steps:
state_before: G : Type w
inst✝ : TopologicalSpace G
μ : Content G
⊢ (fun s => ↑(μ.toFun s)) ⊥ = 0
state_after: G : Type w
inst✝ : TopologicalSpace G
μ : Content G
this : Disjoint ↑⊥ ↑⊥ → IsClosed ↑⊥ → IsClosed ↑⊥ → μ.toFun (⊥ ⊔ ⊥) = μ.toFun ⊥ + μ.toFun ⊥
⊢ (fun s => ↑(μ.toFun s)) ⊥ = 0
tactic: have := μ.sup_disjoint' ⊥ ⊥
state_before: G : Type w
inst✝ : TopologicalSpace G
μ : Content G
this : Disjoint ↑⊥ ↑⊥ → IsClosed ↑⊥ → IsClosed ↑⊥ → μ.toFun (⊥ ⊔ ⊥) = μ.toFun ⊥ + μ.toFun ⊥
⊢ (fun s => ↑(μ.toFun s)) ⊥ = 0
state_after: no goals
tactic: simpa [apply_eq_coe_toFun] using this
Theorem: Complex.log_inv_eq_integral
File: Mathlib/Analysis/SpecialFunctions/Complex/LogBounds.lean

Proof steps:
state_before: z : ℂ
hz : 1 - z ∈ slitPlane
⊢ log (1 - z)⁻¹ = z * ∫ (t : ℝ) in 0 ..1, (1 - t • z)⁻¹
state_after: z : ℂ
hz : 1 + -z ∈ slitPlane
⊢ log (1 + -z)⁻¹ = z * ∫ (t : ℝ) in 0 ..1, (1 - t • z)⁻¹
tactic: rw [sub_eq_add_neg 1 z] at hz ⊢
state_before: z : ℂ
hz : 1 + -z ∈ slitPlane
⊢ log (1 + -z)⁻¹ = z * ∫ (t : ℝ) in 0 ..1, (1 - t • z)⁻¹
state_after: z : ℂ
hz : 1 + -z ∈ slitPlane
⊢ log (1 + -z) = -z * ∫ (t : ℝ) in 0 ..1, (1 - t • z)⁻¹
tactic: rw [log_inv _ <| slitPlane_arg_ne_pi hz, neg_eq_iff_eq_neg, ← neg_mul]
state_before: z : ℂ
hz : 1 + -z ∈ slitPlane
⊢ log (1 + -z) = -z * ∫ (t : ℝ) in 0 ..1, (1 - t • z)⁻¹
state_after: case h.e'_3.h.e'_6.h.e'_4.h.h.e'_3
z : ℂ
hz : 1 + -z ∈ slitPlane
x✝ : ℝ
⊢ 1 - x✝ • z = 1 + x✝ • -z
tactic: convert log_eq_integral hz using 5
state_before: case h.e'_3.h.e'_6.h.e'_4.h.h.e'_3
z : ℂ
hz : 1 + -z ∈ slitPlane
x✝ : ℝ
⊢ 1 - x✝ • z = 1 + x✝ • -z
state_after: no goals
tactic: rw [sub_eq_add_neg, smul_neg]
Theorem: Part.Fix.approx_le_fix
File: Mathlib/Control/LawfulFix.lean

Proof steps:
state_before: α : Type u_1
β : α → Type u_2
f : ((a : α) → Part (β a)) →o (a : α) → Part (β a)
i : ℕ
a : α
b : β a
hh : b ∈ approx (⇑f) i a
⊢ b ∈ Part.fix (⇑f) a
state_after: α : Type u_1
β : α → Type u_2
f : ((a : α) → Part (β a)) →o (a : α) → Part (β a)
i : ℕ
a : α
b : β a
hh : b ∈ approx (⇑f) i a
⊢ ∃ i, b ∈ approx (⇑f) i a
tactic: rw [mem_iff f]
state_before: α : Type u_1
β : α → Type u_2
f : ((a : α) → Part (β a)) →o (a : α) → Part (β a)
i : ℕ
a : α
b : β a
hh : b ∈ approx (⇑f) i a
⊢ ∃ i, b ∈ approx (⇑f) i a
state_after: no goals
tactic: exact ⟨_, hh⟩
Theorem: Filter.principal_singleton
File: Mathlib/Order/Filter/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l : Filter α
a : α
s : Set α
⊢ s ∈ 𝓟 {a} ↔ s ∈ pure a
state_after: no goals
tactic: simp only [mem_pure, mem_principal, singleton_subset_iff]
Theorem: CategoryTheory.MonoidalFunctor.mapAction_μ_inv_hom
File: Mathlib/RepresentationTheory/Action/Monoidal.lean

Proof steps:
state_before: V : Type (u + 1)
inst✝³ : LargeCategory V
G✝ : MonCat
W : Type (u + 1)
inst✝² : LargeCategory W
inst✝¹ : MonoidalCategory V
inst✝ : MonoidalCategory W
F : MonoidalFunctor V W
G : MonCat
X Y : Action V G
⊢ (inv ((F.mapAction G).μ X Y)).hom = inv (F.μ X.V Y.V)
state_after: no goals
tactic: rw [← cancel_mono (F.μ X.V Y.V), IsIso.inv_hom_id, ← F.mapAction_toLaxMonoidalFunctor_μ_hom G,
    ← Action.comp_hom, IsIso.inv_hom_id, Action.id_hom]
Theorem: LinearIndependent.cardinal_le_rank
File: Mathlib/LinearAlgebra/Dimension/Basic.lean

Proof steps:
state_before: R : Type u
R' : Type u'
M M₁ : Type v
M' : Type v'
inst✝¹⁰ : Ring R
inst✝⁹ : Ring R'
inst✝⁸ : AddCommGroup M
inst✝⁷ : AddCommGroup M'
inst✝⁶ : AddCommGroup M₁
inst✝⁵ : Module R M
inst✝⁴ : Module R M'
inst✝³ : Module R M₁
inst✝² : Module R' M'
inst✝¹ : Module R' M₁
inst✝ : Nontrivial R
ι : Type v
v : ι → M
hv : LinearIndependent R v
⊢ #ι ≤ Module.rank R M
state_after: no goals
tactic: simpa using hv.cardinal_lift_le_rank
Theorem: SimpleGraph.Walk.cons_isTrail_iff
File: Mathlib/Combinatorics/SimpleGraph/Path.lean

Proof steps:
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u✝ v✝ w✝ u v w : V
h : G.Adj u v
p : G.Walk v w
⊢ (cons h p).IsTrail ↔ p.IsTrail ∧ s(u, v) ∉ p.edges
state_after: no goals
tactic: simp [isTrail_def, and_comm]
Theorem: Complex.sin_add_pi_div_two
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

Proof steps:
state_before: x : ℂ
⊢ sin (x + ↑π / 2) = cos x
state_after: no goals
tactic: simp [sin_add]
Theorem: SimpleGraph.fromEdgeSet_univ
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

Proof steps:
state_before: ι : Sort u_1
V : Type u
G : SimpleGraph V
a b c u v w : V
e : Sym2 V
s : Set (Sym2 V)
⊢ fromEdgeSet Set.univ = ⊤
state_after: case Adj.h.h.a
ι : Sort u_1
V : Type u
G : SimpleGraph V
a b c u v✝ w✝ : V
e : Sym2 V
s : Set (Sym2 V)
v w : V
⊢ (fromEdgeSet Set.univ).Adj v w ↔ ⊤.Adj v w
tactic: ext v w
state_before: case Adj.h.h.a
ι : Sort u_1
V : Type u
G : SimpleGraph V
a b c u v✝ w✝ : V
e : Sym2 V
s : Set (Sym2 V)
v w : V
⊢ (fromEdgeSet Set.univ).Adj v w ↔ ⊤.Adj v w
state_after: no goals
tactic: simp only [fromEdgeSet_adj, Set.mem_univ, true_and_iff, top_adj]
Theorem: HasFDerivWithinAt.hasFDerivAt
File: Mathlib/Analysis/Calculus/FDeriv/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
h : HasFDerivWithinAt f f' s x
hs : s ∈ 𝓝 x
⊢ HasFDerivAt f f' x
state_after: no goals
tactic: rwa [← univ_inter s, hasFDerivWithinAt_inter hs, hasFDerivWithinAt_univ] at h
Theorem: ball_sub
File: Mathlib/Analysis/Normed/Group/Pointwise.lean

Proof steps:
state_before: E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s t : Set E
x y : E
⊢ ball x δ / s = x • thickening δ s⁻¹
state_after: no goals
tactic: simp [div_eq_mul_inv]
Theorem: Set.compl_iUnion₂
File: Mathlib/Data/Set/Lattice.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
s : (i : ι) → κ i → Set α
⊢ (⋃ i, ⋃ j, s i j)ᶜ = ⋂ i, ⋂ j, (s i j)ᶜ
state_after: no goals
tactic: simp_rw [compl_iUnion]
Theorem: totallyBounded_union
File: Mathlib/Topology/UniformSpace/Cauchy.lean

Proof steps:
state_before: α : Type u
β : Type v
uniformSpace : UniformSpace α
s t : Set α
⊢ TotallyBounded (s ∪ t) ↔ TotallyBounded s ∧ TotallyBounded t
state_after: α : Type u
β : Type v
uniformSpace : UniformSpace α
s t : Set α
⊢ (∀ (i : Bool), TotallyBounded (bif i then s else t)) ↔ TotallyBounded s ∧ TotallyBounded t
tactic: rw [union_eq_iUnion, totallyBounded_iUnion]
state_before: α : Type u
β : Type v
uniformSpace : UniformSpace α
s t : Set α
⊢ (∀ (i : Bool), TotallyBounded (bif i then s else t)) ↔ TotallyBounded s ∧ TotallyBounded t
state_after: no goals
tactic: simp [and_comm]
Theorem: zsmul_mem
File: Mathlib/Algebra/Group/Subgroup/Basic.lean

Proof steps:
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁵ : Group G
inst✝⁴ : Group G'
inst✝³ : Group G''
A : Type u_4
inst✝² : AddGroup A
M : Type u_5
S : Type u_6
inst✝¹ : DivInvMonoid M
inst✝ : SetLike S M
hSM : SubgroupClass S M
H K : S
x : M
hx : x ∈ K
n : ℕ
⊢ x ^ ↑n ∈ K
state_after: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁵ : Group G
inst✝⁴ : Group G'
inst✝³ : Group G''
A : Type u_4
inst✝² : AddGroup A
M : Type u_5
S : Type u_6
inst✝¹ : DivInvMonoid M
inst✝ : SetLike S M
hSM : SubgroupClass S M
H K : S
x : M
hx : x ∈ K
n : ℕ
⊢ x ^ n ∈ K
tactic: rw [zpow_natCast]
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁵ : Group G
inst✝⁴ : Group G'
inst✝³ : Group G''
A : Type u_4
inst✝² : AddGroup A
M : Type u_5
S : Type u_6
inst✝¹ : DivInvMonoid M
inst✝ : SetLike S M
hSM : SubgroupClass S M
H K : S
x : M
hx : x ∈ K
n : ℕ
⊢ x ^ n ∈ K
state_after: no goals
tactic: exact pow_mem hx n
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁵ : Group G
inst✝⁴ : Group G'
inst✝³ : Group G''
A : Type u_4
inst✝² : AddGroup A
M : Type u_5
S : Type u_6
inst✝¹ : DivInvMonoid M
inst✝ : SetLike S M
hSM : SubgroupClass S M
H K : S
x : M
hx : x ∈ K
n : ℕ
⊢ x ^ -[n+1] ∈ K
state_after: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁵ : Group G
inst✝⁴ : Group G'
inst✝³ : Group G''
A : Type u_4
inst✝² : AddGroup A
M : Type u_5
S : Type u_6
inst✝¹ : DivInvMonoid M
inst✝ : SetLike S M
hSM : SubgroupClass S M
H K : S
x : M
hx : x ∈ K
n : ℕ
⊢ (x ^ (n + 1))⁻¹ ∈ K
tactic: rw [zpow_negSucc]
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁵ : Group G
inst✝⁴ : Group G'
inst✝³ : Group G''
A : Type u_4
inst✝² : AddGroup A
M : Type u_5
S : Type u_6
inst✝¹ : DivInvMonoid M
inst✝ : SetLike S M
hSM : SubgroupClass S M
H K : S
x : M
hx : x ∈ K
n : ℕ
⊢ (x ^ (n + 1))⁻¹ ∈ K
state_after: no goals
tactic: exact inv_mem (pow_mem hx n.succ)
Theorem: isAlgebraic_one
File: Mathlib/RingTheory/Algebraic.lean

Proof steps:
state_before: R : Type u
S : Type u_1
A : Type v
inst✝⁷ : CommRing R
inst✝⁶ : CommRing S
inst✝⁵ : Ring A
inst✝⁴ : Algebra R A
inst✝³ : Algebra R S
inst✝² : Algebra S A
inst✝¹ : IsScalarTower R S A
inst✝ : Nontrivial R
⊢ IsAlgebraic R 1
state_after: R : Type u
S : Type u_1
A : Type v
inst✝⁷ : CommRing R
inst✝⁶ : CommRing S
inst✝⁵ : Ring A
inst✝⁴ : Algebra R A
inst✝³ : Algebra R S
inst✝² : Algebra S A
inst✝¹ : IsScalarTower R S A
inst✝ : Nontrivial R
⊢ IsAlgebraic R ((algebraMap R A) 1)
tactic: rw [← _root_.map_one (algebraMap R A)]
state_before: R : Type u
S : Type u_1
A : Type v
inst✝⁷ : CommRing R
inst✝⁶ : CommRing S
inst✝⁵ : Ring A
inst✝⁴ : Algebra R A
inst✝³ : Algebra R S
inst✝² : Algebra S A
inst✝¹ : IsScalarTower R S A
inst✝ : Nontrivial R
⊢ IsAlgebraic R ((algebraMap R A) 1)
state_after: no goals
tactic: exact isAlgebraic_algebraMap 1
Theorem: symmDiff_eq_left
File: Mathlib/Order/SymmDiff.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : GeneralizedBooleanAlgebra α
a b c d : α
⊢ a ∆ b = a ↔ a ∆ b = a ∆ ⊥
state_after: no goals
tactic: rw [symmDiff_bot]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : GeneralizedBooleanAlgebra α
a b c d : α
⊢ a ∆ b = a ∆ ⊥ ↔ b = ⊥
state_after: no goals
tactic: rw [symmDiff_right_inj]
Theorem: SimpleGraph.cliqueSet_map_of_equiv
File: Mathlib/Combinatorics/SimpleGraph/Clique.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G✝ H : SimpleGraph α
n✝ : ℕ
a b c : α
s : Finset α
G : SimpleGraph α
e : α ≃ β
n : ℕ
⊢ (SimpleGraph.map e.toEmbedding G).cliqueSet n = map e.toEmbedding '' G.cliqueSet n
state_after: case inl
α : Type u_1
β : Type u_2
G✝ H : SimpleGraph α
n : ℕ
a b c : α
s : Finset α
G : SimpleGraph α
e : α ≃ β
⊢ (SimpleGraph.map e.toEmbedding G).cliqueSet 1 = map e.toEmbedding '' G.cliqueSet 1

case inr
α : Type u_1
β : Type u_2
G✝ H : SimpleGraph α
n✝ : ℕ
a b c : α
s : Finset α
G : SimpleGraph α
e : α ≃ β
n : ℕ
hn : n ≠ 1
⊢ (SimpleGraph.map e.toEmbedding G).cliqueSet n = map e.toEmbedding '' G.cliqueSet n
tactic: obtain rfl | hn := eq_or_ne n 1
Theorem: Turing.BlankExtends.refl
File: Mathlib/Computability/TuringMachine.lean

Proof steps:
state_before: Γ : Type u_1
inst✝ : Inhabited Γ
l : List Γ
⊢ l = l ++ List.replicate 0 default
state_after: no goals
tactic: simp
Theorem: Nat.squarefree_of_factorization_le_one
File: Mathlib/Data/Nat/Squarefree.lean

Proof steps:
state_before: s : Finset ℕ
m n✝ p n : ℕ
hn : n ≠ 0
hn' : ∀ (p : ℕ), n.factorization p ≤ 1
⊢ Squarefree n
state_after: s : Finset ℕ
m n✝ p n : ℕ
hn : n ≠ 0
hn' : ∀ (p : ℕ), n.factorization p ≤ 1
⊢ ∀ (a : ℕ), List.count a n.primeFactorsList ≤ 1
tactic: rw [squarefree_iff_nodup_primeFactorsList hn, List.nodup_iff_count_le_one]
state_before: s : Finset ℕ
m n✝ p n : ℕ
hn : n ≠ 0
hn' : ∀ (p : ℕ), n.factorization p ≤ 1
⊢ ∀ (a : ℕ), List.count a n.primeFactorsList ≤ 1
state_after: s : Finset ℕ
m n✝ p n : ℕ
hn : n ≠ 0
hn' : ∀ (p : ℕ), n.factorization p ≤ 1
a : ℕ
⊢ List.count a n.primeFactorsList ≤ 1
tactic: intro a
state_before: s : Finset ℕ
m n✝ p n : ℕ
hn : n ≠ 0
hn' : ∀ (p : ℕ), n.factorization p ≤ 1
a : ℕ
⊢ List.count a n.primeFactorsList ≤ 1
state_after: s : Finset ℕ
m n✝ p n : ℕ
hn : n ≠ 0
hn' : ∀ (p : ℕ), n.factorization p ≤ 1
a : ℕ
⊢ n.factorization a ≤ 1
tactic: rw [primeFactorsList_count_eq]
state_before: s : Finset ℕ
m n✝ p n : ℕ
hn : n ≠ 0
hn' : ∀ (p : ℕ), n.factorization p ≤ 1
a : ℕ
⊢ n.factorization a ≤ 1
state_after: no goals
tactic: apply hn'
Theorem: lt_or_lt_of_div_lt_div
File: Mathlib/Algebra/Order/Group/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u
inst✝² : CommGroup α
inst✝¹ : LinearOrder α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c d : α
⊢ a / d < b / c → a < b ∨ c < d
state_after: α : Type u
inst✝² : CommGroup α
inst✝¹ : LinearOrder α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c d : α
⊢ b ≤ a ∧ d ≤ c → b / c ≤ a / d
tactic: contrapose!
state_before: α : Type u
inst✝² : CommGroup α
inst✝¹ : LinearOrder α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c d : α
⊢ b ≤ a ∧ d ≤ c → b / c ≤ a / d
state_after: no goals
tactic: exact fun h ↦ div_le_div'' h.1 h.2
Theorem: Finset.support_mulAntidiagonal_subset_mul
File: Mathlib/Data/Finset/MulAntidiagonal.lean

Proof steps:
state_before: α : Type u_1
inst✝ : OrderedCancelCommMonoid α
s t : Set α
hs : s.IsPWO
ht : t.IsPWO
a✝ : α
u : Set α
hu : u.IsPWO
x : α × α
a : α
x✝ : a ∈ {a | (mulAntidiagonal hs ht a).Nonempty}
b : α × α
hb : b ∈ mulAntidiagonal hs ht a
⊢ a ∈ s * t
state_after: α : Type u_1
inst✝ : OrderedCancelCommMonoid α
s t : Set α
hs : s.IsPWO
ht : t.IsPWO
a✝ : α
u : Set α
hu : u.IsPWO
x : α × α
a : α
x✝ : a ∈ {a | (mulAntidiagonal hs ht a).Nonempty}
b : α × α
hb : b.1 ∈ s ∧ b.2 ∈ t ∧ b.1 * b.2 = a
⊢ a ∈ s * t
tactic: rw [mem_mulAntidiagonal] at hb
state_before: α : Type u_1
inst✝ : OrderedCancelCommMonoid α
s t : Set α
hs : s.IsPWO
ht : t.IsPWO
a✝ : α
u : Set α
hu : u.IsPWO
x : α × α
a : α
x✝ : a ∈ {a | (mulAntidiagonal hs ht a).Nonempty}
b : α × α
hb : b.1 ∈ s ∧ b.2 ∈ t ∧ b.1 * b.2 = a
⊢ a ∈ s * t
state_after: no goals
tactic: exact ⟨b.1, hb.1, b.2, hb.2⟩
Theorem: Nat.map_ceil
File: Mathlib/Algebra/Order/Floor.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝⁵ : LinearOrderedSemiring α
inst✝⁴ : LinearOrderedSemiring β
inst✝³ : FloorSemiring α
inst✝² : FloorSemiring β
inst✝¹ : FunLike F α β
inst✝ : RingHomClass F α β
a✝ : α
b : β
f : F
hf : StrictMono ⇑f
a : α
n : ℕ
⊢ f a ≤ ↑n ↔ a ≤ ↑n
state_after: no goals
tactic: rw [← map_natCast f, hf.le_iff_le]
Theorem: Polynomial.natDegree_neg
File: Mathlib/Algebra/Polynomial/Degree/Definitions.lean

Proof steps:
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Ring R
p : R[X]
⊢ (-p).natDegree = p.natDegree
state_after: no goals
tactic: simp [natDegree]
Theorem: SimpleGraph.maxDegree_lt_card_verts
File: Mathlib/Combinatorics/SimpleGraph/Finite.lean

Proof steps:
state_before: V : Type u_1
G : SimpleGraph V
e : Sym2 V
inst✝² : Fintype V
inst✝¹ : DecidableRel G.Adj
inst✝ : Nonempty V
⊢ G.maxDegree < Fintype.card V
state_after: case intro
V : Type u_1
G : SimpleGraph V
e : Sym2 V
inst✝² : Fintype V
inst✝¹ : DecidableRel G.Adj
inst✝ : Nonempty V
v : V
hv : G.maxDegree = G.degree v
⊢ G.maxDegree < Fintype.card V
tactic: cases' G.exists_maximal_degree_vertex with v hv
state_before: case intro
V : Type u_1
G : SimpleGraph V
e : Sym2 V
inst✝² : Fintype V
inst✝¹ : DecidableRel G.Adj
inst✝ : Nonempty V
v : V
hv : G.maxDegree = G.degree v
⊢ G.maxDegree < Fintype.card V
state_after: case intro
V : Type u_1
G : SimpleGraph V
e : Sym2 V
inst✝² : Fintype V
inst✝¹ : DecidableRel G.Adj
inst✝ : Nonempty V
v : V
hv : G.maxDegree = G.degree v
⊢ G.degree v < Fintype.card V
tactic: rw [hv]
state_before: case intro
V : Type u_1
G : SimpleGraph V
e : Sym2 V
inst✝² : Fintype V
inst✝¹ : DecidableRel G.Adj
inst✝ : Nonempty V
v : V
hv : G.maxDegree = G.degree v
⊢ G.degree v < Fintype.card V
state_after: no goals
tactic: apply G.degree_lt_card_verts v
Theorem: Finset.insert_sdiff_insert'
File: Mathlib/Data/Finset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s t u v : Finset α
a b : α
hab : a ≠ b
ha : a ∉ s
⊢ insert a s \ insert b s = {a}
state_after: case a
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s t u v : Finset α
a b : α
hab : a ≠ b
ha : a ∉ s
a✝ : α
⊢ a✝ ∈ insert a s \ insert b s ↔ a✝ ∈ {a}
tactic: ext
state_before: case a
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s t u v : Finset α
a b : α
hab : a ≠ b
ha : a ∉ s
a✝ : α
⊢ a✝ ∈ insert a s \ insert b s ↔ a✝ ∈ {a}
state_after: no goals
tactic: aesop
Theorem: PMF.toMeasure_uniformOfFintype_apply
File: Mathlib/Probability/Distributions/Uniform.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : Fintype α
inst✝¹ : Nonempty α
s : Set α
inst✝ : MeasurableSpace α
hs : MeasurableSet s
⊢ (uniformOfFintype α).toMeasure s = ↑(Fintype.card ↑s) / ↑(Fintype.card α)
state_after: no goals
tactic: simp [uniformOfFintype, hs]