ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: integral_comp_neg_Iic
File: Mathlib/MeasureTheory/Measure/Lebesgue/Integral.lean

Proof steps:
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
c : ℝ
f : ℝ → E
⊢ ∫ (x : ℝ) in Iic c, f (-x) = ∫ (x : ℝ) in Ioi (-c), f x
state_after: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
c : ℝ
f : ℝ → E
A : MeasurableEmbedding fun x => -x
⊢ ∫ (x : ℝ) in Iic c, f (-x) = ∫ (x : ℝ) in Ioi (-c), f x
tactic: have A : MeasurableEmbedding fun x : ℝ => -x :=
    (Homeomorph.neg ℝ).closedEmbedding.measurableEmbedding
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
c : ℝ
f : ℝ → E
A : MeasurableEmbedding fun x => -x
⊢ ∫ (x : ℝ) in Iic c, f (-x) = ∫ (x : ℝ) in Ioi (-c), f x
state_after: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
c : ℝ
f : ℝ → E
A : MeasurableEmbedding fun x => -x
this : ∫ (y : ℝ) in Ici (-c), f y ∂Measure.map (fun x => -x) volume = ∫ (x : ℝ) in (fun x => -x) ⁻¹' Ici (-c), f (-x)
⊢ ∫ (x : ℝ) in Iic c, f (-x) = ∫ (x : ℝ) in Ioi (-c), f x
tactic: have := MeasurableEmbedding.setIntegral_map (μ := volume) A f (Ici (-c))
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
c : ℝ
f : ℝ → E
A : MeasurableEmbedding fun x => -x
this : ∫ (y : ℝ) in Ici (-c), f y ∂Measure.map (fun x => -x) volume = ∫ (x : ℝ) in (fun x => -x) ⁻¹' Ici (-c), f (-x)
⊢ ∫ (x : ℝ) in Iic c, f (-x) = ∫ (x : ℝ) in Ioi (-c), f x
state_after: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
c : ℝ
f : ℝ → E
A : MeasurableEmbedding fun x => -x
this : ∫ (y : ℝ) in Ici (-c), f y ∂volume = ∫ (x : ℝ) in (fun x => -x) ⁻¹' Ici (-c), f (-x)
⊢ ∫ (x : ℝ) in Iic c, f (-x) = ∫ (x : ℝ) in Ioi (-c), f x
tactic: rw [Measure.map_neg_eq_self (volume : Measure ℝ)] at this
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
c : ℝ
f : ℝ → E
A : MeasurableEmbedding fun x => -x
this : ∫ (y : ℝ) in Ici (-c), f y ∂volume = ∫ (x : ℝ) in (fun x => -x) ⁻¹' Ici (-c), f (-x)
⊢ ∫ (x : ℝ) in Iic c, f (-x) = ∫ (x : ℝ) in Ioi (-c), f x
state_after: no goals
tactic: simp_rw [← integral_Ici_eq_integral_Ioi, this, neg_preimage, preimage_neg_Ici, neg_neg]
Theorem: LocallyConstant.comap_injective
File: Mathlib/Topology/LocallyConstant/Basic.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
α : Type u_4
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
f : C(X, Y)
hfs : Function.Surjective f.toFun
⊢ Function.Injective (comap f)
state_after: X : Type u_1
Y : Type u_2
Z : Type u_3
α : Type u_4
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
f : C(X, Y)
hfs : Function.Surjective f.toFun
a b : LocallyConstant Y Z
h : comap f a = comap f b
⊢ a = b
tactic: intro a b h
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
α : Type u_4
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
f : C(X, Y)
hfs : Function.Surjective f.toFun
a b : LocallyConstant Y Z
h : comap f a = comap f b
⊢ a = b
state_after: case h
X : Type u_1
Y : Type u_2
Z : Type u_3
α : Type u_4
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
f : C(X, Y)
hfs : Function.Surjective f.toFun
a b : LocallyConstant Y Z
h : comap f a = comap f b
y : Y
⊢ a y = b y
tactic: ext y
state_before: case h
X : Type u_1
Y : Type u_2
Z : Type u_3
α : Type u_4
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
f : C(X, Y)
hfs : Function.Surjective f.toFun
a b : LocallyConstant Y Z
h : comap f a = comap f b
y : Y
⊢ a y = b y
state_after: case h.intro
X : Type u_1
Y : Type u_2
Z : Type u_3
α : Type u_4
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
f : C(X, Y)
hfs : Function.Surjective f.toFun
a b : LocallyConstant Y Z
h : comap f a = comap f b
y : Y
x : X
hx : f.toFun x = y
⊢ a y = b y
tactic: obtain ⟨x, hx⟩ := hfs y
state_before: case h.intro
X : Type u_1
Y : Type u_2
Z : Type u_3
α : Type u_4
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
f : C(X, Y)
hfs : Function.Surjective f.toFun
a b : LocallyConstant Y Z
h : comap f a = comap f b
y : Y
x : X
hx : f.toFun x = y
⊢ a y = b y
state_after: no goals
tactic: simpa [← hx] using LocallyConstant.congr_fun h x
Theorem: Equiv.Perm.decomposeOption_symm_apply
File: Mathlib/GroupTheory/Perm/Option.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
σ : Perm (Option α)
⊢ (fun i => swap none i.1 * optionCongr i.2) ((fun σ => (σ none, removeNone σ)) σ) = σ
state_after: no goals
tactic: simp
state_before: α : Type u_1
inst✝ : DecidableEq α
x✝ : Option α × Perm α
x : Option α
σ : Perm α
⊢ (fun σ => (σ none, removeNone σ)) ((fun i => swap none i.1 * optionCongr i.2) (x, σ)) = (x, σ)
state_after: α : Type u_1
inst✝ : DecidableEq α
x✝ : Option α × Perm α
x : Option α
σ : Perm α
this : removeNone (swap none x * optionCongr σ) = σ
⊢ (fun σ => (σ none, removeNone σ)) ((fun i => swap none i.1 * optionCongr i.2) (x, σ)) = (x, σ)
tactic: have : removeNone (swap none x * σ.optionCongr) = σ :=
      Equiv.optionCongr_injective (by simp [← mul_assoc])
