ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Rel.interedges_mono
File: Mathlib/Combinatorics/SimpleGraph/Density.lean

Proof steps:
state_before: 𝕜 : Type u_1
ι : Type u_2
κ : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : LinearOrderedField 𝕜
r : α → β → Prop
inst✝ : (a : α) → DecidablePred (r a)
s s₁ s₂ : Finset α
t t₁ t₂ : Finset β
a : α
b : β
δ : 𝕜
hs : s₂ ⊆ s₁
ht : t₂ ⊆ t₁
x : α × β
⊢ x ∈ interedges r s₂ t₂ → x ∈ interedges r s₁ t₁
state_after: 𝕜 : Type u_1
ι : Type u_2
κ : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : LinearOrderedField 𝕜
r : α → β → Prop
inst✝ : (a : α) → DecidablePred (r a)
s s₁ s₂ : Finset α
t t₁ t₂ : Finset β
a : α
b : β
δ : 𝕜
hs : s₂ ⊆ s₁
ht : t₂ ⊆ t₁
x : α × β
⊢ x.1 ∈ s₂ ∧ x.2 ∈ t₂ ∧ r x.1 x.2 → x.1 ∈ s₁ ∧ x.2 ∈ t₁ ∧ r x.1 x.2
tactic: simp_rw [mem_interedges_iff]
state_before: 𝕜 : Type u_1
ι : Type u_2
κ : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : LinearOrderedField 𝕜
r : α → β → Prop
inst✝ : (a : α) → DecidablePred (r a)
s s₁ s₂ : Finset α
t t₁ t₂ : Finset β
a : α
b : β
δ : 𝕜
hs : s₂ ⊆ s₁
ht : t₂ ⊆ t₁
x : α × β
⊢ x.1 ∈ s₂ ∧ x.2 ∈ t₂ ∧ r x.1 x.2 → x.1 ∈ s₁ ∧ x.2 ∈ t₁ ∧ r x.1 x.2
state_after: no goals
tactic: exact fun h ↦ ⟨hs h.1, ht h.2.1, h.2.2⟩
Theorem: SimpleGraph.neighborSet_union_compl_neighborSet_eq
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
G : SimpleGraph V
v : V
⊢ G.neighborSet v ∪ Gᶜ.neighborSet v = {v}ᶜ
state_after: case h
ι : Sort u_1
V : Type u
G✝ : SimpleGraph V
a b c u v✝ w✝ : V
e : Sym2 V
G : SimpleGraph V
v w : V
⊢ w ∈ G.neighborSet v ∪ Gᶜ.neighborSet v ↔ w ∈ {v}ᶜ
tactic: ext w
state_before: case h
ι : Sort u_1
V : Type u
G✝ : SimpleGraph V
a b c u v✝ w✝ : V
e : Sym2 V
G : SimpleGraph V
v w : V
⊢ w ∈ G.neighborSet v ∪ Gᶜ.neighborSet v ↔ w ∈ {v}ᶜ
state_after: case h
ι : Sort u_1
V : Type u
G✝ : SimpleGraph V
a b c u v✝ w✝ : V
e : Sym2 V
G : SimpleGraph V
v w : V
h : ∀ {a b : V}, G.Adj a b → a ≠ b
⊢ w ∈ G.neighborSet v ∪ Gᶜ.neighborSet v ↔ w ∈ {v}ᶜ
tactic: have h := @ne_of_adj _ G
state_before: case h
ι : Sort u_1
V : Type u
G✝ : SimpleGraph V
a b c u v✝ w✝ : V
e : Sym2 V
G : SimpleGraph V
v w : V
h : ∀ {a b : V}, G.Adj a b → a ≠ b
⊢ w ∈ G.neighborSet v ∪ Gᶜ.neighborSet v ↔ w ∈ {v}ᶜ
state_after: case h
ι : Sort u_1
V : Type u
G✝ : SimpleGraph V
a b c u v✝ w✝ : V
e : Sym2 V
G : SimpleGraph V
v w : V
h : ∀ {a b : V}, G.Adj a b → a ≠ b
⊢ G.Adj v w ∨ v ≠ w ∧ ¬G.Adj v w ↔ ¬w = v
tactic: simp_rw [Set.mem_union, mem_neighborSet, compl_adj, Set.mem_compl_iff, Set.mem_singleton_iff]
state_before: case h
ι : Sort u_1
V : Type u
G✝ : SimpleGraph V
a b c u v✝ w✝ : V
e : Sym2 V
G : SimpleGraph V
v w : V
h : ∀ {a b : V}, G.Adj a b → a ≠ b
⊢ G.Adj v w ∨ v ≠ w ∧ ¬G.Adj v w ↔ ¬w = v
state_after: no goals
tactic: tauto
Theorem: Int.negOnePow_sub
File: Mathlib/Algebra/Ring/NegOnePow.lean

