ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: intervalIntegral.integral_neg
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

Proof steps:
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
a b : ℝ
f g : ℝ → E
μ : Measure ℝ
⊢ ∫ (x : ℝ) in a..b, -f x ∂μ = -∫ (x : ℝ) in a..b, f x ∂μ
state_after: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
a b : ℝ
f g : ℝ → E
μ : Measure ℝ
⊢ -∫ (a : ℝ) in Ioc a b, f a ∂μ - -∫ (a : ℝ) in Ioc b a, f a ∂μ =
    -(∫ (x : ℝ) in Ioc a b, f x ∂μ - ∫ (x : ℝ) in Ioc b a, f x ∂μ)
tactic: simp only [intervalIntegral, integral_neg]
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
a b : ℝ
f g : ℝ → E
μ : Measure ℝ
⊢ -∫ (a : ℝ) in Ioc a b, f a ∂μ - -∫ (a : ℝ) in Ioc b a, f a ∂μ =
    -(∫ (x : ℝ) in Ioc a b, f x ∂μ - ∫ (x : ℝ) in Ioc b a, f x ∂μ)
state_after: no goals
tactic: abel
Theorem: OrderAddMonoidHom.toOrderHom_injective
File: Mathlib/Algebra/Order/Hom/Monoid.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝⁷ : Preorder α
inst✝⁶ : Preorder β
inst✝⁵ : Preorder γ
inst✝⁴ : Preorder δ
inst✝³ : MulOneClass α
inst✝² : MulOneClass β
inst✝¹ : MulOneClass γ
inst✝ : MulOneClass δ
f✝ g✝ f g : α →*o β
h : f.toOrderHom = g.toOrderHom
⊢ ∀ (a : α), f a = g a
state_after: no goals
tactic: convert DFunLike.ext_iff.1 h using 0
Theorem: Complex.differentiable_at_Gamma_nat_add_one
File: Mathlib/NumberTheory/Harmonic/GammaDeriv.lean

Proof steps:
state_before: n : ℕ
⊢ DifferentiableAt ℂ Gamma (↑n + 1)
state_after: n m : ℕ
⊢ ↑n + 1 ≠ -↑m
tactic: refine differentiableAt_Gamma _ (fun m ↦ ?_)
state_before: n m : ℕ
⊢ ↑n + 1 ≠ -↑m
state_after: n m : ℕ
⊢ ¬↑n + 1 + ↑m = 0
tactic: simp only [Ne, ← ofReal_natCast, ← ofReal_one, ← ofReal_add, ← ofReal_neg, ofReal_inj,
    eq_neg_iff_add_eq_zero]
state_before: n m : ℕ
⊢ ¬↑n + 1 + ↑m = 0
state_after: no goals
tactic: positivity
Theorem: ProbabilityTheory.Kernel.setLIntegral_compProd_univ_right
File: Mathlib/Probability/Kernel/Composition.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s✝ : Set (β × γ)
κ : Kernel α β
inst✝¹ : IsSFiniteKernel κ
η : Kernel (α × β) γ
inst✝ : IsSFiniteKernel η
a : α
f : β × γ → ℝ≥0∞
hf : Measurable f
s : Set β
hs : MeasurableSet s
⊢ ∫⁻ (z : β × γ) in s ×ˢ Set.univ, f z ∂(κ ⊗ₖ η) a = ∫⁻ (x : β) in s, ∫⁻ (y : γ), f (x, y) ∂η (a, x) ∂κ a
state_after: no goals
tactic: simp_rw [setLIntegral_compProd κ η a hf hs MeasurableSet.univ, Measure.restrict_univ]
Theorem: ZMod.natCast_comp_val
File: Mathlib/Data/ZMod/Basic.lean

Proof steps:
state_before: n : ℕ
R : Type u_1
inst✝¹ : Ring R
inst✝ : NeZero n
⊢ Nat.cast ∘ val = cast
state_after: case zero
R : Type u_1
inst✝¹ : Ring R
inst✝ : NeZero 0
⊢ Nat.cast ∘ val = cast