state_before: α : Type u_1
inst✝ : DecidableEq α
x✝ : Option α × Perm α
x : Option α
σ : Perm α
this : removeNone (swap none x * optionCongr σ) = σ
⊢ (fun σ => (σ none, removeNone σ)) ((fun i => swap none i.1 * optionCongr i.2) (x, σ)) = (x, σ)
state_after: no goals
tactic: simp [← Perm.eq_inv_iff_eq, this]
Theorem: Real.pi_pos
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

Proof steps:
state_before: ⊢ 0 < 2
state_after: no goals
tactic: norm_num
Theorem: ChainClosure.isChain
File: Mathlib/Order/Chain.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
r : α → α → Prop
c c₁ c₂ c₃ s t : Set α
a b x y : α
hc : ChainClosure r c
⊢ IsChain r c
state_after: no goals
tactic: induction hc with
  | succ _ h => exact h.succ
  | union hs h =>
    exact fun c₁ ⟨t₁, ht₁, (hc₁ : c₁ ∈ t₁)⟩ c₂ ⟨t₂, ht₂, (hc₂ : c₂ ∈ t₂)⟩ hneq =>
      ((hs _ ht₁).total <| hs _ ht₂).elim (fun ht => h t₂ ht₂ (ht hc₁) hc₂ hneq) fun ht =>
        h t₁ ht₁ hc₁ (ht hc₂) hneq
Theorem: Tactic.ReduceModChar.CharP.neg_mul_eq_sub_one_mul
File: Mathlib/Tactic/ReduceModChar.lean