Proof steps:
state_before: n₁ n₂ : ℤ
⊢ (n₁ - n₂).negOnePow = n₁.negOnePow * n₂.negOnePow
state_after: no goals
tactic: simp only [sub_eq_add_neg, negOnePow_add, negOnePow_neg]
Theorem: Submonoid.fromLeftInv_eq_iff
File: Mathlib/GroupTheory/Submonoid/Inverses.lean

Proof steps:
state_before: M : Type u_1
inst✝ : CommMonoid M
S : Submonoid M
a : ↥S.leftInv
b : M
⊢ ↑(S.fromLeftInv a) = b ↔ ↑a * b = 1
state_after: no goals
tactic: rw [← IsUnit.mul_right_inj (leftInv_le_isUnit _ a.prop), S.mul_fromLeftInv, eq_comm]
Theorem: Filter.pow_mem_pow
File: Mathlib/Order/Filter/Pointwise.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
ε : Type u_6
inst✝ : Monoid α
f g : Filter α
s : Set α
a : α
m n : ℕ
hs : s ∈ f
⊢ s ^ 0 ∈ f ^ 0
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
ε : Type u_6
inst✝ : Monoid α
f g : Filter α
s : Set α
a : α
m n : ℕ
hs : s ∈ f
⊢ 1 ∈ f ^ 0
tactic: rw [pow_zero]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
ε : Type u_6
inst✝ : Monoid α
f g : Filter α
s : Set α
a : α
m n : ℕ
hs : s ∈ f
⊢ 1 ∈ f ^ 0
state_after: no goals
tactic: exact one_mem_one
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
ε : Type u_6
inst✝ : Monoid α
f g : Filter α
s : Set α
a : α
m n✝ : ℕ
hs : s ∈ f
n : ℕ
⊢ s ^ (n + 1) ∈ f ^ (n + 1)
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
ε : Type u_6
inst✝ : Monoid α
f g : Filter α
s : Set α
a : α
m n✝ : ℕ
hs : s ∈ f
n : ℕ
⊢ s ^ n * s ∈ f ^ (n + 1)
tactic: rw [pow_succ]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
ε : Type u_6
inst✝ : Monoid α
f g : Filter α
s : Set α
a : α
m n✝ : ℕ
hs : s ∈ f
n : ℕ
⊢ s ^ n * s ∈ f ^ (n + 1)
state_after: no goals
tactic: exact mul_mem_mul (pow_mem_pow hs n) hs
Theorem: quadraticCharFun_eq_pow_of_char_ne_two
File: Mathlib/NumberTheory/LegendreSymbol/QuadraticChar/Basic.lean

Proof steps:
state_before: F : Type u_1
inst✝² : Field F
inst✝¹ : Fintype F
inst✝ : DecidableEq F
hF : ringChar F ≠ 2
a : F
ha : a ≠ 0
⊢ quadraticCharFun F a = if a ^ (Fintype.card F / 2) = 1 then 1 else -1
state_after: F : Type u_1
inst✝² : Field F
inst✝¹ : Fintype F
inst✝ : DecidableEq F
hF : ringChar F ≠ 2
a : F
ha : a ≠ 0
⊢ (if IsSquare a then 1 else -1) = if a ^ (Fintype.card F / 2) = 1 then 1 else -1
tactic: simp only [quadraticCharFun, ha, if_false]
state_before: F : Type u_1
inst✝² : Field F
inst✝¹ : Fintype F
inst✝ : DecidableEq F
hF : ringChar F ≠ 2
a : F
ha : a ≠ 0
⊢ (if IsSquare a then 1 else -1) = if a ^ (Fintype.card F / 2) = 1 then 1 else -1
state_after: no goals
tactic: simp_rw [FiniteField.isSquare_iff hF ha]
Theorem: RingCat.Colimits.cocone_naturality_components
File: Mathlib/Algebra/Category/Ring/Colimits.lean