case succ
R : Type u_1
inst✝¹ : Ring R
n✝ : ℕ
inst✝ : NeZero (n✝ + 1)
⊢ Nat.cast ∘ val = cast
tactic: cases n
state_before: case succ
R : Type u_1
inst✝¹ : Ring R
n✝ : ℕ
inst✝ : NeZero (n✝ + 1)
⊢ Nat.cast ∘ val = cast
state_after: no goals
tactic: rfl
Theorem: CategoryTheory.MonoidalFunctor.mapAction_toLaxMonoidalFunctor_toFunctor_obj_V
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
⊢ IsIso __src✝.ε
state_after: 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
⊢ IsIso { hom := F.ε, comm := ⋯ }
tactic: dsimp [mapActionLax]
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
⊢ IsIso { hom := F.ε, comm := ⋯ }
state_after: no goals
tactic: infer_instance
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), IsIso (__src✝.μ X Y)
state_after: 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), IsIso { hom := F.μ X.V Y.V, comm := ⋯ }
tactic: dsimp [mapActionLax]
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), IsIso { hom := F.μ X.V Y.V, comm := ⋯ }
state_after: no goals
tactic: infer_instance
Theorem: CompositionSeries.snoc_eraseLast_last
File: Mathlib/Order/JordanHolder.lean

Proof steps:
state_before: X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s : CompositionSeries X
h : IsMaximal (eraseLast s).last (last s)
hs : s.length = 0
⊢ last s = (eraseLast s).last
state_after: no goals
tactic: simp [last, Fin.ext_iff, hs]
Theorem: Nat.sInf_add'
File: Mathlib/Data/Nat/Lattice.lean

Proof steps:
state_before: n : ℕ
p : ℕ → Prop
h : 0 < sInf {m | p m}
⊢ sInf {m | p m} + n = sInf {m | p (m - n)}
state_after: n : ℕ
p : ℕ → Prop
h : 0 < sInf {m | p m}
⊢ n ≤ sInf {m | p (m - n)}
tactic: suffices h₁ : n ≤ sInf {m | p (m - n)} by
    convert sInf_add h₁
    simp_rw [Nat.add_sub_cancel_right]
state_before: n : ℕ
p : ℕ → Prop
h : 0 < sInf {m | p m}
⊢ n ≤ sInf {m | p (m - n)}
state_after: case intro
n : ℕ
p : ℕ → Prop
h : 0 < sInf {m | p m}
m : ℕ
hm : m ∈ {m | p m}
⊢ n ≤ sInf {m | p (m - n)}
tactic: obtain ⟨m, hm⟩ := nonempty_of_pos_sInf h
state_before: case intro
n : ℕ
p : ℕ → Prop
h : 0 < sInf {m | p m}
m : ℕ
hm : m ∈ {m | p m}
⊢ n ≤ sInf {m | p (m - n)}
state_after: case intro.refine_1
n : ℕ
p : ℕ → Prop
h : 0 < sInf {m | p m}
m : ℕ
hm : m ∈ {m | p m}
⊢ m + n ∈ {m | p (m - n)}

case intro.refine_2
n : ℕ
p : ℕ → Prop
h : 0 < sInf {m | p m}
m : ℕ
hm : m ∈ {m | p m}
b : ℕ
hb : b ∈ {m | p (m - n)}
hbn : b < n
⊢ b - n ∈ {m | p m}
tactic: refine
    le_csInf ⟨m + n, ?_⟩ fun b hb ↦
      le_of_not_lt fun hbn ↦
        ne_of_mem_of_not_mem ?_ (not_mem_of_lt_sInf h) (Nat.sub_eq_zero_of_le hbn.le)
Theorem: ProbabilityTheory.condCount_inter
File: Mathlib/Probability/CondCount.lean

Proof steps:
state_before: Ω : Type u_1
inst✝¹ : MeasurableSpace Ω
inst✝ : MeasurableSingletonClass Ω
s t u : Set Ω
hs : s.Finite
⊢ (condCount s) (t ∩ u) = (condCount (s ∩ t)) u * (condCount s) t
state_after: case pos
Ω : Type u_1
inst✝¹ : MeasurableSpace Ω
inst✝ : MeasurableSingletonClass Ω
s t u : Set Ω
hs : s.Finite
hst : s ∩ t = ∅
⊢ (condCount s) (t ∩ u) = (condCount (s ∩ t)) u * (condCount s) t