Proof steps:
state_before: u : Level
α : Type u_1
inst✝ : Ring α
n : ℕ
inst : CharP α n
a b : α
na : ℕ
na' : α
p : IsNat ((↑n - 1) * a) na
pa : ↑na = na'
⊢ -(a * b) = na' * b
state_after: u : Level
α : Type u_1
inst✝ : Ring α
n : ℕ
inst : CharP α n
a b : α
na : ℕ
na' : α
p : IsNat ((↑n - 1) * a) na
pa : ↑na = na'
⊢ -1 * (a * b) = (↑n - 1) * a * b
tactic: rw [← pa, ← p.out, ← neg_one_mul]
state_before: u : Level
α : Type u_1
inst✝ : Ring α
n : ℕ
inst : CharP α n
a b : α
na : ℕ
na' : α
p : IsNat ((↑n - 1) * a) na
pa : ↑na = na'
⊢ -1 * (a * b) = (↑n - 1) * a * b
state_after: no goals
tactic: simp
Theorem: DFinsupp.erase_def
File: Mathlib/Data/DFinsupp/Basic.lean

Proof steps:
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
inst✝ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
i : ι
f : Π₀ (i : ι), β i
⊢ erase i f = mk (f.support.erase i) fun j => f ↑j
state_after: case h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
inst✝ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
i : ι
f : Π₀ (i : ι), β i
j : ι
⊢ (erase i f) j = (mk (f.support.erase i) fun j => f ↑j) j
tactic: ext j
state_before: case h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
inst✝ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
i : ι
f : Π₀ (i : ι), β i
j : ι
⊢ (erase i f) j = (mk (f.support.erase i) fun j => f ↑j) j
state_after: no goals
tactic: by_cases h1 : j = i <;> by_cases h2 : f j ≠ 0 <;> simp at h2 <;> simp [h1, h2]
Theorem: dist_inf_sup_pi
File: Mathlib/Analysis/Normed/Order/UpperLower.lean

Proof steps:
state_before: α : Type u_1
ι : Type u_2
inst✝ : Fintype ι
s t : Set (ι → ℝ)
a₁ a₂ b₁ b₂ x✝ y✝ : ι → ℝ
δ : ℝ
x y : ι → ℝ
⊢ dist (x ⊓ y) (x ⊔ y) = dist x y
state_after: α : Type u_1
ι : Type u_2
inst✝ : Fintype ι
s t : Set (ι → ℝ)
a₁ a₂ b₁ b₂ x✝¹ y✝ : ι → ℝ
δ : ℝ
x y : ι → ℝ
i : ι
x✝ : i ∈ Finset.univ
⊢ nndist ((x ⊓ y) i) ((x ⊔ y) i) = nndist (x i) (y i)
tactic: refine congr_arg NNReal.toReal (Finset.sup_congr rfl fun i _ ↦ ?_)
state_before: α : Type u_1
ι : Type u_2
inst✝ : Fintype ι
s t : Set (ι → ℝ)
a₁ a₂ b₁ b₂ x✝¹ y✝ : ι → ℝ
δ : ℝ
x y : ι → ℝ
i : ι
x✝ : i ∈ Finset.univ
⊢ nndist ((x ⊓ y) i) ((x ⊔ y) i) = nndist (x i) (y i)
state_after: no goals
tactic: simp only [Real.nndist_eq', sup_eq_max, inf_eq_min, max_sub_min_eq_abs, Pi.inf_apply,
    Pi.sup_apply, Real.nnabs_of_nonneg, abs_nonneg, Real.toNNReal_abs]
