ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: TypeVec.lastFun_of_subtype
File: Mathlib/Data/TypeVec.lean

Proof steps:
state_before: n : ℕ
α : TypeVec.{u_1} (n + 1)
p : α ⟹ repeat (n + 1) Prop
⊢ lastFun (ofSubtype p) = _root_.id
state_after: case h
n : ℕ
α : TypeVec.{u_1} (n + 1)
p : α ⟹ repeat (n + 1) Prop
i : (Subtype_ p).last
⊢ lastFun (ofSubtype p) i = _root_.id i
tactic: ext i : 2
state_before: case h
n : ℕ
α : TypeVec.{u_1} (n + 1)
p : α ⟹ repeat (n + 1) Prop
i : (Subtype_ p).last
⊢ lastFun (ofSubtype p) i = _root_.id i
state_after: case h.mk
n : ℕ
α : TypeVec.{u_1} (n + 1)
p : α ⟹ repeat (n + 1) Prop
val✝ : α Fin2.fz
property✝ : p Fin2.fz val✝
⊢ lastFun (ofSubtype p) ⟨val✝, property✝⟩ = _root_.id ⟨val✝, property✝⟩
tactic: induction i
state_before: case h.mk
n : ℕ
α : TypeVec.{u_1} (n + 1)
p : α ⟹ repeat (n + 1) Prop
val✝ : α Fin2.fz
property✝ : p Fin2.fz val✝
⊢ lastFun (ofSubtype p) ⟨val✝, property✝⟩ = _root_.id ⟨val✝, property✝⟩
state_after: case h.mk
n : ℕ
α : TypeVec.{u_1} (n + 1)
p : α ⟹ repeat (n + 1) Prop
val✝ : α Fin2.fz
property✝ : p Fin2.fz val✝
⊢ lastFun (ofSubtype p) ⟨val✝, property✝⟩ = ⟨val✝, property✝⟩
tactic: simp [dropFun, *]
state_before: case h.mk
n : ℕ
α : TypeVec.{u_1} (n + 1)
p : α ⟹ repeat (n + 1) Prop
val✝ : α Fin2.fz
property✝ : p Fin2.fz val✝
⊢ lastFun (ofSubtype p) ⟨val✝, property✝⟩ = ⟨val✝, property✝⟩
state_after: no goals
tactic: rfl
Theorem: AlgebraicTopology.DoldKan.Γ₀.Obj.Termwise.mapMono_naturality
File: Mathlib/AlgebraicTopology/DoldKan/FunctorGamma.lean

Proof steps:
state_before: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Preadditive C
K K' : ChainComplex C ℕ
f : K ⟶ K'
Δ Δ' Δ'' : SimplexCategory
i : Δ ⟶ Δ'
inst✝ : Mono i
⊢ mapMono K i ≫ f.f Δ.len = f.f Δ'.len ≫ mapMono K' i
state_after: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Preadditive C
K K' : ChainComplex C ℕ
f : K ⟶ K'
Δ Δ' Δ'' : SimplexCategory
i : Δ ⟶ Δ'
inst✝ : Mono i
⊢ (if h : Δ' = Δ then eqToHom ⋯ else if h : Isδ₀ i then K.d Δ'.len Δ.len else 0) ≫ f.f Δ.len =
    f.f Δ'.len ≫ if h : Δ' = Δ then eqToHom ⋯ else if h : Isδ₀ i then K'.d Δ'.len Δ.len else 0
tactic: unfold mapMono
state_before: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Preadditive C
K K' : ChainComplex C ℕ
f : K ⟶ K'
Δ Δ' Δ'' : SimplexCategory
i : Δ ⟶ Δ'
inst✝ : Mono i
⊢ (if h : Δ' = Δ then eqToHom ⋯ else if h : Isδ₀ i then K.d Δ'.len Δ.len else 0) ≫ f.f Δ.len =
    f.f Δ'.len ≫ if h : Δ' = Δ then eqToHom ⋯ else if h : Isδ₀ i then K'.d Δ'.len Δ.len else 0