case neg
Ω : Type u_1
inst✝¹ : MeasurableSpace Ω
inst✝ : MeasurableSingletonClass Ω
s t u : Set Ω
hs : s.Finite
hst : ¬s ∩ t = ∅
⊢ (condCount s) (t ∩ u) = (condCount (s ∩ t)) u * (condCount s) t
tactic: by_cases hst : s ∩ t = ∅
state_before: case neg
Ω : Type u_1
inst✝¹ : MeasurableSpace Ω
inst✝ : MeasurableSingletonClass Ω
s t u : Set Ω
hs : s.Finite
hst : ¬s ∩ t = ∅
⊢ (condCount s) (t ∩ u) = (condCount (s ∩ t)) u * (condCount s) t
state_after: case neg.h0
Ω : Type u_1
inst✝¹ : MeasurableSpace Ω
inst✝ : MeasurableSingletonClass Ω
s t u : Set Ω
hs : s.Finite
hst : ¬s ∩ t = ∅
⊢ Measure.count (s ∩ t) ≠ 0

case neg.ht
Ω : Type u_1
inst✝¹ : MeasurableSpace Ω
inst✝ : MeasurableSingletonClass Ω
s t u : Set Ω
hs : s.Finite
hst : ¬s ∩ t = ∅
⊢ Measure.count (s ∩ t) ≠ ⊤
tactic: rw [condCount, condCount, cond_apply _ hs.measurableSet, cond_apply _ hs.measurableSet,
    cond_apply _ (hs.inter_of_left _).measurableSet, mul_comm _ (Measure.count (s ∩ t)),
    ← mul_assoc, mul_comm _ (Measure.count (s ∩ t)), ← mul_assoc, ENNReal.mul_inv_cancel, one_mul,
    mul_comm, Set.inter_assoc]
Theorem: Multiset.powersetCard_zero_left
File: Mathlib/Data/Multiset/Powerset.lean