Theorem: Equiv.swap_mem_stabilizer
File: Mathlib/GroupTheory/GroupAction/Basic.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
S : Set α
a b : α
⊢ swap a b ∈ MulAction.stabilizer (Perm α) S ↔ (a ∈ S ↔ b ∈ S)
state_after: α : Type u_1
inst✝ : DecidableEq α
S : Set α
a b : α
⊢ (∀ (x : α), x ∈ (swap a b)⁻¹ • S ↔ x ∈ S) ↔ (a ∈ S ↔ b ∈ S)
tactic: rw [MulAction.mem_stabilizer_iff, Set.ext_iff, ← swap_inv]
state_before: α : Type u_1
inst✝ : DecidableEq α
S : Set α
a b : α
⊢ (∀ (x : α), x ∈ (swap a b)⁻¹ • S ↔ x ∈ S) ↔ (a ∈ S ↔ b ∈ S)
state_after: α : Type u_1
inst✝ : DecidableEq α
S : Set α
a b : α
⊢ (∀ (x : α), (if x = a then b else if x = b then a else x) ∈ S ↔ x ∈ S) ↔ (a ∈ S ↔ b ∈ S)
tactic: simp_rw [Set.mem_inv_smul_set_iff, Perm.smul_def, swap_apply_def]
state_before: α : Type u_1
inst✝ : DecidableEq α
S : Set α
a b : α
⊢ (∀ (x : α), (if x = a then b else if x = b then a else x) ∈ S ↔ x ∈ S) ↔ (a ∈ S ↔ b ∈ S)
state_after: no goals
tactic: exact ⟨fun h ↦ by simpa [Iff.comm] using h a, by intros; split_ifs <;> simp [*]⟩
Theorem: List.inits_eq_tails
File: Mathlib/Data/List/Infix.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
l l₁ l₂ l₃ : List α
a b : α
m n : ℕ
⊢ [].inits = (map reverse [].reverse.tails).reverse
state_after: no goals
tactic: simp
state_before: α : Type u_1
β : Type u_2
l✝ l₁ l₂ l₃ : List α
a✝ b : α
m n : ℕ
a : α
l : List α
⊢ (a :: l).inits = (map reverse (a :: l).reverse.tails).reverse
state_after: no goals
tactic: simp [inits_eq_tails l, map_inj_left, ← map_reverse]
Theorem: MeasureTheory.measure_diff'
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t s : Set α
hm : MeasurableSet t
h_fin : μ t ≠ ⊤
⊢ μ (s \ t) + μ t = μ (s ∪ t)
state_after: no goals
tactic: rw [add_comm, measure_add_diff hm, union_comm]
Theorem: Collinear.wbtw_of_dist_eq_of_dist_le
File: Mathlib/Analysis/Convex/StrictConvexBetween.lean

Proof steps:
state_before: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : NormedSpace ℝ V
inst✝² : StrictConvexSpace ℝ V
inst✝¹ : PseudoMetricSpace P
inst✝ : NormedAddTorsor V P
p p₁ p₂ p₃ : P
r : ℝ
h : Collinear ℝ {p₁, p₂, p₃}
hp₁ : dist p₁ p = r
hp₂ : dist p₂ p ≤ r
hp₃ : dist p₃ p = r
hp₁p₃ : p₁ ≠ p₃
⊢ Wbtw ℝ p₁ p₂ p₃
state_after: case inl
V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : NormedSpace ℝ V
inst✝² : StrictConvexSpace ℝ V
inst✝¹ : PseudoMetricSpace P
inst✝ : NormedAddTorsor V P
p p₁ p₂ p₃ : P
r : ℝ
h : Collinear ℝ {p₁, p₂, p₃}
hp₁ : dist p₁ p = r
hp₂ : dist p₂ p ≤ r
hp₃ : dist p₃ p = r
hp₁p₃ : p₁ ≠ p₃
hw : Wbtw ℝ p₁ p₂ p₃
⊢ Wbtw ℝ p₁ p₂ p₃

case inr.inl
V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : NormedSpace ℝ V
inst✝² : StrictConvexSpace ℝ V
inst✝¹ : PseudoMetricSpace P
inst✝ : NormedAddTorsor V P
p p₁ p₂ p₃ : P
r : ℝ
h : Collinear ℝ {p₁, p₂, p₃}
hp₁ : dist p₁ p = r
hp₂ : dist p₂ p ≤ r
hp₃ : dist p₃ p = r
hp₁p₃ : p₁ ≠ p₃
hw : Wbtw ℝ p₂ p₃ p₁
⊢ Wbtw ℝ p₁ p₂ p₃