Proof steps:
state_before: J : Type v
inst✝ : SmallCategory J
F : J ⥤ RingCat
j j' : J
f : j ⟶ j'
x : ↑(F.obj j)
⊢ (coconeMorphism F j') ((F.map f) x) = (coconeMorphism F j) x
state_after: no goals
tactic: rw [← cocone_naturality F f, comp_apply]
Theorem: List.formPerm_eq_formPerm_iff
File: Mathlib/GroupTheory/Perm/List.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
l✝ : List α
x : α
l l' : List α
hl : l.Nodup
hl' : l'.Nodup
⊢ l.formPerm = l'.formPerm ↔ l ~r l' ∨ l.length ≤ 1 ∧ l'.length ≤ 1
state_after: case nil
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
l : List α
x : α
l' : List α
hl' : l'.Nodup
hl : [].Nodup
⊢ [].formPerm = l'.formPerm ↔ [] ~r l' ∨ [].length ≤ 1 ∧ l'.length ≤ 1

case cons.nil
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
l : List α
x✝ : α
l' : List α
hl' : l'.Nodup
x : α
hl : [x].Nodup
⊢ [x].formPerm = l'.formPerm ↔ [x] ~r l' ∨ [x].length ≤ 1 ∧ l'.length ≤ 1

case cons.cons
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
l✝ : List α
x✝ : α
l' : List α
hl' : l'.Nodup
x y : α
l : List α
hl : (x :: y :: l).Nodup
⊢ (x :: y :: l).formPerm = l'.formPerm ↔ (x :: y :: l) ~r l' ∨ (x :: y :: l).length ≤ 1 ∧ l'.length ≤ 1
tactic: rcases l with (_ | ⟨x, _ | ⟨y, l⟩⟩)
Theorem: CategoryTheory.WithTerminal.mapId_inv_app
File: Mathlib/CategoryTheory/WithTerminal.lean

Proof steps:
state_before: C✝ : Type u
inst✝¹ : Category.{v, u} C✝
C : Type u_1
inst✝ : Category.{?u.49274, u_1} C
⊢ ∀ {X Y : WithTerminal C} (f : X ⟶ Y),
    (map (𝟭 C)).map f ≫
        ((fun X =>
              match X with
              | of x => Iso.refl ((map (𝟭 C)).obj (of x))
              | star => Iso.refl ((map (𝟭 C)).obj star))
            Y).hom =
      ((fun X =>
              match X with
              | of x => Iso.refl ((map (𝟭 C)).obj (of x))
              | star => Iso.refl ((map (𝟭 C)).obj star))
            X).hom ≫
        (𝟭 (WithTerminal C)).map f
state_after: no goals
tactic: aesop_cat
Theorem: Polynomial.scaleRoots_eval₂_eq_zero
File: Mathlib/RingTheory/Polynomial/ScaleRoots.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
A : Type u_3
K : Type u_4
inst✝³ : Semiring S
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Field K
p : S[X]
f : S →+* R
r : R
s : S
hr : eval₂ f r p = 0
⊢ eval₂ f (f s * r) (p.scaleRoots s) = 0
state_after: no goals
tactic: rw [scaleRoots_eval₂_mul, hr, mul_zero]
Theorem: Complex.hasSum_cos
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Series.lean

Proof steps:
state_before: z : ℂ
⊢ HasSum (fun n => (-1) ^ n * z ^ (2 * n) / ↑(2 * n)!) (cos z)
state_after: case h.e'_5
z : ℂ
⊢ (fun n => (-1) ^ n * z ^ (2 * n) / ↑(2 * n)!) = fun n => (z * I) ^ (2 * n) / ↑(2 * n)!
tactic: convert Complex.hasSum_cos' z using 1
state_before: case h.e'_5
z : ℂ
⊢ (fun n => (-1) ^ n * z ^ (2 * n) / ↑(2 * n)!) = fun n => (z * I) ^ (2 * n) / ↑(2 * n)!
state_after: no goals
tactic: simp_rw [mul_pow, pow_mul, Complex.I_sq, mul_comm]
Theorem: Ordinal.zero_lt_card
File: Mathlib/SetTheory/Ordinal/Basic.lean

Proof steps:
state_before: α : Type u
β : Type u_1
γ : Type u_2
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u_3}
⊢ 0 < o.card ↔ 0 < o
state_after: no goals
tactic: simpa using nat_lt_card (n := 0)
Theorem: ENNReal.rpow_arith_mean_le_arith_mean_rpow
File: Mathlib/Analysis/MeanInequalitiesPow.lean