Proof steps:
state_before: α : Type u_1
s : Multiset α
l : List α
⊢ powersetCard 0 ⟦l⟧ = {0}
state_after: no goals
tactic: simp [powersetCard_coe']
Theorem: SimpleGraph.adjMatrix_pow_apply_eq_card_walk
File: Mathlib/Combinatorics/SimpleGraph/AdjMatrix.lean

Proof steps:
state_before: V : Type u_1
α : Type u_2
β : Type u_3
G : SimpleGraph V
inst✝³ : DecidableRel G.Adj
inst✝² : Fintype V
inst✝¹ : DecidableEq V
inst✝ : Semiring α
n : ℕ
u v : V
⊢ (adjMatrix α G ^ n) u v = ↑(Fintype.card ↑{p | p.length = n})
state_after: V : Type u_1
α : Type u_2
β : Type u_3
G : SimpleGraph V
inst✝³ : DecidableRel G.Adj
inst✝² : Fintype V
inst✝¹ : DecidableEq V
inst✝ : Semiring α
n : ℕ
u v : V
⊢ (adjMatrix α G ^ n) u v = ↑(G.finsetWalkLength n u v).card
tactic: rw [card_set_walk_length_eq]
state_before: V : Type u_1
α : Type u_2
β : Type u_3
G : SimpleGraph V
inst✝³ : DecidableRel G.Adj
inst✝² : Fintype V
inst✝¹ : DecidableEq V
inst✝ : Semiring α
n : ℕ
u v : V
⊢ (adjMatrix α G ^ n) u v = ↑(G.finsetWalkLength n u v).card
state_after: case zero
V : Type u_1
α : Type u_2
β : Type u_3
G : SimpleGraph V
inst✝³ : DecidableRel G.Adj
inst✝² : Fintype V
inst✝¹ : DecidableEq V
inst✝ : Semiring α
u v : V
⊢ (adjMatrix α G ^ 0) u v = ↑(G.finsetWalkLength 0 u v).card

case succ
V : Type u_1
α : Type u_2
β : Type u_3
G : SimpleGraph V
inst✝³ : DecidableRel G.Adj
inst✝² : Fintype V
inst✝¹ : DecidableEq V
inst✝ : Semiring α
n : ℕ
ih : ∀ (u v : V), (adjMatrix α G ^ n) u v = ↑(G.finsetWalkLength n u v).card
u v : V
⊢ (adjMatrix α G ^ (n + 1)) u v = ↑(G.finsetWalkLength (n + 1) u v).card
tactic: induction' n with n ih generalizing u v
Theorem: Finite.card_eq_zero_of_surjective
File: Mathlib/Data/Finite/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f : α → β
hf : Function.Surjective f
h : Nat.card β = 0
⊢ Nat.card α = 0
state_after: case inl
α : Type u_1
β : Type u_2
γ : Type u_3
f : α → β
hf : Function.Surjective f
h : Nat.card β = 0
h✝ : Finite β
⊢ Nat.card α = 0

case inr
α : Type u_1
β : Type u_2
γ : Type u_3
f : α → β
hf : Function.Surjective f
h : Nat.card β = 0
h✝ : Infinite β
⊢ Nat.card α = 0
tactic: cases finite_or_infinite β
Theorem: FreeAddGroup.Red.Step.cons_left_iff
File: Mathlib/GroupTheory/FreeGroup/Basic.lean

Proof steps:
state_before: α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
a : α
b : Bool
⊢ Step ((a, b) :: L₁) L₂ ↔ (∃ L, Step L₁ L ∧ L₂ = (a, b) :: L) ∨ L₁ = (a, !b) :: L₂
state_after: case mp
α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
a : α
b : Bool
⊢ Step ((a, b) :: L₁) L₂ → (∃ L, Step L₁ L ∧ L₂ = (a, b) :: L) ∨ L₁ = (a, !b) :: L₂

case mpr
α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
a : α
b : Bool
⊢ (∃ L, Step L₁ L ∧ L₂ = (a, b) :: L) ∨ L₁ = (a, !b) :: L₂ → Step ((a, b) :: L₁) L₂
tactic: constructor
Theorem: hasSum_one_div_nat_pow_mul_fourier
File: Mathlib/NumberTheory/ZetaValues.lean

Proof steps:
state_before: k : ℕ
hk : 2 ≤ k
x : ℝ
hx : x ∈ Icc 0 1
⊢ HasSum (fun n => 1 / ↑n ^ k * ((fourier ↑n) ↑x + (-1) ^ k * (fourier (-↑n)) ↑x))
    (-(2 * ↑π * I) ^ k / ↑k ! * ↑(bernoulliFun k x))
state_after: case h.e'_5
k : ℕ
hk : 2 ≤ k
x : ℝ
hx : x ∈ Icc 0 1
⊢ (fun n => 1 / ↑n ^ k * ((fourier ↑n) ↑x + (-1) ^ k * (fourier (-↑n)) ↑x)) = fun n =>
    1 / ↑↑n ^ k * (fourier ↑n) ↑x + 1 / ↑(-↑n) ^ k * (fourier (-↑n)) ↑x

case h.e'_6
k : ℕ
hk : 2 ≤ k
x : ℝ
hx : x ∈ Icc 0 1
⊢ -(2 * ↑π * I) ^ k / ↑k ! * ↑(bernoulliFun k x) =
    -(2 * ↑π * I) ^ k / ↑k ! * ↑(bernoulliFun k x) + 1 / ↑0 ^ k * (fourier 0) ↑x
tactic: convert (hasSum_one_div_pow_mul_fourier_mul_bernoulliFun hk hx).nat_add_neg using 1
Theorem: Real.arccos_zero
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean

Proof steps:
state_before: x y : ℝ
⊢ arccos 0 = π / 2
state_after: no goals
tactic: simp [arccos]
Theorem: Irreducible.natSepDegree_eq_one_iff_of_monic'
File: Mathlib/FieldTheory/SeparableDegree.lean

Proof steps:
state_before: F : Type u
E : Type v
inst✝⁵ : Field F
inst✝⁴ : Field E
inst✝³ : Algebra F E
K : Type w
inst✝² : Field K
inst✝¹ : Algebra F K
f : F[X]
q : ℕ
inst✝ : ExpChar F q
hm : f.Monic
hi : Irreducible f
⊢ f.natSepDegree = 1 ↔ ∃ n y, f = (expand F (q ^ n)) (X - C y)
state_after: case refine_1
F : Type u
E : Type v
inst✝⁵ : Field F
inst✝⁴ : Field E
inst✝³ : Algebra F E
K : Type w
inst✝² : Field K
inst✝¹ : Algebra F K
f : F[X]
q : ℕ
inst✝ : ExpChar F q
hm : f.Monic
hi : Irreducible f
h : f.natSepDegree = 1
⊢ ∃ n y, f = (expand F (q ^ n)) (X - C y)

case refine_2
F : Type u
E : Type v
inst✝⁵ : Field F
inst✝⁴ : Field E
inst✝³ : Algebra F E
K : Type w
inst✝² : Field K
inst✝¹ : Algebra F K
f : F[X]
q : ℕ
inst✝ : ExpChar F q
hm : f.Monic
hi : Irreducible f
x✝ : ∃ n y, f = (expand F (q ^ n)) (X - C y)
n : ℕ
y : F
h : f = (expand F (q ^ n)) (X - C y)
⊢ f.natSepDegree = 1
tactic: refine ⟨fun h ↦ ?_, fun ⟨n, y, h⟩ ↦ ?_⟩
state_before: case refine_2
F : Type u
E : Type v
inst✝⁵ : Field F
inst✝⁴ : Field E
inst✝³ : Algebra F E
K : Type w
inst✝² : Field K
inst✝¹ : Algebra F K
f : F[X]
q : ℕ
inst✝ : ExpChar F q
hm : f.Monic
hi : Irreducible f
x✝ : ∃ n y, f = (expand F (q ^ n)) (X - C y)
n : ℕ
y : F
h : f = (expand F (q ^ n)) (X - C y)
⊢ f.natSepDegree = 1
state_after: no goals
tactic: rw [h, natSepDegree_expand _ q, natSepDegree_X_sub_C]
Theorem: ZMod.eq_iff_modEq_nat
File: Mathlib/Data/ZMod/Basic.lean

Proof steps:
state_before: m n✝ n a b : ℕ
⊢ ↑a = ↑b ↔ a ≡ b [MOD n]
state_after: case zero
m n a b : ℕ
⊢ ↑a = ↑b ↔ a ≡ b [MOD 0]

case succ
m n a b n✝ : ℕ
⊢ ↑a = ↑b ↔ a ≡ b [MOD n✝ + 1]
tactic: cases n
Theorem: List.Nat.antidiagonalTuple_one
File: Mathlib/Data/Fin/Tuple/NatAntidiagonal.lean

Proof steps:
state_before: n : ℕ
⊢ antidiagonalTuple 1 n = [![n]]
state_after: n : ℕ
⊢ ((range n).bind fun a => map (fun x => Fin.cons a x) (antidiagonalTuple 0 (n - a))) ++
      map (fun x => Fin.cons n x) (antidiagonalTuple 0 0) =
    [![n]]
tactic: simp_rw [antidiagonalTuple, antidiagonal, List.range_succ, List.map_append, List.map_singleton,
    tsub_self, List.append_bind, List.bind_singleton, List.bind_map]
state_before: n : ℕ
⊢ ((range n).bind fun a => map (fun x => Fin.cons a x) (antidiagonalTuple 0 (n - a))) ++
      map (fun x => Fin.cons n x) (antidiagonalTuple 0 0) =
    [![n]]
state_after: n : ℕ
⊢ ((range n).bind fun a => map (fun x => Fin.cons a x) (antidiagonalTuple 0 (n - a))) ++
      map (fun x => Fin.cons n x) (antidiagonalTuple 0 0) =
    [] ++ [![n]]
tactic: conv_rhs => rw [← List.nil_append [![n]]]
state_before: n : ℕ
⊢ ((range n).bind fun a => map (fun x => Fin.cons a x) (antidiagonalTuple 0 (n - a))) ++
      map (fun x => Fin.cons n x) (antidiagonalTuple 0 0) =
    [] ++ [![n]]
state_after: case e_a
n : ℕ
⊢ ((range n).bind fun a => map (fun x => Fin.cons a x) (antidiagonalTuple 0 (n - a))) = []
tactic: congr 1
state_before: case e_a
n : ℕ
⊢ ((range n).bind fun a => map (fun x => Fin.cons a x) (antidiagonalTuple 0 (n - a))) = []
state_after: case e_a
n : ℕ
⊢ ∀ x < n, antidiagonalTuple 0 (n - x) = []
tactic: simp_rw [List.bind_eq_nil, List.mem_range, List.map_eq_nil]
state_before: case e_a
n : ℕ
⊢ ∀ x < n, antidiagonalTuple 0 (n - x) = []
state_after: case e_a
n x : ℕ
hx : x < n
⊢ antidiagonalTuple 0 (n - x) = []
tactic: intro x hx
state_before: case e_a
n x : ℕ
hx : x < n
⊢ antidiagonalTuple 0 (n - x) = []
state_after: case e_a.intro
x m : ℕ
hx : x < x + m + 1
⊢ antidiagonalTuple 0 (x + m + 1 - x) = []
tactic: obtain ⟨m, rfl⟩ := Nat.exists_eq_add_of_lt hx
state_before: case e_a.intro
x m : ℕ
hx : x < x + m + 1
⊢ antidiagonalTuple 0 (x + m + 1 - x) = []
state_after: no goals
tactic: rw [add_assoc, add_tsub_cancel_left, antidiagonalTuple_zero_succ]
Theorem: BoxIntegral.hasIntegral_iff
File: Mathlib/Analysis/BoxIntegral/Basic.lean

Proof steps:
state_before: ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J : Box ι
π : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
⊢ (∀ (ib : ℝ),
      0 < ib →
        ∃ ia,
          (∀ (c : ℝ≥0), l.RCond (ia c)) ∧
            ∀ x ∈ {π | ∃ c, l.MemBaseSet I c (ia c) π ∧ π.IsPartition}, integralSum f vol x ∈ closedBall y ib) ↔
    ∀ ε > 0,
      ∃ r,
        (∀ (c : ℝ≥0), l.RCond (r c)) ∧
          ∀ (c : ℝ≥0) (π : TaggedPrepartition I),
            l.MemBaseSet I c (r c) π → π.IsPartition → dist (integralSum f vol π) y ≤ ε
state_after: no goals
tactic: simp [@forall_swap ℝ≥0 (TaggedPrepartition I)]
Theorem: GaussianFourier.norm_cexp_neg_mul_sq_add_mul_I'
File: Mathlib/Analysis/SpecialFunctions/Gaussian/FourierTransform.lean

Proof steps:
state_before: b : ℂ
hb : b.re ≠ 0
c T : ℝ
⊢ ‖cexp (-b * (↑T + ↑c * I) ^ 2)‖ = rexp (-(b.re * (T - b.im * c / b.re) ^ 2 - c ^ 2 * (b.im ^ 2 / b.re + b.re)))
state_after: b : ℂ
hb : b.re ≠ 0
c T : ℝ
this :
  b.re * T ^ 2 - 2 * b.im * c * T - b.re * c ^ 2 = b.re * (T - b.im * c / b.re) ^ 2 - c ^ 2 * (b.im ^ 2 / b.re + b.re)
⊢ ‖cexp (-b * (↑T + ↑c * I) ^ 2)‖ = rexp (-(b.re * (T - b.im * c / b.re) ^ 2 - c ^ 2 * (b.im ^ 2 / b.re + b.re)))
tactic: have :
    b.re * T ^ 2 - 2 * b.im * c * T - b.re * c ^ 2 =
      b.re * (T - b.im * c / b.re) ^ 2 - c ^ 2 * (b.im ^ 2 / b.re + b.re) := by
    field_simp; ring
state_before: b : ℂ
hb : b.re ≠ 0
c T : ℝ
this :
  b.re * T ^ 2 - 2 * b.im * c * T - b.re * c ^ 2 = b.re * (T - b.im * c / b.re) ^ 2 - c ^ 2 * (b.im ^ 2 / b.re + b.re)
⊢ ‖cexp (-b * (↑T + ↑c * I) ^ 2)‖ = rexp (-(b.re * (T - b.im * c / b.re) ^ 2 - c ^ 2 * (b.im ^ 2 / b.re + b.re)))
state_after: no goals
tactic: rw [norm_cexp_neg_mul_sq_add_mul_I, this]
Theorem: derivedSet_closure
File: Mathlib/Topology/DerivedSet.lean

Proof steps:
state_before: X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : T1Space X
A : Set X
⊢ derivedSet (closure A) = derivedSet A
state_after: X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : T1Space X
A : Set X
x : X
hx : x ∈ derivedSet (closure A)
⊢ x ∈ derivedSet A
tactic: refine le_antisymm (fun x hx => ?_) (derivedSet_mono _ _ subset_closure)
state_before: X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : T1Space X
A : Set X
x : X
hx : x ∈ derivedSet (closure A)
⊢ x ∈ derivedSet A
state_after: X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : T1Space X
A : Set X
x : X
hx : ∀ ⦃i : Set X⦄, x ∈ i ∧ IsOpen i → (i ∩ {x}ᶜ ∩ closure A).Nonempty
⊢ ∀ ⦃i : Set X⦄, x ∈ i ∧ IsOpen i → (i ∩ {x}ᶜ ∩ A).Nonempty
tactic: rw [mem_derivedSet, AccPt, (nhdsWithin_basis_open x {x}ᶜ).inf_principal_neBot_iff] at hx ⊢
state_before: X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : T1Space X
A : Set X
x : X
hx : ∀ ⦃i : Set X⦄, x ∈ i ∧ IsOpen i → (i ∩ {x}ᶜ ∩ closure A).Nonempty
⊢ ∀ ⦃i : Set X⦄, x ∈ i ∧ IsOpen i → (i ∩ {x}ᶜ ∩ A).Nonempty
state_after: case h.h
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : T1Space X
A : Set X
x : X
hx : ∀ ⦃i : Set X⦄, x ∈ i ∧ IsOpen i → (i ∩ {x}ᶜ ∩ closure A).Nonempty
u : Set X
hu : x ∈ u ∧ IsOpen u
this : (u ∩ {x}ᶜ ∩ closure A).Nonempty
⊢ (u ∩ {x}ᶜ ∩ A).Nonempty
tactic: peel hx with u hu _
state_before: case h.h
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : T1Space X
A : Set X
x : X
hx : ∀ ⦃i : Set X⦄, x ∈ i ∧ IsOpen i → (i ∩ {x}ᶜ ∩ closure A).Nonempty
u : Set X
hu : x ∈ u ∧ IsOpen u
this : (u ∩ {x}ᶜ ∩ closure A).Nonempty
⊢ (u ∩ {x}ᶜ ∩ A).Nonempty
state_after: case h.h.intro
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : T1Space X
A : Set X
x : X
hx : ∀ ⦃i : Set X⦄, x ∈ i ∧ IsOpen i → (i ∩ {x}ᶜ ∩ closure A).Nonempty
u : Set X
this : (u ∩ {x}ᶜ ∩ closure A).Nonempty
hu_open : IsOpen u
⊢ (u ∩ {x}ᶜ ∩ A).Nonempty
tactic: obtain ⟨-, hu_open⟩ := hu
state_before: case h.h.intro
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : T1Space X
A : Set X
x : X
hx : ∀ ⦃i : Set X⦄, x ∈ i ∧ IsOpen i → (i ∩ {x}ᶜ ∩ closure A).Nonempty
u : Set X
this : (u ∩ {x}ᶜ ∩ closure A).Nonempty
hu_open : IsOpen u
⊢ (u ∩ {x}ᶜ ∩ A).Nonempty
state_after: no goals
tactic: exact mem_closure_iff.mp this.some_mem.2 (u ∩ {x}ᶜ) (hu_open.inter isOpen_compl_singleton)
    this.some_mem.1
Theorem: IsMin.withTop
File: Mathlib/Order/WithBot.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a b : α
inst✝ : LE α
h : IsMin a
⊢ IsMin ↑a
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a b : α
inst✝ : LE α
h : IsMin a
b✝ : WithTop α
hb : b✝ ≤ ↑a
⊢ ↑a ≤ b✝
tactic: intro _ hb
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a b : α
inst✝ : LE α
h : IsMin a
b✝ : WithTop α
hb : b✝ ≤ ↑a
⊢ ↑a ≤ b✝
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a b : α
inst✝ : LE α
h : IsMin a
b✝ : WithTop α
hb : WithTop.toDual ↑a ≤ WithTop.toDual b✝
⊢ ↑a ≤ b✝
tactic: rw [← toDual_le_toDual_iff] at hb
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a b : α
inst✝ : LE α
h : IsMin a
b✝ : WithTop α
hb : WithTop.toDual ↑a ≤ WithTop.toDual b✝
⊢ ↑a ≤ b✝
state_after: no goals
tactic: simpa [toDual_le_iff] using h.toDual.withBot hb
Theorem: Set.OrdConnected.vadd
File: Mathlib/Algebra/Order/UpperLower.lean

Proof steps:
state_before: α : Type u_1
inst✝ : OrderedCommGroup α
s t : Set α
a : α
hs : s.OrdConnected
⊢ (a • s).OrdConnected
state_after: α : Type u_1
inst✝ : OrderedCommGroup α
s t : Set α
a : α
hs : s.OrdConnected
⊢ (a • ↑(upperClosure s) ∩ a • ↑(lowerClosure s)).OrdConnected
tactic: rw [← hs.upperClosure_inter_lowerClosure, smul_set_inter]
state_before: α : Type u_1
inst✝ : OrderedCommGroup α
s t : Set α
a : α
hs : s.OrdConnected
⊢ (a • ↑(upperClosure s) ∩ a • ↑(lowerClosure s)).OrdConnected
state_after: no goals
tactic: exact (upperClosure _).upper.smul.ordConnected.inter (lowerClosure _).lower.smul.ordConnected
Theorem: MeasureTheory.Measure.haar.prehaar_sup_le
File: Mathlib/MeasureTheory/Measure/Haar/Basic.lean

Proof steps:
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
U : Set G
K₁ K₂ : Compacts G
hU : (interior U).Nonempty
⊢ prehaar (↑K₀) U (K₁ ⊔ K₂) ≤ prehaar (↑K₀) U K₁ + prehaar (↑K₀) U K₂
state_after: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
U : Set G
K₁ K₂ : Compacts G
hU : (interior U).Nonempty
⊢ ↑(index (↑(K₁ ⊔ K₂)) U) / ↑(index (↑K₀) U) ≤ ↑(index (↑K₁) U) / ↑(index (↑K₀) U) + ↑(index (↑K₂) U) / ↑(index (↑K₀) U)
tactic: simp only [prehaar]
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
U : Set G
K₁ K₂ : Compacts G
hU : (interior U).Nonempty
⊢ ↑(index (↑(K₁ ⊔ K₂)) U) / ↑(index (↑K₀) U) ≤ ↑(index (↑K₁) U) / ↑(index (↑K₀) U) + ↑(index (↑K₂) U) / ↑(index (↑K₀) U)
state_after: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
U : Set G
K₁ K₂ : Compacts G
hU : (interior U).Nonempty
⊢ ↑(index (↑(K₁ ⊔ K₂)) U) ≤ ↑(index (↑K₁) U) + ↑(index (↑K₂) U)

G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
U : Set G
K₁ K₂ : Compacts G
hU : (interior U).Nonempty
⊢ 0 < ↑(index (↑K₀) U)
tactic: rw [div_add_div_same, div_le_div_right]
Theorem: CategoryTheory.ShortComplex.exact_and_epi_g_iff_of_iso
File: Mathlib/Algebra/Homology/ShortComplex/Exact.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝³ : Category.{u_3, u_1} C
inst✝² : Category.{?u.9092, u_2} D
inst✝¹ : HasZeroMorphisms C
inst✝ : HasZeroMorphisms D
S S₁ S₂ : ShortComplex C
e : S₁ ≅ S₂
⊢ S₁.Exact ∧ Epi S₁.g ↔ S₂.Exact ∧ Epi S₂.g
state_after: C : Type u_1
D : Type u_2
inst✝³ : Category.{u_3, u_1} C
inst✝² : Category.{?u.9092, u_2} D
inst✝¹ : HasZeroMorphisms C
inst✝ : HasZeroMorphisms D
S S₁ S₂ : ShortComplex C
e : S₁ ≅ S₂
this : Epi S₁.g ↔ Epi S₂.g
⊢ S₁.Exact ∧ Epi S₁.g ↔ S₂.Exact ∧ Epi S₂.g
tactic: have : Epi S₁.g ↔ Epi S₂.g :=
    (MorphismProperty.epimorphisms C).arrow_mk_iso_iff
      (Arrow.isoMk (ShortComplex.π₂.mapIso e) (ShortComplex.π₃.mapIso e) e.hom.comm₂₃)
state_before: C : Type u_1
D : Type u_2
inst✝³ : Category.{u_3, u_1} C
inst✝² : Category.{?u.9092, u_2} D
inst✝¹ : HasZeroMorphisms C
inst✝ : HasZeroMorphisms D
S S₁ S₂ : ShortComplex C
e : S₁ ≅ S₂
this : Epi S₁.g ↔ Epi S₂.g
⊢ S₁.Exact ∧ Epi S₁.g ↔ S₂.Exact ∧ Epi S₂.g
state_after: no goals
tactic: rw [exact_iff_of_iso e, this]