case inr.inr
V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : NormedSpace ℝ V
inst✝² : StrictConvexSpace ℝ V
inst✝¹ : PseudoMetricSpace P
inst✝ : NormedAddTorsor V P
p p₁ p₂ p₃ : P
r : ℝ
h : Collinear ℝ {p₁, p₂, p₃}
hp₁ : dist p₁ p = r
hp₂ : dist p₂ p ≤ r
hp₃ : dist p₃ p = r
hp₁p₃ : p₁ ≠ p₃
hw : Wbtw ℝ p₃ p₁ p₂
⊢ Wbtw ℝ p₁ p₂ p₃
tactic: rcases h.wbtw_or_wbtw_or_wbtw with (hw | hw | hw)
Theorem: HasFTaylorSeriesUpToOn.eq_iteratedFDerivWithin_of_uniqueDiffOn
File: Mathlib/Analysis/Calculus/ContDiff/Defs.lean

Proof steps:
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m✝ n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
h : HasFTaylorSeriesUpToOn n f p s
m : ℕ
hmn : ↑m ≤ n
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
⊢ p x m = iteratedFDerivWithin 𝕜 m f s x
state_after: case zero
𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x₀ : E
c : F
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
h : HasFTaylorSeriesUpToOn n f p s
hs : UniqueDiffOn 𝕜 s
x : E
hmn : ↑0 ≤ n
hx : x ∈ s
⊢ p x 0 = iteratedFDerivWithin 𝕜 0 f s x

case succ
𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x₀ : E
c : F
m✝ n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
h : HasFTaylorSeriesUpToOn n f p s
hs : UniqueDiffOn 𝕜 s
m : ℕ
IH : ∀ {x : E}, ↑m ≤ n → x ∈ s → p x m = iteratedFDerivWithin 𝕜 m f s x
x : E
hmn : ↑(m + 1) ≤ n
hx : x ∈ s
⊢ p x (m + 1) = iteratedFDerivWithin 𝕜 (m + 1) f s x
tactic: induction' m with m IH generalizing x
Theorem: Orientation.kahler_comp_rightAngleRotation
File: Mathlib/Analysis/InnerProductSpace/TwoDim.lean

Proof steps:
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace ℝ E
inst✝ : Fact (finrank ℝ E = 2)
o : Orientation ℝ E (Fin 2)
x y : E
⊢ (o.kahler (o.rightAngleRotation x)) (o.rightAngleRotation y) = (o.kahler x) y
state_after: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace ℝ E
inst✝ : Fact (finrank ℝ E = 2)
o : Orientation ℝ E (Fin 2)
x y : E
⊢ Complex.I * (-Complex.I * (o.kahler x) y) = (o.kahler x) y
tactic: simp only [kahler_rightAngleRotation_left, kahler_rightAngleRotation_right]
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace ℝ E
inst✝ : Fact (finrank ℝ E = 2)
o : Orientation ℝ E (Fin 2)
x y : E
⊢ Complex.I * (-Complex.I * (o.kahler x) y) = (o.kahler x) y
state_after: no goals
tactic: linear_combination -o.kahler x y * Complex.I_sq
Theorem: Filter.frequently_or_distrib_left
File: Mathlib/Order/Filter/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : Filter α
inst✝ : f.NeBot
p : Prop
q : α → Prop
⊢ (∃ᶠ (x : α) in f, p ∨ q x) ↔ p ∨ ∃ᶠ (x : α) in f, q x
state_after: no goals
tactic: simp
Theorem: add_le_iff_nonpos_right
File: Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝³ : MulOneClass α
inst✝² : LE α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝ : ContravariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b : α
⊢ a * b ≤ a ↔ a * b ≤ a * 1
state_after: no goals
tactic: rw [mul_one]
Theorem: max_div_min_eq_mabs'
File: Mathlib/Algebra/Order/Group/Unbundled/Abs.lean