Proof steps:
state_before: ι : Type u
s : Finset ι
w z : ι → ℝ≥0∞
hw' : ∑ i ∈ s, w i = 1
p : ℝ
hp : 1 ≤ p
⊢ (∑ i ∈ s, w i * z i) ^ p ≤ ∑ i ∈ s, w i * z i ^ p
state_after: ι : Type u
s : Finset ι
w z : ι → ℝ≥0∞
hw' : ∑ i ∈ s, w i = 1
p : ℝ
hp : 1 ≤ p
hp_pos : 0 < p
⊢ (∑ i ∈ s, w i * z i) ^ p ≤ ∑ i ∈ s, w i * z i ^ p
tactic: have hp_pos : 0 < p := by positivity
state_before: ι : Type u
s : Finset ι
w z : ι → ℝ≥0∞
hw' : ∑ i ∈ s, w i = 1
p : ℝ
hp : 1 ≤ p
hp_pos : 0 < p
⊢ (∑ i ∈ s, w i * z i) ^ p ≤ ∑ i ∈ s, w i * z i ^ p
state_after: ι : Type u
s : Finset ι
w z : ι → ℝ≥0∞
hw' : ∑ i ∈ s, w i = 1
p : ℝ
hp : 1 ≤ p
hp_pos : 0 < p
hp_nonneg : 0 ≤ p
⊢ (∑ i ∈ s, w i * z i) ^ p ≤ ∑ i ∈ s, w i * z i ^ p
tactic: have hp_nonneg : 0 ≤ p := by positivity
state_before: ι : Type u
s : Finset ι
w z : ι → ℝ≥0∞
hw' : ∑ i ∈ s, w i = 1
p : ℝ
hp : 1 ≤ p
hp_pos : 0 < p
hp_nonneg : 0 ≤ p
⊢ (∑ i ∈ s, w i * z i) ^ p ≤ ∑ i ∈ s, w i * z i ^ p
state_after: ι : Type u
s : Finset ι
w z : ι → ℝ≥0∞
hw' : ∑ i ∈ s, w i = 1
p : ℝ
hp : 1 ≤ p
hp_pos : 0 < p
hp_nonneg : 0 ≤ p
hp_not_neg : ¬p < 0
⊢ (∑ i ∈ s, w i * z i) ^ p ≤ ∑ i ∈ s, w i * z i ^ p
tactic: have hp_not_neg : ¬p < 0 := by simp [hp_nonneg]
state_before: ι : Type u
s : Finset ι
w z : ι → ℝ≥0∞
hw' : ∑ i ∈ s, w i = 1
p : ℝ
hp : 1 ≤ p
hp_pos : 0 < p
hp_nonneg : 0 ≤ p
hp_not_neg : ¬p < 0
⊢ (∑ i ∈ s, w i * z i) ^ p ≤ ∑ i ∈ s, w i * z i ^ p
state_after: ι : Type u
s : Finset ι
w z : ι → ℝ≥0∞
hw' : ∑ i ∈ s, w i = 1
p : ℝ
hp : 1 ≤ p
hp_pos : 0 < p
hp_nonneg : 0 ≤ p
hp_not_neg : ¬p < 0
h_top_iff_rpow_top : ∀ i ∈ s, w i * z i = ⊤ ↔ w i * z i ^ p = ⊤
⊢ (∑ i ∈ s, w i * z i) ^ p ≤ ∑ i ∈ s, w i * z i ^ p
tactic: have h_top_iff_rpow_top : ∀ (i : ι), i ∈ s → (w i * z i = ⊤ ↔ w i * z i ^ p = ⊤) := by
    simp [ENNReal.mul_eq_top, hp_pos, hp_nonneg, hp_not_neg]
state_before: ι : Type u
s : Finset ι
w z : ι → ℝ≥0∞
hw' : ∑ i ∈ s, w i = 1
p : ℝ
hp : 1 ≤ p
hp_pos : 0 < p
hp_nonneg : 0 ≤ p
hp_not_neg : ¬p < 0
h_top_iff_rpow_top : ∀ i ∈ s, w i * z i = ⊤ ↔ w i * z i ^ p = ⊤
⊢ (∑ i ∈ s, w i * z i) ^ p ≤ ∑ i ∈ s, w i * z i ^ p
state_after: case refine_1
ι : Type u
s : Finset ι
w z : ι → ℝ≥0∞
hw' : ∑ i ∈ s, w i = 1
p : ℝ
hp : 1 ≤ p
hp_pos : 0 < p
hp_nonneg : 0 ≤ p
hp_not_neg : ¬p < 0
h_top_iff_rpow_top : ∀ i ∈ s, w i * z i = ⊤ ↔ w i * z i ^ p = ⊤
⊢ (∑ i ∈ s, w i * z i) ^ p = ⊤ → ∑ i ∈ s, w i * z i ^ p = ⊤