state_after: case pos
C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Preadditive C
K K' : ChainComplex C ℕ
f : K ⟶ K'
Δ Δ' Δ'' : SimplexCategory
i : Δ ⟶ Δ'
inst✝ : Mono i
h : Δ' = Δ
⊢ eqToHom ⋯ ≫ f.f Δ.len = f.f Δ'.len ≫ eqToHom ⋯

case pos
C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Preadditive C
K K' : ChainComplex C ℕ
f : K ⟶ K'
Δ Δ' Δ'' : SimplexCategory
i : Δ ⟶ Δ'
inst✝ : Mono i
h : ¬Δ' = Δ
h✝ : Isδ₀ i
⊢ K.d Δ'.len Δ.len ≫ f.f Δ.len = f.f Δ'.len ≫ K'.d Δ'.len Δ.len

case neg
C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Preadditive C
K K' : ChainComplex C ℕ
f : K ⟶ K'
Δ Δ' Δ'' : SimplexCategory
i : Δ ⟶ Δ'
inst✝ : Mono i
h : ¬Δ' = Δ
h✝ : ¬Isδ₀ i
⊢ 0 ≫ f.f Δ.len = f.f Δ'.len ≫ 0
tactic: split_ifs with h
Theorem: IsCoprime.mul_add_left_left
File: Mathlib/RingTheory/Coprime/Basic.lean

Proof steps:
state_before: R : Type u
inst✝ : CommRing R
x y : R
h : IsCoprime x y
z : R
⊢ IsCoprime (y * z + x) y
state_after: R : Type u
inst✝ : CommRing R
x y : R
h : IsCoprime x y
z : R
⊢ IsCoprime (x + y * z) y
tactic: rw [add_comm]
state_before: R : Type u
inst✝ : CommRing R
x y : R
h : IsCoprime x y
z : R
⊢ IsCoprime (x + y * z) y
state_after: no goals
tactic: exact h.add_mul_left_left z
Theorem: SimpleGraph.edgeFinset_subset_edgeFinset
File: Mathlib/Combinatorics/SimpleGraph/Finite.lean

Proof steps:
state_before: V : Type u_1
G : SimpleGraph V
e : Sym2 V
G₁ G₂ : SimpleGraph V
inst✝² : Fintype ↑G.edgeSet
inst✝¹ : Fintype ↑G₁.edgeSet
inst✝ : Fintype ↑G₂.edgeSet
⊢ G₁.edgeFinset ⊆ G₂.edgeFinset ↔ G₁ ≤ G₂
state_after: no goals
tactic: simp
Theorem: Complex.betaIntegral_eval_nat_add_one_right
File: Mathlib/Analysis/SpecialFunctions/Gamma/Beta.lean

Proof steps:
state_before: u : ℂ
hu : 0 < u.re
n : ℕ
⊢ u.betaIntegral (↑n + 1) = ↑n ! / ∏ j ∈ Finset.range (n + 1), (u + ↑j)
state_after: case zero
u : ℂ
hu : 0 < u.re
⊢ u.betaIntegral (↑0 + 1) = ↑0! / ∏ j ∈ Finset.range (0 + 1), (u + ↑j)

case succ
n : ℕ
IH : ∀ {u : ℂ}, 0 < u.re → u.betaIntegral (↑n + 1) = ↑n ! / ∏ j ∈ Finset.range (n + 1), (u + ↑j)
u : ℂ
hu : 0 < u.re
⊢ u.betaIntegral (↑(n + 1) + 1) = ↑(n + 1)! / ∏ j ∈ Finset.range (n + 1 + 1), (u + ↑j)
tactic: induction' n with n IH generalizing u
Theorem: interior_Icc
File: Mathlib/Topology/Order/DenselyOrdered.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝⁵ : TopologicalSpace α
inst✝⁴ : LinearOrder α
inst✝³ : OrderTopology α
inst✝² : DenselyOrdered α
a✝ b✝ : α
s : Set α
inst✝¹ : NoMinOrder α
inst✝ : NoMaxOrder α
a b : α
⊢ interior (Icc a b) = Ioo a b
state_after: no goals
tactic: rw [← Ici_inter_Iic, interior_inter, interior_Ici, interior_Iic, Ioi_inter_Iio]
Theorem: Filter.seq_assoc
File: Mathlib/Order/Filter/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l x : Filter α
g : Filter (α → β)
h : Filter (β → γ)
⊢ h.seq (g.seq x) = ((map (fun x x_1 => x ∘ x_1) h).seq g).seq x
state_after: case refine_1
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l x : Filter α
g : Filter (α → β)
h : Filter (β → γ)
s : Set (α → γ)
hs : s ∈ (map (fun x x_1 => x ∘ x_1) h).seq g
t : Set α
ht : t ∈ x
⊢ s.seq t ∈ h.seq (g.seq x)