Proof steps:
state_before: α : Type u_1
inst✝³ : Group α
inst✝² : LinearOrder α
a✝¹ b✝¹ : α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a✝ b✝ c : α
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b : α
⊢ max a b / min a b = mabs (a / b)
state_after: case inl
α : Type u_1
inst✝³ : Group α
inst✝² : LinearOrder α
a✝¹ b✝¹ : α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a✝ b✝ c : α
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b : α
ab : a ≤ b
⊢ max a b / min a b = mabs (a / b)

case inr
α : Type u_1
inst✝³ : Group α
inst✝² : LinearOrder α
a✝¹ b✝¹ : α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a✝ b✝ c : α
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b : α
ba : b ≤ a
⊢ max a b / min a b = mabs (a / b)
tactic: rcases le_total a b with ab | ba
Theorem: accPt_sup
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 : X
F G : Filter X
⊢ AccPt x (F ⊔ G) ↔ AccPt x F ∨ AccPt x G
state_after: no goals
tactic: simp only [AccPt, inf_sup_left, sup_neBot]
Theorem: ContinuousMap.cancel_left
File: Mathlib/Topology/ContinuousFunction/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f✝ g : C(α, β)
f : C(β, γ)
g₁ g₂ : C(α, β)
hf : Injective ⇑f
h : f.comp g₁ = f.comp g₂
a : α
⊢ f (g₁ a) = f (g₂ a)
state_after: no goals
tactic: rw [← comp_apply, h, comp_apply]
Theorem: PowerSeries.coeff_zero_X_mul
File: Mathlib/RingTheory/PowerSeries/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Semiring R
φ : R⟦X⟧
⊢ (coeff R 0) (X * φ) = 0
state_after: no goals
tactic: simp
Theorem: WeierstrassCurve.Jacobian.Point.toAffine_some
File: Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean

Proof steps:
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
X Y : F
h : W.Nonsingular ![X, Y, 1]
⊢ toAffine W ![X, Y, 1] = Affine.Point.some ⋯
state_after: no goals
tactic: simp only [toAffine_of_Z_ne_zero h one_ne_zero, fin3_def_ext, one_pow, div_one]
Theorem: strictAnti_dual_iff
File: Mathlib/Order/Monotone/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type u_2
π : ι → Type u_3
r : α → α → Prop
inst✝¹ : Preorder α
inst✝ : Preorder β
f : α → β
s : Set α
⊢ StrictAnti (⇑toDual ∘ f ∘ ⇑ofDual) ↔ StrictAnti f
state_after: no goals
tactic: rw [strictAnti_toDual_comp_iff, strictMono_comp_ofDual_iff]
Theorem: Int.natAbs_even
File: Mathlib/Algebra/Ring/Int.lean

Proof steps:
state_before: m n : ℤ
⊢ Even n.natAbs ↔ Even n
state_after: no goals
tactic: simp [even_iff_two_dvd, dvd_natAbs, natCast_dvd.symm]
Theorem: Int.not_even_bit1
File: Mathlib/Algebra/Ring/Int.lean

Proof steps:
state_before: m n✝ n : ℤ
⊢ ¬Even (2 * n + 1)
state_after: no goals
tactic: simp [parity_simps]
Theorem: AddCommGroup.self_modEq_zero
File: Mathlib/Algebra/ModEq.lean

Proof steps:
state_before: α : Type u_1
inst✝ : AddCommGroup α
p a a₁ a₂ b b₁ b₂ c : α
n : ℕ
z : ℤ
⊢ 0 - p = -1 • p
state_after: no goals
tactic: simp
Theorem: SimpleGraph.exists_girth_eq_length
File: Mathlib/Combinatorics/SimpleGraph/Girth.lean