case refine_2
ι : Type u
s : Finset ι
w z : ι → ℝ≥0∞
hw' : ∑ i ∈ s, w i = 1
p : ℝ
hp : 1 ≤ p
hp_pos : 0 < p
hp_nonneg : 0 ≤ p
hp_not_neg : ¬p < 0
h_top_iff_rpow_top : ∀ i ∈ s, w i * z i = ⊤ ↔ w i * z i ^ p = ⊤
⊢ (∑ i ∈ s, w i * z i) ^ p ≠ ⊤ →
    ∑ i ∈ s, w i * z i ^ p ≠ ⊤ → ((∑ i ∈ s, w i * z i) ^ p).toNNReal ≤ (∑ i ∈ s, w i * z i ^ p).toNNReal
tactic: refine le_of_top_imp_top_of_toNNReal_le ?_ ?_
Theorem: SchwartzMap.tsum_eq_tsum_fourierIntegral
File: Mathlib/Analysis/Fourier/PoissonSummation.lean

Proof steps:
state_before: f g : 𝓢(ℝ, ℂ)
hfg : 𝓕 ⇑f = ⇑g
x : ℝ
⊢ ∑' (n : ℤ), f (x + ↑n) = ∑' (n : ℤ), g ↑n * (fourier n) ↑x
state_after: no goals
tactic: simp only [← hfg, Real.tsum_eq_tsum_fourierIntegral_of_rpow_decay f.continuous one_lt_two
    (f.isBigO_cocompact_rpow (-2)) (hfg ▸ g.isBigO_cocompact_rpow (-2))]
Theorem: Cardinal.self_le_power
File: Mathlib/SetTheory/Cardinal/Basic.lean

Proof steps:
state_before: α β : Type u
a b : Cardinal.{u_1}
hb : 1 ≤ b
⊢ a ≤ a ^ b
state_after: case inl
α β : Type u
b : Cardinal.{u_1}
hb : 1 ≤ b
⊢ 0 ≤ 0 ^ b

case inr
α β : Type u
a b : Cardinal.{u_1}
hb : 1 ≤ b
ha : a ≠ 0
⊢ a ≤ a ^ b
tactic: rcases eq_or_ne a 0 with (rfl | ha)
Theorem: TopologicalSpace.IsTopologicalBasis.continuous_iff
File: Mathlib/Topology/Bases.lean