case refine_2
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l x : Filter α
g : Filter (α → β)
h : Filter (β → γ)
s : Set (β → γ)
hs : s ∈ h
t : Set β
ht : t ∈ g.seq x
⊢ s.seq t ∈ ((map (fun x x_1 => x ∘ x_1) h).seq g).seq x
tactic: refine le_antisymm (le_seq fun s hs t ht => ?_) (le_seq fun s hs t ht => ?_)
Theorem: affineSegment_comm
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 y : P
⊢ affineSegment R x y = affineSegment R y x
state_after: 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 y z : P
⊢ z ∈ affineSegment R x y ↔ z ∈ affineSegment R y x
tactic: refine Set.ext fun z => ?_
Theorem: ProbabilityTheory.condIndepFun_iff_condIndepSet_preimage
File: Mathlib/Probability/Independence/Conditional.lean

Proof steps:
state_before: Ω : Type u_1
ι : Type u_2
β : Type u_3
β' : Type u_4
m' mΩ : MeasurableSpace Ω
inst✝² : StandardBorelSpace Ω
inst✝¹ : Nonempty Ω
hm' : m' ≤ mΩ
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
f : Ω → β
g : Ω → β'
mβ : MeasurableSpace β
mβ' : MeasurableSpace β'
hf : Measurable f
hg : Measurable g
⊢ CondIndepFun m' hm' f g μ ↔
    ∀ (s : Set β) (t : Set β'), MeasurableSet s → MeasurableSet t → CondIndepSet m' hm' (f ⁻¹' s) (g ⁻¹' t) μ
state_after: no goals
tactic: simp only [CondIndepFun, CondIndepSet, Kernel.indepFun_iff_indepSet_preimage hf hg]
Theorem: Nat.Partrec.Code.curry_inj
File: Mathlib/Computability/PartrecCode.lean

Proof steps:
state_before: c₁ c₂ : Code
n₁ n₂ : ℕ
h : c₁.curry n₁ = c₂.curry n₂
⊢ c₁ = c₂
state_after: no goals
tactic: injection h
state_before: c₁ c₂ : Code
n₁ n₂ : ℕ
h : c₁.curry n₁ = c₂.curry n₂
⊢ n₁ = n₂
state_after: c₁ c₂ : Code
n₁ n₂ : ℕ
h₁ : c₁ = c₂
h₂ : (Code.const n₁).pair Code.id = (Code.const n₂).pair Code.id
⊢ n₁ = n₂
tactic: injection h with h₁ h₂
state_before: c₁ c₂ : Code
n₁ n₂ : ℕ
h₁ : c₁ = c₂
h₂ : (Code.const n₁).pair Code.id = (Code.const n₂).pair Code.id
⊢ n₁ = n₂
state_after: c₁ c₂ : Code
n₁ n₂ : ℕ
h₁ : c₁ = c₂
h₃ : Code.const n₁ = Code.const n₂
h₄ : Code.id = Code.id
⊢ n₁ = n₂
tactic: injection h₂ with h₃ h₄
state_before: c₁ c₂ : Code
n₁ n₂ : ℕ
h₁ : c₁ = c₂
h₃ : Code.const n₁ = Code.const n₂
h₄ : Code.id = Code.id
⊢ n₁ = n₂
state_after: no goals
tactic: exact const_inj h₃
Theorem: integrableOn_Ico_iff_integrableOn_Ioo
File: Mathlib/MeasureTheory/Integral/IntegrableOn.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝⁴ : MeasurableSpace α
inst✝³ : NormedAddCommGroup E
inst✝² : PartialOrder α
inst✝¹ : MeasurableSingletonClass α
f : α → E
μ : Measure α
a b : α
inst✝ : NoAtoms μ
⊢ μ {a} ≠ ⊤
state_after: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝⁴ : MeasurableSpace α
inst✝³ : NormedAddCommGroup E
inst✝² : PartialOrder α
inst✝¹ : MeasurableSingletonClass α
f : α → E
μ : Measure α
a b : α
inst✝ : NoAtoms μ
⊢ 0 ≠ ⊤
tactic: rw [measure_singleton]
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝⁴ : MeasurableSpace α
inst✝³ : NormedAddCommGroup E
inst✝² : PartialOrder α
inst✝¹ : MeasurableSingletonClass α
f : α → E
μ : Measure α
a b : α
inst✝ : NoAtoms μ
⊢ 0 ≠ ⊤
state_after: no goals
tactic: exact ENNReal.zero_ne_top
Theorem: AddLECancellable.le_tsub_iff_le_tsub
File: Mathlib/Algebra/Order/Sub/Canonical.lean

Proof steps:
state_before: α : Type u_1
inst✝⁵ : AddCommSemigroup α
inst✝⁴ : PartialOrder α
inst✝³ : ExistsAddOfLE α
inst✝² : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
ha : AddLECancellable a
hc : AddLECancellable c
h₁ : a ≤ b
h₂ : c ≤ b
⊢ a ≤ b - c ↔ c ≤ b - a
state_after: no goals
tactic: rw [ha.le_tsub_iff_left h₁, hc.le_tsub_iff_right h₂]
Theorem: Set.indicator_eq_self_of_superset
File: Mathlib/Algebra/Group/Indicator.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
M : Type u_4
N : Type u_5
inst✝¹ : One M
inst✝ : One N
s t : Set α
f g : α → M
a : α
h1 : s.mulIndicator f = f
h2 : s ⊆ t
⊢ t.mulIndicator f = f
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
M : Type u_4
N : Type u_5
inst✝¹ : One M
inst✝ : One N
s t : Set α
f g : α → M
a : α
h1 : mulSupport f ⊆ s
h2 : s ⊆ t
⊢ mulSupport f ⊆ t
tactic: rw [mulIndicator_eq_self] at h1 ⊢
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
M : Type u_4
N : Type u_5
inst✝¹ : One M
inst✝ : One N
s t : Set α
f g : α → M
a : α
h1 : mulSupport f ⊆ s
h2 : s ⊆ t
⊢ mulSupport f ⊆ t
state_after: no goals
tactic: exact Subset.trans h1 h2
Theorem: Real.sqrt_lt_sqrt_iff_of_pos
File: Mathlib/Data/Real/Sqrt.lean

Proof steps:
state_before: x y : ℝ
hy : 0 < y
⊢ √x < √y ↔ x < y
state_after: no goals
tactic: rw [Real.sqrt, Real.sqrt, NNReal.coe_lt_coe, NNReal.sqrt_lt_sqrt, toNNReal_lt_toNNReal_iff hy]
Theorem: SupPrime.ne_bot
File: Mathlib/Order/Irreducible.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : SemilatticeSup α
a b c : α
inst✝ : OrderBot α
s : Finset ι
f : ι → α
ha : SupPrime a
⊢ a ≠ ⊥
state_after: ι : Type u_1
α : Type u_2
inst✝¹ : SemilatticeSup α
b c : α
inst✝ : OrderBot α
s : Finset ι
f : ι → α
ha : SupPrime ⊥
⊢ False
tactic: rintro rfl
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : SemilatticeSup α
b c : α
inst✝ : OrderBot α
s : Finset ι
f : ι → α
ha : SupPrime ⊥
⊢ False
state_after: no goals
tactic: exact not_supPrime_bot ha
Theorem: TwoSidedIdeal.ringCon_injective
File: Mathlib/RingTheory/TwoSidedIdeal/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝ : NonUnitalNonAssocRing R
I : TwoSidedIdeal R
⊢ Function.Injective ringCon
state_after: case mk.mk
R : Type u_1
inst✝ : NonUnitalNonAssocRing R
I : TwoSidedIdeal R
x : RingCon R
⊢ { ringCon := x } = { ringCon := { ringCon := x }.ringCon }
tactic: rintro ⟨x⟩ ⟨y⟩ rfl
state_before: case mk.mk
R : Type u_1
inst✝ : NonUnitalNonAssocRing R
I : TwoSidedIdeal R
x : RingCon R
⊢ { ringCon := x } = { ringCon := { ringCon := x }.ringCon }
state_after: no goals
tactic: rfl
Theorem: Set.insert_diff_eq_singleton
File: Mathlib/Data/Set/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a✝ b : α
s✝ s₁ s₂ t t₁ t₂ u : Set α
a : α
s : Set α
h : a ∉ s
⊢ insert a s \ s = {a}
state_after: case h
α : Type u
β : Type v
γ : Type w
ι : Sort x
a✝ b : α
s✝ s₁ s₂ t t₁ t₂ u : Set α
a : α
s : Set α
h : a ∉ s
x✝ : α
⊢ x✝ ∈ insert a s \ s ↔ x✝ ∈ {a}
tactic: ext
state_before: case h
α : Type u
β : Type v
γ : Type w
ι : Sort x
a✝ b : α
s✝ s₁ s₂ t t₁ t₂ u : Set α
a : α
s : Set α
h : a ∉ s
x✝ : α
⊢ x✝ ∈ insert a s \ s ↔ x✝ ∈ {a}
state_after: case h
α : Type u
β : Type v
γ : Type w
ι : Sort x
a✝ b : α
s✝ s₁ s₂ t t₁ t₂ u : Set α
a : α
s : Set α
h : a ∉ s
x✝ : α
⊢ x✝ = a → x✝ ∉ s
tactic: rw [Set.mem_diff, Set.mem_insert_iff, Set.mem_singleton_iff, or_and_right, and_not_self_iff,
    or_false_iff, and_iff_left_iff_imp]
state_before: case h
α : Type u
β : Type v
γ : Type w
ι : Sort x
a✝ b : α
s✝ s₁ s₂ t t₁ t₂ u : Set α
a : α
s : Set α
h : a ∉ s
x✝ : α
⊢ x✝ = a → x✝ ∉ s
state_after: case h
α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t t₁ t₂ u s : Set α
x✝ : α
h : x✝ ∉ s
⊢ x✝ ∉ s
tactic: rintro rfl
state_before: case h
α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t t₁ t₂ u s : Set α
x✝ : α
h : x✝ ∉ s
⊢ x✝ ∉ s
state_after: no goals
tactic: exact h
Theorem: differentiableAt_const_add_iff
File: Mathlib/Analysis/Calculus/FDeriv/Add.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
c : F
h : DifferentiableAt 𝕜 (fun y => c + f y) x
⊢ DifferentiableAt 𝕜 f x
state_after: no goals
tactic: simpa using h.const_add (-c)
Theorem: Lagrange.natDegree_nodal
File: Mathlib/LinearAlgebra/Lagrange.lean

Proof steps:
state_before: R : Type u_1
inst✝¹ : CommRing R
ι : Type u_2
s : Finset ι
v : ι → R
inst✝ : Nontrivial R
⊢ (nodal s v).natDegree = s.card
state_after: no goals
tactic: simp_rw [nodal, natDegree_prod_of_monic (h := fun i _ => monic_X_sub_C (v i)),
    natDegree_X_sub_C, sum_const, smul_eq_mul, mul_one]
Theorem: Equiv.Perm.two_le_card_support_cycleOf_iff
File: Mathlib/GroupTheory/Perm/Cycle/Factors.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
x y : α
inst✝³ : DecidableRel f.SameCycle
inst✝² : DecidableRel g.SameCycle
inst✝¹ : DecidableEq α
inst✝ : Fintype α
⊢ 2 ≤ (f.cycleOf x).support.card ↔ f x ≠ x
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
x y : α
inst✝³ : DecidableRel f.SameCycle
inst✝² : DecidableRel g.SameCycle
inst✝¹ : DecidableEq α
inst✝ : Fintype α
h : 2 ≤ (f.cycleOf x).support.card
⊢ f x ≠ x
tactic: refine ⟨fun h => ?_, fun h => by simpa using (isCycle_cycleOf _ h).two_le_card_support⟩
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
x y : α
inst✝³ : DecidableRel f.SameCycle
inst✝² : DecidableRel g.SameCycle
inst✝¹ : DecidableEq α
inst✝ : Fintype α
h : 2 ≤ (f.cycleOf x).support.card
⊢ f x ≠ x
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
x y : α
inst✝³ : DecidableRel f.SameCycle
inst✝² : DecidableRel g.SameCycle
inst✝¹ : DecidableEq α
inst✝ : Fintype α
h : f x = x
⊢ (f.cycleOf x).support.card < 2
tactic: contrapose! h
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
x y : α
inst✝³ : DecidableRel f.SameCycle
inst✝² : DecidableRel g.SameCycle
inst✝¹ : DecidableEq α
inst✝ : Fintype α
h : f x = x
⊢ (f.cycleOf x).support.card < 2
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
x y : α
inst✝³ : DecidableRel f.SameCycle
inst✝² : DecidableRel g.SameCycle
inst✝¹ : DecidableEq α
inst✝ : Fintype α
h : f.cycleOf x = 1
⊢ (f.cycleOf x).support.card < 2
tactic: rw [← cycleOf_eq_one_iff] at h
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
x y : α
inst✝³ : DecidableRel f.SameCycle
inst✝² : DecidableRel g.SameCycle
inst✝¹ : DecidableEq α
inst✝ : Fintype α
h : f.cycleOf x = 1
⊢ (f.cycleOf x).support.card < 2
state_after: no goals
tactic: simp [h]
Theorem: ContinuousLinearMapWOT.add_apply
File: Mathlib/Analysis/Normed/Operator/WeakOperatorTopology.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁵ : RCLike 𝕜
inst✝⁴ : AddCommGroup E
inst✝³ : TopologicalSpace E
inst✝² : Module 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
f g : E →WOT[𝕜]F
x : E
⊢ (f + g) x = f x + g x
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁵ : RCLike 𝕜
inst✝⁴ : AddCommGroup E
inst✝³ : TopologicalSpace E
inst✝² : Module 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
f g : E →WOT[𝕜]F
x : E
⊢ (↑(EquivLike.coe (ContinuousLinearMap.toWOT 𝕜 E F).symm (f + g))).toFun x =
    (↑(EquivLike.coe (ContinuousLinearMap.toWOT 𝕜 E F).symm f)).toFun x +
      (↑(EquivLike.coe (ContinuousLinearMap.toWOT 𝕜 E F).symm g)).toFun x
tactic: simp only [DFunLike.coe]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁵ : RCLike 𝕜
inst✝⁴ : AddCommGroup E
inst✝³ : TopologicalSpace E
inst✝² : Module 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
f g : E →WOT[𝕜]F
x : E
⊢ (↑(EquivLike.coe (ContinuousLinearMap.toWOT 𝕜 E F).symm (f + g))).toFun x =
    (↑(EquivLike.coe (ContinuousLinearMap.toWOT 𝕜 E F).symm f)).toFun x +
      (↑(EquivLike.coe (ContinuousLinearMap.toWOT 𝕜 E F).symm g)).toFun x
state_after: no goals
tactic: rfl
Theorem: LiouvilleWith.int_add_iff
File: Mathlib/NumberTheory/Liouville/LiouvilleWith.lean

Proof steps:
state_before: p q x y : ℝ
r : ℚ
m : ℤ
n : ℕ
⊢ LiouvilleWith p (↑m + x) ↔ LiouvilleWith p x
state_after: no goals
tactic: rw [add_comm, add_int_iff]
Theorem: BoundedContinuousFunction.norm_eq
File: Mathlib/Topology/ContinuousFunction/Bounded.lean

Proof steps:
state_before: F : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝¹ : TopologicalSpace α
inst✝ : SeminormedAddCommGroup β
f✝ g : α →ᵇ β
x : α
C : ℝ
f : α →ᵇ β
⊢ ‖f‖ = sInf {C | 0 ≤ C ∧ ∀ (x : α), ‖f x‖ ≤ C}
state_after: no goals
tactic: simp [norm_def, BoundedContinuousFunction.dist_eq]
Theorem: Metric.thickening_subset_cthickening
File: Mathlib/Topology/MetricSpace/Thickening.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ✝ ε : ℝ
s t : Set α
x : α
δ : ℝ
E : Set α
⊢ thickening δ E ⊆ cthickening δ E
state_after: ι : Sort u_1
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ✝ ε : ℝ
s t : Set α
x✝ : α
δ : ℝ
E : Set α
x : α
hx : x ∈ thickening δ E
⊢ x ∈ cthickening δ E
tactic: intro x hx
state_before: ι : Sort u_1
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ✝ ε : ℝ
s t : Set α
x✝ : α
δ : ℝ
E : Set α
x : α
hx : x ∈ thickening δ E
⊢ x ∈ cthickening δ E
state_after: ι : Sort u_1
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ✝ ε : ℝ
s t : Set α
x✝ : α
δ : ℝ
E : Set α
x : α
hx : infEdist x E < ENNReal.ofReal δ
⊢ x ∈ cthickening δ E
tactic: rw [thickening, mem_setOf_eq] at hx
state_before: ι : Sort u_1
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ✝ ε : ℝ
s t : Set α
x✝ : α
δ : ℝ
E : Set α
x : α
hx : infEdist x E < ENNReal.ofReal δ
⊢ x ∈ cthickening δ E
state_after: no goals
tactic: exact hx.le
Theorem: continuousAt_dslope_of_ne
File: Mathlib/Analysis/Calculus/Dslope.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f : 𝕜 → E
a b : 𝕜
s : Set 𝕜
h : b ≠ a
⊢ ContinuousAt (dslope f a) b ↔ ContinuousAt f b
state_after: no goals
tactic: simp only [← continuousWithinAt_univ, continuousWithinAt_dslope_of_ne h]
Theorem: FiniteDimensional.finrank_prod
File: Mathlib/LinearAlgebra/Dimension/Constructions.lean

Proof steps:
state_before: R S : Type u
M : Type v
M' : Type v'
M₁ : Type v
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝¹³ : Ring R
inst✝¹² : CommRing S
inst✝¹¹ : AddCommGroup M
inst✝¹⁰ : AddCommGroup M'
inst✝⁹ : AddCommGroup M₁
inst✝⁸ : Module R M
inst✝⁷ : Module R M'
inst✝⁶ : Module R M₁
inst✝⁵ : StrongRankCondition R
inst✝⁴ : Module.Free R M
inst✝³ : Module.Free R M'
inst✝² : Module.Free R M₁
inst✝¹ : Module.Finite R M
inst✝ : Module.Finite R M'
⊢ finrank R (M × M') = finrank R M + finrank R M'
state_after: no goals
tactic: simp [finrank, rank_lt_aleph0 R M, rank_lt_aleph0 R M']
Theorem: Nat.frequently_atTop_fermatPsp
File: Mathlib/NumberTheory/FermatPsp.lean

Proof steps:
state_before: b : ℕ
h : 1 ≤ b
⊢ ∃ᶠ (n : ℕ) in Filter.atTop, n.FermatPsp b
state_after: b : ℕ
h : 1 ≤ b
n : ℕ
⊢ ∃ b_1 ≥ n, b_1.FermatPsp b
tactic: refine Filter.frequently_atTop.2 fun n => ?_
state_before: b : ℕ
h : 1 ≤ b
n : ℕ
⊢ ∃ b_1 ≥ n, b_1.FermatPsp b
state_after: case intro
b : ℕ
h : 1 ≤ b
n p : ℕ
hp : p.FermatPsp b ∧ n ≤ p
⊢ ∃ b_1 ≥ n, b_1.FermatPsp b
tactic: obtain ⟨p, hp⟩ := exists_infinite_pseudoprimes h n
state_before: case intro
b : ℕ
h : 1 ≤ b
n p : ℕ
hp : p.FermatPsp b ∧ n ≤ p
⊢ ∃ b_1 ≥ n, b_1.FermatPsp b
state_after: no goals
tactic: exact ⟨p, hp.2, hp.1⟩
Theorem: LinearIndependent.fintype_card_le_finrank
File: Mathlib/LinearAlgebra/Dimension/Finite.lean

Proof steps:
state_before: R : Type u
M M₁ : Type v
M' : Type v'
ι✝ : Type w
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✝² : StrongRankCondition R
inst✝¹ : Module.Finite R M
ι : Type u_1
inst✝ : Fintype ι
b : ι → M
h : LinearIndependent R b
⊢ Fintype.card ι ≤ finrank R M
state_after: no goals
tactic: simpa using h.cardinal_mk_le_finrank
Theorem: Filter.Eventually.curry
File: Mathlib/Order/Filter/Prod.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s : Set α
t : Set β
f : Filter α
g : Filter β
la : Filter α
lb : Filter β
p : α × β → Prop
h : ∀ᶠ (x : α × β) in la ×ˢ lb, p x
⊢ ∀ᶠ (x : α) in la, ∀ᶠ (y : β) in lb, p (x, y)
state_after: case intro.intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s : Set α
t : Set β
f : Filter α
g : Filter β
la : Filter α
lb : Filter β
p : α × β → Prop
h✝ : ∀ᶠ (x : α × β) in la ×ˢ lb, p x
pa : α → Prop
ha : ∀ᶠ (x : α) in la, pa x
pb : β → Prop
hb : ∀ᶠ (y : β) in lb, pb y
h : ∀ {x : α}, pa x → ∀ {y : β}, pb y → p (x, y)
⊢ ∀ᶠ (x : α) in la, ∀ᶠ (y : β) in lb, p (x, y)
tactic: rcases eventually_prod_iff.1 h with ⟨pa, ha, pb, hb, h⟩
state_before: case intro.intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s : Set α
t : Set β
f : Filter α
g : Filter β
la : Filter α
lb : Filter β
p : α × β → Prop
h✝ : ∀ᶠ (x : α × β) in la ×ˢ lb, p x
pa : α → Prop
ha : ∀ᶠ (x : α) in la, pa x
pb : β → Prop
hb : ∀ᶠ (y : β) in lb, pb y
h : ∀ {x : α}, pa x → ∀ {y : β}, pb y → p (x, y)
⊢ ∀ᶠ (x : α) in la, ∀ᶠ (y : β) in lb, p (x, y)
state_after: no goals
tactic: exact ha.mono fun a ha => hb.mono fun b hb => h ha hb
Theorem: Nat.mul_div_eq_iff_dvd
File: Mathlib/Data/Nat/Defs.lean

Proof steps:
state_before: a b c d✝ m n✝ k : ℕ
p q : ℕ → Prop
n d : ℕ
⊢ d * (n / d) = n ↔ d * (n / d) = d * (n / d) + n % d
state_after: no goals
tactic: rw [div_add_mod]
state_before: a b c d✝ m n✝ k : ℕ
p q : ℕ → Prop
n d : ℕ
⊢ d * (n / d) = d * (n / d) + n % d ↔ d ∣ n
state_after: no goals
tactic: rw [eq_comm, Nat.add_eq_left, dvd_iff_mod_eq_zero]
Theorem: Polynomial.derivative_X
File: Mathlib/Algebra/Polynomial/Derivative.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Semiring R
⊢ (monomial (1 - 1)) (1 * ↑1) = 1
state_after: no goals
tactic: simp
Theorem: MeasureTheory.setIntegral_indicator
File: Mathlib/MeasureTheory/Integral/SetIntegral.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace X
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f g : X → E
s t : Set X
μ ν : Measure X
l l' : Filter X
ht : MeasurableSet t
⊢ ∫ (x : X) in s, t.indicator f x ∂μ = ∫ (x : X) in s ∩ t, f x ∂μ
state_after: no goals
tactic: rw [integral_indicator ht, Measure.restrict_restrict ht, Set.inter_comm]