Proof steps:
state_before: α : Type u_1
G : SimpleGraph α
⊢ (∃ a w, w.IsCycle ∧ G.girth = w.length) ↔ ¬G.IsAcyclic
state_after: α : Type u_1
G : SimpleGraph α
h : ¬G.IsAcyclic
⊢ ∃ a w, w.IsCycle ∧ G.girth = w.length
tactic: refine ⟨by tauto, fun h ↦ ?_⟩
state_before: α : Type u_1
G : SimpleGraph α
h : ¬G.IsAcyclic
⊢ ∃ a w, w.IsCycle ∧ G.girth = w.length
state_after: case intro.intro
α : Type u_1
G : SimpleGraph α
h : ¬G.IsAcyclic
w✝¹ : α
w✝ : G.Walk w✝¹ w✝¹
h✝ : w✝.IsCycle ∧ G.egirth = ↑w✝.length
⊢ ∃ a w, w.IsCycle ∧ G.girth = w.length
tactic: obtain ⟨_, _, _⟩ := exists_egirth_eq_length.mpr h
state_before: case intro.intro
α : Type u_1
G : SimpleGraph α
h : ¬G.IsAcyclic
w✝¹ : α
w✝ : G.Walk w✝¹ w✝¹
h✝ : w✝.IsCycle ∧ G.egirth = ↑w✝.length
⊢ ∃ a w, w.IsCycle ∧ G.girth = w.length
state_after: case intro.intro
α : Type u_1
G : SimpleGraph α
h : ¬G.IsAcyclic
w✝¹ : α
w✝ : G.Walk w✝¹ w✝¹
h✝ : w✝.IsCycle ∧ G.egirth = ↑w✝.length
⊢ ∃ a w, w.IsCycle ∧ w✝.length = w.length
tactic: simp_all only [girth, ENat.toNat_coe]
state_before: case intro.intro
α : Type u_1
G : SimpleGraph α
h : ¬G.IsAcyclic
w✝¹ : α
w✝ : G.Walk w✝¹ w✝¹
h✝ : w✝.IsCycle ∧ G.egirth = ↑w✝.length
⊢ ∃ a w, w.IsCycle ∧ w✝.length = w.length
state_after: no goals
tactic: tauto
Theorem: Int.abs_ediv_le_abs
File: Mathlib/Algebra/Order/Group/Int.lean

Proof steps:
state_before: this : ∀ (a : ℤ) (n : ℕ), |a / ↑n| ≤ |a|
a b : ℤ
n : ℕ
⊢ |a / -↑n| ≤ |a|
state_after: this : ∀ (a : ℤ) (n : ℕ), |a / ↑n| ≤ |a|
a b : ℤ
n : ℕ
⊢ |a / ↑n| ≤ |a|
tactic: rw [Int.ediv_neg, abs_neg]
state_before: this : ∀ (a : ℤ) (n : ℕ), |a / ↑n| ≤ |a|
a b : ℤ
n : ℕ
⊢ |a / ↑n| ≤ |a|
state_after: no goals
tactic: apply this
state_before: a : ℤ
n : ℕ
⊢ |a / ↑n| ≤ |a|
state_after: a : ℤ
n : ℕ
⊢ ↑(a / ↑n).natAbs ≤ ↑a.natAbs
tactic: rw [abs_eq_natAbs, abs_eq_natAbs]
state_before: a : ℤ
n : ℕ
⊢ ↑(a / ↑n).natAbs ≤ ↑a.natAbs
state_after: no goals
tactic: exact ofNat_le_ofNat_of_le
    (match a, n with
      | (m : ℕ), n => Nat.div_le_self _ _
      | -[m+1], 0 => Nat.zero_le _
      | -[m+1], n + 1 => Nat.succ_le_succ (Nat.div_le_self _ _))
Theorem: Complex.arg_le_pi_div_two_iff
File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