Proof steps:
state_before: α : Type u
β✝ : Type u_1
t : TopologicalSpace α
B✝ : Set (Set α)
s : Set α
β : Type u_2
inst✝ : TopologicalSpace β
B : Set (Set β)
hB : IsTopologicalBasis B
f : α → β
⊢ Continuous f ↔ ∀ s ∈ B, IsOpen (f ⁻¹' s)
state_after: no goals
tactic: rw [hB.eq_generateFrom, continuous_generateFrom_iff]
Theorem: Inducing.isCompact_preimage
File: Mathlib/Topology/Compactness/Compact.lean

Proof steps:
state_before: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
f : X → Y
hf : Inducing f
hf' : IsClosed (range f)
K : Set Y
hK : IsCompact K
⊢ IsCompact (f ⁻¹' K)
state_after: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
f : X → Y
hf : Inducing f
hf' : IsClosed (range f)
K : Set Y
hK : IsCompact (K ∩ range f)
⊢ IsCompact (f ⁻¹' K)
tactic: replace hK := hK.inter_right hf'
state_before: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
f : X → Y
hf : Inducing f
hf' : IsClosed (range f)
K : Set Y
hK : IsCompact (K ∩ range f)
⊢ IsCompact (f ⁻¹' K)
state_after: no goals
tactic: rwa [hf.isCompact_iff, image_preimage_eq_inter_range]
Theorem: Nat.lt_find_iff
File: Mathlib/Data/Nat/Find.lean

Proof steps:
state_before: a b c d m n✝ k : ℕ
p q : ℕ → Prop
inst✝² : DecidablePred p
H : ∃ n, p n
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
h : ∃ n, p n
n : ℕ
⊢ n < Nat.find h ↔ ∀ (m : ℕ), m ≤ n → ¬p m
state_after: no goals
tactic: simp only [← succ_le_iff, le_find_iff, succ_le_succ_iff]
Theorem: ProbabilityTheory.isProbabilityMeasureGamma
File: Mathlib/Probability/Distributions/Gamma.lean

Proof steps:
state_before: a r : ℝ
ha : 0 < a
hr : 0 < r
⊢ (gammaMeasure a r) univ = 1
state_after: no goals
tactic: simp [gammaMeasure, lintegral_gammaPDF_eq_one ha hr]
Theorem: Matroid.Restriction.strictRestriction_of_ground_ne
File: Mathlib/Data/Matroid/Restrict.lean

Proof steps:
state_before: α : Type u_1
M : Matroid α
R I J X Y : Set α
N : Matroid α
h : N ≤r M
hne : N.E ≠ M.E
⊢ N <r M
state_after: α : Type u_1
M : Matroid α
R I J X Y : Set α
N : Matroid α
h : N ≤r M
hne : N.E ≠ M.E
⊢ M ↾ N.E <r M
tactic: rw [← h.eq_restrict]
state_before: α : Type u_1
M : Matroid α
R I J X Y : Set α
N : Matroid α
h : N ≤r M
hne : N.E ≠ M.E
⊢ M ↾ N.E <r M
state_after: no goals
tactic: exact restrict_strictRestriction (h.subset.ssubset_of_ne hne)
Theorem: Set.nontrivial_of_infsep_pos
File: Mathlib/Topology/MetricSpace/Infsep.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : EDist α
x y : α
s : Set α
hs : 0 < s.infsep
⊢ s.Nontrivial
state_after: α : Type u_1
β : Type u_2
inst✝ : EDist α
x y : α
s : Set α
hs : ¬s.Nontrivial
⊢ ¬0 < s.infsep
tactic: contrapose hs
state_before: α : Type u_1
β : Type u_2
inst✝ : EDist α
x y : α
s : Set α
hs : ¬s.Nontrivial
⊢ ¬0 < s.infsep
state_after: α : Type u_1
β : Type u_2
inst✝ : EDist α
x y : α
s : Set α
hs : s.Subsingleton
⊢ ¬0 < s.infsep
tactic: rw [not_nontrivial_iff] at hs
state_before: α : Type u_1
β : Type u_2
inst✝ : EDist α
x y : α
s : Set α
hs : s.Subsingleton
⊢ ¬0 < s.infsep
state_after: no goals
tactic: exact hs.infsep_zero ▸ lt_irrefl _
Theorem: Polynomial.not_isUnit_X_pow_sub_one
File: Mathlib/Algebra/Polynomial/Monic.lean

Proof steps:
state_before: R✝ : Type u
S : Type v
a b : R✝
m n✝ : ℕ
ι : Type y
inst✝² : Ring R✝
p : R✝[X]
R : Type u_1
inst✝¹ : CommRing R
inst✝ : Nontrivial R
n : ℕ
⊢ ¬IsUnit (X ^ n - 1)
state_after: R✝ : Type u
S : Type v
a b : R✝
m n✝ : ℕ
ι : Type y
inst✝² : Ring R✝
p : R✝[X]
R : Type u_1
inst✝¹ : CommRing R
inst✝ : Nontrivial R
n : ℕ
h : IsUnit (X ^ n - 1)
⊢ False
tactic: intro h
state_before: R✝ : Type u
S : Type v
a b : R✝
m n✝ : ℕ
ι : Type y
inst✝² : Ring R✝
p : R✝[X]
R : Type u_1
inst✝¹ : CommRing R
inst✝ : Nontrivial R
n : ℕ
h : IsUnit (X ^ n - 1)
⊢ False
state_after: case inl
R✝ : Type u
S : Type v
a b : R✝
m n : ℕ
ι : Type y
inst✝² : Ring R✝
p : R✝[X]
R : Type u_1
inst✝¹ : CommRing R
inst✝ : Nontrivial R
h : IsUnit (X ^ 0 - 1)
⊢ False

case inr
R✝ : Type u
S : Type v
a b : R✝
m n✝ : ℕ
ι : Type y
inst✝² : Ring R✝
p : R✝[X]
R : Type u_1
inst✝¹ : CommRing R
inst✝ : Nontrivial R
n : ℕ
h : IsUnit (X ^ n - 1)
hn : n ≠ 0
⊢ False
tactic: rcases eq_or_ne n 0 with (rfl | hn)
state_before: case inr
R✝ : Type u
S : Type v
a b : R✝
m n✝ : ℕ
ι : Type y
inst✝² : Ring R✝
p : R✝[X]
R : Type u_1
inst✝¹ : CommRing R
inst✝ : Nontrivial R
n : ℕ
h : IsUnit (X ^ n - 1)
hn : n ≠ 0
⊢ False
state_after: case inr
R✝ : Type u
S : Type v
a b : R✝
m n✝ : ℕ
ι : Type y
inst✝² : Ring R✝
p : R✝[X]
R : Type u_1
inst✝¹ : CommRing R
inst✝ : Nontrivial R
n : ℕ
h : IsUnit (X ^ n - 1)
hn : n ≠ 0
⊢ n = 0
tactic: apply hn
state_before: case inr
R✝ : Type u
S : Type v
a b : R✝
m n✝ : ℕ
ι : Type y
inst✝² : Ring R✝
p : R✝[X]
R : Type u_1
inst✝¹ : CommRing R
inst✝ : Nontrivial R
n : ℕ
h : IsUnit (X ^ n - 1)
hn : n ≠ 0
⊢ n = 0
state_after: no goals
tactic: rw [← @natDegree_one R, ← (monic_X_pow_sub_C _ hn).eq_one_of_isUnit h, natDegree_X_pow_sub_C]
Theorem: AntitoneOn.mapsTo_Iic
File: Mathlib/Order/Interval/Set/Image.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
f : α → β
inst✝¹ : Preorder α
inst✝ : Preorder β
a b : α
h : AntitoneOn f (Iic b)
x✝¹ : α
x✝ : x✝¹ ∈ Iic b
⊢ f x✝¹ ∈ Ici (f b)
state_after: no goals
tactic: aesop
Theorem: Bool.eq_not_iff
File: Mathlib/Data/Bool/Basic.lean

Proof steps:
state_before: ⊢ ∀ {a b : Bool}, a = !b ↔ a ≠ b
state_after: no goals
tactic: decide
Theorem: fderivWithin_eq_fderiv
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
hs : UniqueDiffWithinAt 𝕜 s x
h : DifferentiableAt 𝕜 f x
⊢ fderivWithin 𝕜 f s x = fderiv 𝕜 f x
state_after: 𝕜 : 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
hs : UniqueDiffWithinAt 𝕜 s x
h : DifferentiableAt 𝕜 f x
⊢ fderivWithin 𝕜 f s x = fderivWithin 𝕜 f univ x
tactic: rw [← fderivWithin_univ]
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
hs : UniqueDiffWithinAt 𝕜 s x
h : DifferentiableAt 𝕜 f x
⊢ fderivWithin 𝕜 f s x = fderivWithin 𝕜 f univ x
state_after: no goals
tactic: exact fderivWithin_subset (subset_univ _) hs h.differentiableWithinAt
Theorem: mem_closure_iff_nhds'
File: Mathlib/Topology/Basic.lean

Proof steps:
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
⊢ x ∈ closure s ↔ ∀ t ∈ 𝓝 x, ∃ y, ↑y ∈ t
state_after: no goals
tactic: simp only [mem_closure_iff_nhds, Set.inter_nonempty_iff_exists_right, SetCoe.exists, exists_prop]
Theorem: Nat.clog_of_left_le_one
File: Mathlib/Data/Nat/Log.lean

Proof steps:
state_before: b : ℕ
hb : b ≤ 1
n : ℕ
⊢ clog b n = 0
state_after: no goals
tactic: rw [clog, dif_neg fun h : 1 < b ∧ 1 < n => h.1.not_le hb]
Theorem: LinearEquiv.lTensor_refl_apply
File: Mathlib/LinearAlgebra/TensorProduct/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝¹⁶ : CommSemiring R
R' : Type u_2
inst✝¹⁵ : Monoid R'
R'' : Type u_3
inst✝¹⁴ : Semiring R''
M : Type u_4
N : Type u_5
P : Type u_6
Q : Type u_7
S : Type u_8
T : Type u_9
inst✝¹³ : AddCommMonoid M
inst✝¹² : AddCommMonoid N
inst✝¹¹ : AddCommMonoid P
inst✝¹⁰ : AddCommMonoid Q
inst✝⁹ : AddCommMonoid S
inst✝⁸ : AddCommMonoid T
inst✝⁷ : Module R M
inst✝⁶ : Module R N
inst✝⁵ : Module R P
inst✝⁴ : Module R Q
inst✝³ : Module R S
inst✝² : Module R T
inst✝¹ : DistribMulAction R' M
inst✝ : Module R'' M
g : P ≃ₗ[R] Q
f : N ≃ₗ[R] P
m : M
n : N
p : P
x : M ⊗[R] N
y : N ⊗[R] M
⊢ (lTensor M (refl R N)) x = x
state_after: no goals
tactic: rw [lTensor_refl, refl_apply]
Theorem: CategoryTheory.isIso_of_yoneda_map_bijective
File: Mathlib/CategoryTheory/Yoneda.lean

Proof steps:
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
X Y : C
f : X ⟶ Y
hf : ∀ (T : C), Function.Bijective fun x => x ≫ f
⊢ IsIso f
state_after: case intro
C : Type u₁
inst✝ : Category.{v₁, u₁} C
X Y : C
f : X ⟶ Y
hf : ∀ (T : C), Function.Bijective fun x => x ≫ f
g : Y ⟶ X
hg : g ≫ f = 𝟙 Y
⊢ IsIso f
tactic: obtain ⟨g, hg : g ≫ f = 𝟙 Y⟩ := (hf Y).2 (𝟙 Y)
state_before: case intro
C : Type u₁
inst✝ : Category.{v₁, u₁} C
X Y : C
f : X ⟶ Y
hf : ∀ (T : C), Function.Bijective fun x => x ≫ f
g : Y ⟶ X
hg : g ≫ f = 𝟙 Y
⊢ IsIso f
state_after: no goals
tactic: exact ⟨g, (hf _).1 (by aesop_cat), hg⟩
Theorem: RCLike.realLinearIsometryEquiv_apply
File: Mathlib/Analysis/RCLike/Basic.lean

Proof steps:
state_before: K : Type u_1
E : Type u_2
inst✝ : RCLike K
h : I = 0
z : K
⊢ ‖{ toFun := __spread✝⁻⁰.toFun, map_add' := ⋯, map_smul' := ⋯, invFun := __spread✝⁻⁰.invFun, left_inv := ⋯,
          right_inv := ⋯ }
        z‖ =
    ‖z‖
state_after: K : Type u_1
E : Type u_2
inst✝ : RCLike K
h : I = 0
z : K
⊢ ‖{ toFun := __spread✝⁻⁰.toFun, map_add' := ⋯, map_smul' := ⋯, invFun := __spread✝⁻⁰.invFun, left_inv := ⋯,
          right_inv := ⋯ }
        (↑(re z) + ↑(im z) * I)‖ =
    ‖↑(re z) + ↑(im z) * I‖
tactic: rw [← re_add_im z]
state_before: K : Type u_1
E : Type u_2
inst✝ : RCLike K
h : I = 0
z : K
⊢ ‖{ toFun := __spread✝⁻⁰.toFun, map_add' := ⋯, map_smul' := ⋯, invFun := __spread✝⁻⁰.invFun, left_inv := ⋯,
          right_inv := ⋯ }
        (↑(re z) + ↑(im z) * I)‖ =
    ‖↑(re z) + ↑(im z) * I‖
state_after: no goals
tactic: simp [- re_add_im, h]
Theorem: MvPowerSeries.coeff_zero_mul_X
File: Mathlib/RingTheory/MvPowerSeries/Basic.lean

Proof steps:
state_before: σ : Type u_1
R : Type u_2
inst✝ : Semiring R
φ : MvPowerSeries σ R
s : σ
⊢ (coeff R 0) (φ * X s) = 0
state_after: σ : Type u_1
R : Type u_2
inst✝ : Semiring R
φ : MvPowerSeries σ R
s : σ
this : ¬single s 1 ≤ 0
⊢ (coeff R 0) (φ * X s) = 0
tactic: have : ¬single s 1 ≤ 0 := fun h => by simpa using h s
state_before: σ : Type u_1
R : Type u_2
inst✝ : Semiring R
φ : MvPowerSeries σ R
s : σ
this : ¬single s 1 ≤ 0
⊢ (coeff R 0) (φ * X s) = 0
state_after: no goals
tactic: simp only [X, coeff_mul_monomial, if_neg this]