Proof steps:
state_before: a x z✝ z : ℂ
⊢ z.arg ≤ π / 2 ↔ 0 ≤ z.re ∨ z.im < 0
state_after: case inl
a x z✝ z : ℂ
hre : 0 ≤ z.re
⊢ z.arg ≤ π / 2 ↔ 0 ≤ z.re ∨ z.im < 0

case inr
a x z✝ z : ℂ
hre : z.re < 0
⊢ z.arg ≤ π / 2 ↔ 0 ≤ z.re ∨ z.im < 0
tactic: rcases le_or_lt 0 (re z) with hre | hre
state_before: case inr
a x z✝ z : ℂ
hre : z.re < 0
⊢ z.arg ≤ π / 2 ↔ 0 ≤ z.re ∨ z.im < 0
state_after: case inr
a x z✝ z : ℂ
hre : z.re < 0
⊢ z.arg ≤ π / 2 ↔ z.im < 0
tactic: simp only [hre.not_le, false_or_iff]
state_before: case inr
a x z✝ z : ℂ
hre : z.re < 0
⊢ z.arg ≤ π / 2 ↔ z.im < 0
state_after: case inr.inl
a x z✝ z : ℂ
hre : z.re < 0
him : 0 ≤ z.im
⊢ z.arg ≤ π / 2 ↔ z.im < 0

case inr.inr
a x z✝ z : ℂ
hre : z.re < 0
him : z.im < 0
⊢ z.arg ≤ π / 2 ↔ z.im < 0
tactic: rcases le_or_lt 0 (im z) with him | him
Theorem: mem_leftCoset_leftCoset
File: Mathlib/GroupTheory/Coset.lean

Proof steps:
state_before: α : Type u_1
inst✝ : Monoid α
s : Submonoid α
a : α
ha : a • ↑s = ↑s
⊢ a ∈ s
state_after: α : Type u_1
inst✝ : Monoid α
s : Submonoid α
a : α
ha : a • ↑s = ↑s
⊢ a ∈ a • ↑s
tactic: rw [← SetLike.mem_coe, ← ha]
state_before: α : Type u_1
inst✝ : Monoid α
s : Submonoid α
a : α
ha : a • ↑s = ↑s
⊢ a ∈ a • ↑s
state_after: no goals
tactic: exact mem_own_leftCoset s a
Theorem: AnalyticOn.iterated_deriv
File: Mathlib/Analysis/Calculus/FDeriv/Analytic.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝⁵ : NontriviallyNormedField 𝕜
E : Type u
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace 𝕜 E
F : Type v
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 𝕜 F
r : ℝ≥0∞
f : 𝕜 → F
x : 𝕜
s : Set 𝕜
inst✝ : CompleteSpace F
h : AnalyticOn 𝕜 f s
n : ℕ
⊢ AnalyticOn 𝕜 (_root_.deriv^[n] f) s
state_after: case zero
𝕜 : Type u_1
inst✝⁵ : NontriviallyNormedField 𝕜
E : Type u
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace 𝕜 E
F : Type v
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 𝕜 F
r : ℝ≥0∞
f : 𝕜 → F
x : 𝕜
s : Set 𝕜
inst✝ : CompleteSpace F
h : AnalyticOn 𝕜 f s
⊢ AnalyticOn 𝕜 (_root_.deriv^[0] f) s

case succ
𝕜 : Type u_1
inst✝⁵ : NontriviallyNormedField 𝕜
E : Type u
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace 𝕜 E
F : Type v
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 𝕜 F
r : ℝ≥0∞
f : 𝕜 → F
x : 𝕜
s : Set 𝕜
inst✝ : CompleteSpace F
h : AnalyticOn 𝕜 f s
n : ℕ
IH : AnalyticOn 𝕜 (_root_.deriv^[n] f) s
⊢ AnalyticOn 𝕜 (_root_.deriv^[n + 1] f) s
tactic: induction' n with n IH