ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Set.univ_subtype
File: Mathlib/Data/Set/Lattice.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
p : α → Prop
x✝ : Subtype p
x : α
h : p x
⊢ ⟨x, h⟩ ∈ univ ↔ ⟨x, h⟩ ∈ ⋃ x, ⋃ (h : p x), {⟨x, h⟩}
state_after: no goals
tactic: simp [h]
Theorem: Matrix.vecMul_diagonal_const
File: Mathlib/Data/Matrix/Basic.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝³ : NonAssocSemiring α
inst✝² : Fintype m
inst✝¹ : Fintype n
inst✝ : DecidableEq m
x : α
v : m → α
⊢ (v ᵥ* diagonal fun x_1 => x) = MulOpposite.op x • v
state_after: case h
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝³ : NonAssocSemiring α
inst✝² : Fintype m
inst✝¹ : Fintype n
inst✝ : DecidableEq m
x : α
v : m → α
x✝ : m
⊢ (v ᵥ* diagonal fun x_1 => x) x✝ = (MulOpposite.op x • v) x✝
tactic: ext
state_before: case h
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝³ : NonAssocSemiring α
inst✝² : Fintype m
inst✝¹ : Fintype n
inst✝ : DecidableEq m
x : α
v : m → α
x✝ : m
⊢ (v ᵥ* diagonal fun x_1 => x) x✝ = (MulOpposite.op x • v) x✝
state_after: no goals
tactic: simp [vecMul_diagonal]
Theorem: conjugate_le_conjugate
File: Mathlib/Algebra/Star/Order.lean

Proof steps:
state_before: R : Type u
inst✝³ : NonUnitalSemiring R
inst✝² : PartialOrder R
inst✝¹ : StarRing R
inst✝ : StarOrderedRing R
a b : R
hab : a ≤ b
c : R
⊢ star c * a * c ≤ star c * b * c
state_after: R : Type u
inst✝³ : NonUnitalSemiring R
inst✝² : PartialOrder R
inst✝¹ : StarRing R
inst✝ : StarOrderedRing R
a b : R
hab : ∃ p ∈ AddSubmonoid.closure (range fun s => star s * s), b = a + p
c : R
⊢ ∃ p ∈ AddSubmonoid.closure (range fun s => star s * s), star c * b * c = star c * a * c + p
tactic: rw [StarOrderedRing.le_iff] at hab ⊢
state_before: R : Type u
inst✝³ : NonUnitalSemiring R
inst✝² : PartialOrder R
inst✝¹ : StarRing R
inst✝ : StarOrderedRing R
a b : R
hab : ∃ p ∈ AddSubmonoid.closure (range fun s => star s * s), b = a + p
c : R
⊢ ∃ p ∈ AddSubmonoid.closure (range fun s => star s * s), star c * b * c = star c * a * c + p
state_after: case intro.intro
R : Type u
inst✝³ : NonUnitalSemiring R
inst✝² : PartialOrder R
inst✝¹ : StarRing R
inst✝ : StarOrderedRing R
a c p : R
hp : p ∈ AddSubmonoid.closure (range fun s => star s * s)
⊢ ∃ p_1 ∈ AddSubmonoid.closure (range fun s => star s * s), star c * (a + p) * c = star c * a * c + p_1
tactic: obtain ⟨p, hp, rfl⟩ := hab
state_before: case intro.intro
R : Type u
inst✝³ : NonUnitalSemiring R
inst✝² : PartialOrder R
inst✝¹ : StarRing R
inst✝ : StarOrderedRing R
a c p : R
hp : p ∈ AddSubmonoid.closure (range fun s => star s * s)
⊢ ∃ p_1 ∈ AddSubmonoid.closure (range fun s => star s * s), star c * (a + p) * c = star c * a * c + p_1
state_after: case intro.intro
R : Type u
inst✝³ : NonUnitalSemiring R
inst✝² : PartialOrder R
inst✝¹ : StarRing R
inst✝ : StarOrderedRing R
a c p : R
hp : 0 ≤ p
⊢ ∃ p_1, 0 ≤ p_1 ∧ star c * (a + p) * c = star c * a * c + p_1
tactic: simp_rw [← StarOrderedRing.nonneg_iff] at hp ⊢
state_before: case intro.intro
R : Type u
inst✝³ : NonUnitalSemiring R
inst✝² : PartialOrder R
inst✝¹ : StarRing R
inst✝ : StarOrderedRing R
a c p : R
hp : 0 ≤ p
⊢ ∃ p_1, 0 ≤ p_1 ∧ star c * (a + p) * c = star c * a * c + p_1
state_after: no goals
tactic: exact ⟨star c * p * c, conjugate_nonneg hp c, by simp only [add_mul, mul_add]⟩
Theorem: Finset.fold_union_inter
File: Mathlib/Data/Finset/Fold.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
op : β → β → β
hc : Std.Commutative op
ha : Std.Associative op
f : α → β
b : β
s : Finset α
a : α
inst✝ : DecidableEq α
s₁ s₂ : Finset α
b₁ b₂ : β
⊢ op (fold op b₁ f (s₁ ∪ s₂)) (fold op b₂ f (s₁ ∩ s₂)) = op (fold op b₂ f s₁) (fold op b₁ f s₂)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
op : β → β → β
hc : Std.Commutative op
ha : Std.Associative op
f : α → β
b : β
s : Finset α
a : α
inst✝ : DecidableEq α
s₁ s₂ : Finset α
b₁ b₂ : β
⊢ op (Multiset.fold op b₁ (Multiset.map f (s₁ ∪ s₂).val)) (Multiset.fold op b₂ (Multiset.map f (s₁ ∩ s₂).val)) =
    op (Multiset.fold op b₂ (Multiset.map f s₁.val)) (Multiset.fold op b₁ (Multiset.map f s₂.val))
tactic: unfold fold
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
op : β → β → β
hc : Std.Commutative op
ha : Std.Associative op
f : α → β
b : β
s : Finset α
a : α
inst✝ : DecidableEq α
s₁ s₂ : Finset α
b₁ b₂ : β
⊢ op (Multiset.fold op b₁ (Multiset.map f (s₁ ∪ s₂).val)) (Multiset.fold op b₂ (Multiset.map f (s₁ ∩ s₂).val)) =
    op (Multiset.fold op b₂ (Multiset.map f s₁.val)) (Multiset.fold op b₁ (Multiset.map f s₂.val))
state_after: no goals
tactic: rw [← fold_add op, ← Multiset.map_add, union_val, inter_val, union_add_inter, Multiset.map_add,
    hc.comm, fold_add]
Theorem: Continuous.mulIndicator
File: Mathlib/Topology/ContinuousOn.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁵ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝⁴ : (i : ι) → TopologicalSpace (π i)
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
inst✝¹ : TopologicalSpace δ
inst✝ : One β
f : α → β
s : Set α
hs : ∀ a ∈ frontier s, f a = 1
hf : Continuous f
⊢ Continuous (s.mulIndicator f)
state_after: no goals
tactic: classical exact hf.piecewise hs continuous_const
Theorem: sub_mem_posTangentConeAt_of_segment_subset
File: Mathlib/Analysis/Calculus/LocalExtr/Basic.lean

Proof steps:
state_before: E : Type u
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : E → ℝ
f' : E →L[ℝ] ℝ
s : Set E
a x y : E
h : [x-[ℝ]y] ⊆ s
⊢ [x-[ℝ]x + (y - x)] ⊆ s
state_after: no goals
tactic: rwa [add_sub_cancel]
Theorem: Multiset.add_inter_distrib
File: Mathlib/Data/Multiset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s✝ t✝ u✝ : Multiset α
a b : α
s t u : Multiset α
⊢ s + t ∩ u = (s + t) ∩ (s + u)
state_after: no goals
tactic: rw [add_comm, inter_add_distrib, add_comm s, add_comm s]
Theorem: finsum_smul
File: Mathlib/Algebra/BigOperators/Finprod.lean

Proof steps:
state_before: G : Type u_1
M✝ : Type u_2
N : Type u_3
α : Sort u_4
β : Sort u_5
ι : Sort u_6
inst✝⁵ : CommMonoid M✝
inst✝⁴ : CommMonoid N
R : Type u_7
M : Type u_8
inst✝³ : Ring R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : NoZeroSMulDivisors R M
f : ι → R
x : M
⊢ (∑ᶠ (i : ι), f i) • x = ∑ᶠ (i : ι), f i • x
state_after: case inl
G : Type u_1
M✝ : Type u_2
N : Type u_3
α : Sort u_4
β : Sort u_5
ι : Sort u_6
inst✝⁵ : CommMonoid M✝
inst✝⁴ : CommMonoid N
R : Type u_7
M : Type u_8
inst✝³ : Ring R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : NoZeroSMulDivisors R M
f : ι → R
⊢ (∑ᶠ (i : ι), f i) • 0 = ∑ᶠ (i : ι), f i • 0

case inr
G : Type u_1
M✝ : Type u_2
N : Type u_3
α : Sort u_4
β : Sort u_5
ι : Sort u_6
inst✝⁵ : CommMonoid M✝
inst✝⁴ : CommMonoid N
R : Type u_7
M : Type u_8
inst✝³ : Ring R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : NoZeroSMulDivisors R M
f : ι → R
x : M
hx : x ≠ 0
⊢ (∑ᶠ (i : ι), f i) • x = ∑ᶠ (i : ι), f i • x
tactic: rcases eq_or_ne x 0 with (rfl | hx)
Theorem: TrivSqZeroExt.liftEquivOfComm_symm_apply_coe
File: Mathlib/Algebra/TrivSqZeroExt.lean

Proof steps:
state_before: S : Type u_1
R R' : Type u
M : Type v
inst✝¹⁸ : CommSemiring S
inst✝¹⁷ : Semiring R
inst✝¹⁶ : CommSemiring R'
inst✝¹⁵ : AddCommMonoid M
inst✝¹⁴ : Algebra S R
inst✝¹³ : Algebra S R'
inst✝¹² : Module S M
inst✝¹¹ : Module R M
inst✝¹⁰ : Module Rᵐᵒᵖ M
inst✝⁹ : SMulCommClass R Rᵐᵒᵖ M
inst✝⁸ : IsScalarTower S R M
inst✝⁷ : IsScalarTower S Rᵐᵒᵖ M
inst✝⁶ : Module R' M
inst✝⁵ : Module R'ᵐᵒᵖ M
inst✝⁴ : IsCentralScalar R' M
inst✝³ : IsScalarTower S R' M
A : Type u_2
inst✝² : Semiring A
inst✝¹ : Algebra S A
inst✝ : Algebra R' A
⊢ { f // ∀ (x y : M), f x * f y = 0 } ≃ (tsze R' M →ₐ[R'] A)
state_after: S : Type u_1
R R' : Type u
M : Type v
inst✝¹⁸ : CommSemiring S
inst✝¹⁷ : Semiring R
inst✝¹⁶ : CommSemiring R'
inst✝¹⁵ : AddCommMonoid M
inst✝¹⁴ : Algebra S R
inst✝¹³ : Algebra S R'
inst✝¹² : Module S M
inst✝¹¹ : Module R M
inst✝¹⁰ : Module Rᵐᵒᵖ M
inst✝⁹ : SMulCommClass R Rᵐᵒᵖ M
inst✝⁸ : IsScalarTower S R M
inst✝⁷ : IsScalarTower S Rᵐᵒᵖ M
inst✝⁶ : Module R' M
inst✝⁵ : Module R'ᵐᵒᵖ M
inst✝⁴ : IsCentralScalar R' M
inst✝³ : IsScalarTower S R' M
A : Type u_2
inst✝² : Semiring A
inst✝¹ : Algebra S A
inst✝ : Algebra R' A
⊢ { f // ∀ (x y : M), f x * f y = 0 } ≃
    { fg //
      (∀ (x y : M), fg.2 x * fg.2 y = 0) ∧
        (∀ (r : R') (x : M), fg.2 (r •> x) = fg.1 r * fg.2 x) ∧ ∀ (r : R') (x : M), fg.2 (x <• r) = fg.2 x * fg.1 r }
tactic: refine Equiv.trans ?_ liftEquiv
state_before: S : Type u_1
R R' : Type u
M : Type v
inst✝¹⁸ : CommSemiring S
inst✝¹⁷ : Semiring R
inst✝¹⁶ : CommSemiring R'
inst✝¹⁵ : AddCommMonoid M
inst✝¹⁴ : Algebra S R
inst✝¹³ : Algebra S R'
inst✝¹² : Module S M
inst✝¹¹ : Module R M
inst✝¹⁰ : Module Rᵐᵒᵖ M
inst✝⁹ : SMulCommClass R Rᵐᵒᵖ M
inst✝⁸ : IsScalarTower S R M
inst✝⁷ : IsScalarTower S Rᵐᵒᵖ M
inst✝⁶ : Module R' M
inst✝⁵ : Module R'ᵐᵒᵖ M
inst✝⁴ : IsCentralScalar R' M
inst✝³ : IsScalarTower S R' M
A : Type u_2
inst✝² : Semiring A
inst✝¹ : Algebra S A
inst✝ : Algebra R' A
⊢ { f // ∀ (x y : M), f x * f y = 0 } ≃
    { fg //
      (∀ (x y : M), fg.2 x * fg.2 y = 0) ∧
        (∀ (r : R') (x : M), fg.2 (r •> x) = fg.1 r * fg.2 x) ∧ ∀ (r : R') (x : M), fg.2 (x <• r) = fg.2 x * fg.1 r }
state_after: no goals
tactic: exact {
    toFun := fun f => ⟨(Algebra.ofId _ _, f.val), f.prop,
      fun r x => by simp [Algebra.smul_def, Algebra.ofId_apply],
      fun r x => by simp [Algebra.smul_def, Algebra.ofId_apply, Algebra.commutes]⟩
    invFun := fun fg => ⟨fg.val.2, fg.prop.1⟩
    left_inv := fun f => rfl
    right_inv := fun fg => Subtype.ext <|
      Prod.ext (AlgHom.toLinearMap_injective <| LinearMap.ext_ring <| by simp)
      rfl }
Theorem: Mathlib.Vector.mapAccumr₂_unused_input_left
File: Mathlib/Data/Vector/MapLemmas.lean

Proof steps:
state_before: α : Type
n : ℕ
β : Type
xs : Vector α n
ys : Vector β n
σ γ : Type
s : σ
inst✝ : Inhabited α
f : α → β → σ → σ × γ
h : ∀ (a : α) (b : β) (s : σ), f default b s = f a b s
⊢ mapAccumr₂ f xs ys s = mapAccumr (fun b s => f default b s) ys s
state_after: no goals
tactic: induction xs, ys using Vector.revInductionOn₂ generalizing s with
  | nil => rfl
  | snoc xs ys x y ih => simp [h x y s, ih]
Theorem: SimpleGraph.Walk.end_mem_verts_toSubgraph
File: Mathlib/Combinatorics/SimpleGraph/Connectivity/Subgraph.lean

Proof steps:
state_before: V : Type u
V' : Type v
G : SimpleGraph V
G' : SimpleGraph V'
u v w : V
p : G.Walk u v
⊢ v ∈ p.toSubgraph.verts
state_after: no goals
tactic: simp [mem_verts_toSubgraph]
Theorem: LowerSet.compl_iSup₂
File: Mathlib/Order/UpperLower/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝ : LE α
s t : LowerSet α
a : α
f : (i : ι) → κ i → LowerSet α
⊢ (⨆ i, ⨆ j, f i j).compl = ⨆ i, ⨆ j, (f i j).compl
state_after: no goals
tactic: simp_rw [LowerSet.compl_iSup]
Theorem: Set.ite_inter_self
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 t s s' : Set α
⊢ t.ite s s' ∩ t = s ∩ t
state_after: no goals
tactic: rw [Set.ite, union_inter_distrib_right, diff_inter_self, inter_assoc, inter_self, union_empty]
Theorem: Polynomial.annIdealGenerator_eq_minpoly
File: Mathlib/LinearAlgebra/AnnihilatingPolynomial.lean

Proof steps:
state_before: 𝕜 : Type u_1
A : Type u_2
inst✝² : Field 𝕜
inst✝¹ : Ring A
inst✝ : Algebra 𝕜 A
a : A
⊢ annIdealGenerator 𝕜 a = minpoly 𝕜 a
state_after: case pos
𝕜 : Type u_1
A : Type u_2
inst✝² : Field 𝕜
inst✝¹ : Ring A
inst✝ : Algebra 𝕜 A
a : A
h : annIdealGenerator 𝕜 a = 0
⊢ annIdealGenerator 𝕜 a = minpoly 𝕜 a

case neg
𝕜 : Type u_1
A : Type u_2
inst✝² : Field 𝕜
inst✝¹ : Ring A
inst✝ : Algebra 𝕜 A
a : A
h : ¬annIdealGenerator 𝕜 a = 0
⊢ annIdealGenerator 𝕜 a = minpoly 𝕜 a
tactic: by_cases h : annIdealGenerator 𝕜 a = 0
Theorem: Nat.minFac_le_div
File: Mathlib/Data/Nat/Prime/Defs.lean

Proof steps:
state_before: n✝ n : ℕ
pos : 0 < n
np : ¬Prime n
h0 : n = n.minFac * 0
⊢ ¬0 < n
state_after: n✝ n : ℕ
pos : 0 < n
np : ¬Prime n
h0 : n = n.minFac * 0
⊢ ¬0 < 0
tactic: rw [h0, mul_zero]
state_before: n✝ n : ℕ
pos : 0 < n
np : ¬Prime n
h0 : n = n.minFac * 0
⊢ ¬0 < 0
state_after: no goals
tactic: decide
state_before: n✝ n : ℕ
pos : 0 < n
np : ¬Prime n
h1 : n = n.minFac * 1
⊢ n.minFac ≤ n / n.minFac
state_after: n✝ n : ℕ
pos : 0 < n
np : ¬Prime n
h1 : n = n.minFac
⊢ n.minFac ≤ n / n.minFac
tactic: rw [mul_one] at h1
state_before: n✝ n : ℕ
pos : 0 < n
np : ¬Prime n
h1 : n = n.minFac
⊢ n.minFac ≤ n / n.minFac
state_after: n✝ n : ℕ
pos : 0 < n
np : n < 2
h1 : n = n.minFac
⊢ n.minFac ≤ n / n.minFac
tactic: rw [prime_def_minFac, not_and_or, ← h1, eq_self_iff_true, _root_.not_true, or_false_iff,
      not_le] at np
state_before: n✝ n : ℕ
pos : 0 < n
np : n < 2
h1 : n = n.minFac
⊢ n.minFac ≤ n / n.minFac
state_after: no goals
tactic: rw [le_antisymm (le_of_lt_succ np) (succ_le_of_lt pos), minFac_one, Nat.div_one]
state_before: n✝ n : ℕ
pos : 0 < n
np : ¬Prime n
x : ℕ
hx : n = n.minFac * (x + 2)
⊢ n.minFac ≤ n / n.minFac
state_after: n✝ n : ℕ
pos : 0 < n
np : ¬Prime n
x : ℕ
hx : n = n.minFac * (x + 2)
⊢ n.minFac ≤ n.minFac * (x + 2) / n.minFac
tactic: conv_rhs =>
      congr
      rw [hx]
state_before: n✝ n : ℕ
pos : 0 < n
np : ¬Prime n
x : ℕ
hx : n = n.minFac * (x + 2)
⊢ n.minFac ≤ n.minFac * (x + 2) / n.minFac
state_after: n✝ n : ℕ
pos : 0 < n
np : ¬Prime n
x : ℕ
hx : n = n.minFac * (x + 2)
⊢ n.minFac ≤ x + 2
tactic: rw [Nat.mul_div_cancel_left _ (minFac_pos _)]
state_before: n✝ n : ℕ
pos : 0 < n
np : ¬Prime n
x : ℕ
hx : n = n.minFac * (x + 2)
⊢ n.minFac ≤ x + 2
state_after: no goals
tactic: exact minFac_le_of_dvd (le_add_left 2 x) ⟨minFac n, by rwa [mul_comm]⟩
Theorem: mul_eq_of_eq_inv_mul
File: Mathlib/Algebra/Group/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a b c d : G
n : ℤ
h : b = a⁻¹ * c
⊢ a * b = c
state_after: no goals
tactic: rw [h, mul_inv_cancel_left]
Theorem: BoxIntegral.Prepartition.forall_biUnionTagged
File: Mathlib/Analysis/BoxIntegral/Partition/Tagged.lean

Proof steps:
state_before: ι : Type u_1
I J : Box ι
p : (ι → ℝ) → Box ι → Prop
π : Prepartition I
πi : (J : Box ι) → TaggedPrepartition J
⊢ (∀ J ∈ π.biUnionTagged πi, p ((π.biUnionTagged πi).tag J) J) ↔ ∀ J ∈ π, ∀ J' ∈ πi J, p ((πi J).tag J') J'
state_after: ι : Type u_1
I J : Box ι
p : (ι → ℝ) → Box ι → Prop
π : Prepartition I
πi : (J : Box ι) → TaggedPrepartition J
⊢ (∀ (J : Box ι), (∃ J' ∈ π, J ∈ πi J') → p ((π.biUnionTagged πi).tag J) J) ↔ ∀ J ∈ π, ∀ J' ∈ πi J, p ((πi J).tag J') J'
tactic: simp only [mem_biUnionTagged]
state_before: ι : Type u_1
I J : Box ι
p : (ι → ℝ) → Box ι → Prop
π : Prepartition I
πi : (J : Box ι) → TaggedPrepartition J
⊢ (∀ (J : Box ι), (∃ J' ∈ π, J ∈ πi J') → p ((π.biUnionTagged πi).tag J) J) ↔ ∀ J ∈ π, ∀ J' ∈ πi J, p ((πi J).tag J') J'
state_after: case refine_1
ι : Type u_1
I J✝ : Box ι
p : (ι → ℝ) → Box ι → Prop
π : Prepartition I
πi : (J : Box ι) → TaggedPrepartition J
H : ∀ (J : Box ι), (∃ J' ∈ π, J ∈ πi J') → p ((π.biUnionTagged πi).tag J) J
J : Box ι
hJ : J ∈ π
J' : Box ι
hJ' : J' ∈ πi J
⊢ p ((πi J).tag J') J'

case refine_2
ι : Type u_1
I J✝ : Box ι
p : (ι → ℝ) → Box ι → Prop
π : Prepartition I
πi : (J : Box ι) → TaggedPrepartition J
H : ∀ J ∈ π, ∀ J' ∈ πi J, p ((πi J).tag J') J'
J' : Box ι
x✝ : ∃ J'_1 ∈ π, J' ∈ πi J'_1
J : Box ι
hJ : J ∈ π
hJ' : J' ∈ πi J
⊢ p ((π.biUnionTagged πi).tag J') J'
tactic: refine ⟨fun H J hJ J' hJ' => ?_, fun H J' ⟨J, hJ, hJ'⟩ => ?_⟩
Theorem: MeasureTheory.IsSetSemiring.sUnion_diffFinset₀_subset
File: Mathlib/MeasureTheory/SetSemiring.lean

Proof steps:
state_before: α : Type u_1
C : Set (Set α)
s t : Set α
I : Finset (Set α)
hC : IsSetSemiring C
hs : s ∈ C
hI : ↑I ⊆ C
⊢ ⋃₀ ↑(hC.diffFinset₀ hs hI) ⊆ s
state_after: α : Type u_1
C : Set (Set α)
s t : Set α
I : Finset (Set α)
hC : IsSetSemiring C
hs : s ∈ C
hI : ↑I ⊆ C
⊢ s \ ⋃₀ ↑I ⊆ s
tactic: rw [← hC.diff_sUnion_eq_sUnion_diffFinset₀]
state_before: α : Type u_1
C : Set (Set α)
s t : Set α
I : Finset (Set α)
hC : IsSetSemiring C
hs : s ∈ C
hI : ↑I ⊆ C
⊢ s \ ⋃₀ ↑I ⊆ s
state_after: no goals
tactic: exact diff_subset
Theorem: MeasureTheory.tilted_of_not_aemeasurable
File: Mathlib/MeasureTheory/Measure/Tilted.lean

Proof steps:
state_before: α : Type u_1
mα : MeasurableSpace α
μ : Measure α
f : α → ℝ
hf : ¬AEMeasurable f μ
⊢ μ.tilted f = 0
state_after: α : Type u_1
mα : MeasurableSpace α
μ : Measure α
f : α → ℝ
hf : ¬AEMeasurable f μ
⊢ ¬Integrable (fun x => rexp (f x)) μ
tactic: refine tilted_of_not_integrable ?_
state_before: α : Type u_1
mα : MeasurableSpace α
μ : Measure α
f : α → ℝ
hf : ¬AEMeasurable f μ
⊢ ¬Integrable (fun x => rexp (f x)) μ
state_after: α : Type u_1
mα : MeasurableSpace α
μ : Measure α
f : α → ℝ
hf : ¬AEMeasurable f μ
⊢ ¬AEMeasurable (fun x => rexp (f x)) μ
tactic: suffices ¬ AEMeasurable (fun x ↦ exp (f x)) μ by exact fun h ↦ this h.1.aemeasurable
state_before: α : Type u_1
mα : MeasurableSpace α
μ : Measure α
f : α → ℝ
hf : ¬AEMeasurable f μ
⊢ ¬AEMeasurable (fun x => rexp (f x)) μ
state_after: no goals
tactic: exact fun h ↦ hf (aemeasurable_of_aemeasurable_exp h)
Theorem: MeasureTheory.integrableOn_Ioi_deriv_of_nonpos'
File: Mathlib/MeasureTheory/Integral/IntegralEqImproper.lean

Proof steps:
state_before: E : Type u_1
f f' : ℝ → E
g g' : ℝ → ℝ
a b l : ℝ
m : E
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
hderiv : ∀ x ∈ Ici a, HasDerivAt g (g' x) x
g'neg : ∀ x ∈ Ioi a, g' x ≤ 0
hg : Tendsto g atTop (𝓝 l)
⊢ IntegrableOn g' (Ioi a) volume
state_after: E : Type u_1
f f' : ℝ → E
g g' : ℝ → ℝ
a b l : ℝ
m : E
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
hderiv : ∀ x ∈ Ici a, HasDerivAt g (g' x) x
g'neg : ∀ x ∈ Ioi a, g' x ≤ 0
hg : Tendsto g atTop (𝓝 l)
⊢ ContinuousWithinAt g (Ici a) a
tactic: refine integrableOn_Ioi_deriv_of_nonpos ?_ (fun x hx ↦ hderiv x hx.out.le) g'neg hg
state_before: E : Type u_1
f f' : ℝ → E
g g' : ℝ → ℝ
a b l : ℝ
m : E
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
hderiv : ∀ x ∈ Ici a, HasDerivAt g (g' x) x
g'neg : ∀ x ∈ Ioi a, g' x ≤ 0
hg : Tendsto g atTop (𝓝 l)
⊢ ContinuousWithinAt g (Ici a) a
state_after: no goals
tactic: exact (hderiv a left_mem_Ici).continuousAt.continuousWithinAt
Theorem: Equiv.subRight_apply
File: Mathlib/Algebra/Group/Units/Equiv.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
A : Type u_4
B : Type u_5
M : Type u_6
N : Type u_7
P : Type u_8
Q : Type u_9
G : Type u_10
H : Type u_11
inst✝ : Group G
a b : G
⊢ (fun b => b * a) ((fun b => b / a) b) = b
state_after: no goals
tactic: simp [div_eq_mul_inv]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
A : Type u_4
B : Type u_5
M : Type u_6
N : Type u_7
P : Type u_8
Q : Type u_9
G : Type u_10
H : Type u_11
inst✝ : Group G
a b : G
⊢ (fun b => b / a) ((fun b => b * a) b) = b
state_after: no goals
tactic: simp [div_eq_mul_inv]
Theorem: Real.exp_sub_sum_range_isBigO_pow
File: Mathlib/Analysis/SpecialFunctions/Exp.lean

Proof steps:
state_before: n : ℕ
⊢ (fun x => rexp x - ∑ i ∈ Finset.range n, x ^ i / ↑i !) =O[𝓝 0] fun x => x ^ n
state_after: n : ℕ
this :
  ((fun x => Complex.exp x - ∑ i ∈ Finset.range n, x ^ i / ↑i !) ∘ Complex.ofReal') =O[𝓝 0]
    ((fun x => x ^ n) ∘ Complex.ofReal')
⊢ (fun x => rexp x - ∑ i ∈ Finset.range n, x ^ i / ↑i !) =O[𝓝 0] fun x => x ^ n
tactic: have := (Complex.exp_sub_sum_range_isBigO_pow n).comp_tendsto
    (Complex.continuous_ofReal.tendsto' 0 0 rfl)
state_before: n : ℕ
this : (fun x => Complex.exp ↑x - ∑ i ∈ Finset.range n, ↑x ^ i / ↑i !) =O[𝓝 0] fun x => ↑x ^ n
⊢ (fun x => rexp x - ∑ i ∈ Finset.range n, x ^ i / ↑i !) =O[𝓝 0] fun x => x ^ n
state_after: no goals
tactic: norm_cast at this
Theorem: CategoryTheory.Pretriangulated.productTriangle.lift_hom₁
File: Mathlib/CategoryTheory/Triangulated/Basic.lean

Proof steps:
state_before: C : Type u
inst✝⁵ : Category.{v, u} C
inst✝⁴ : HasShift C ℤ
T₁ T₂ T₃ : Triangle C
J : Type u_1
T : J → Triangle C
inst✝³ : HasProduct fun j => (T j).obj₁
inst✝² : HasProduct fun j => (T j).obj₂
inst✝¹ : HasProduct fun j => (T j).obj₃
inst✝ : HasProduct fun j => (shiftFunctor C 1).obj (T j).obj₁
T' : Triangle C
φ : (j : J) → T' ⟶ T j
⊢ T'.mor₃ ≫ (shiftFunctor C 1).map (Pi.lift fun j => (φ j).hom₁) =
    (Pi.lift fun j => (φ j).hom₃) ≫ (productTriangle T).mor₃
state_after: C : Type u
inst✝⁵ : Category.{v, u} C
inst✝⁴ : HasShift C ℤ
T₁ T₂ T₃ : Triangle C
J : Type u_1
T : J → Triangle C
inst✝³ : HasProduct fun j => (T j).obj₁
inst✝² : HasProduct fun j => (T j).obj₂
inst✝¹ : HasProduct fun j => (T j).obj₃
inst✝ : HasProduct fun j => (shiftFunctor C 1).obj (T j).obj₁
T' : Triangle C
φ : (j : J) → T' ⟶ T j
⊢ T'.mor₃ ≫ (shiftFunctor C 1).map (Pi.lift fun j => (φ j).hom₁) =
    (Pi.lift fun j => (φ j).hom₃) ≫
      (Pi.map fun j => (T j).mor₃) ≫ inv (piComparison (shiftFunctor C 1) fun j => (T j).obj₁)
tactic: dsimp
state_before: C : Type u
inst✝⁵ : Category.{v, u} C
inst✝⁴ : HasShift C ℤ
T₁ T₂ T₃ : Triangle C
J : Type u_1
T : J → Triangle C
inst✝³ : HasProduct fun j => (T j).obj₁
inst✝² : HasProduct fun j => (T j).obj₂
inst✝¹ : HasProduct fun j => (T j).obj₃
inst✝ : HasProduct fun j => (shiftFunctor C 1).obj (T j).obj₁
T' : Triangle C
φ : (j : J) → T' ⟶ T j
⊢ T'.mor₃ ≫ (shiftFunctor C 1).map (Pi.lift fun j => (φ j).hom₁) =
    (Pi.lift fun j => (φ j).hom₃) ≫
      (Pi.map fun j => (T j).mor₃) ≫ inv (piComparison (shiftFunctor C 1) fun j => (T j).obj₁)
state_after: C : Type u
inst✝⁵ : Category.{v, u} C
inst✝⁴ : HasShift C ℤ
T₁ T₂ T₃ : Triangle C
J : Type u_1
T : J → Triangle C
inst✝³ : HasProduct fun j => (T j).obj₁
inst✝² : HasProduct fun j => (T j).obj₂
inst✝¹ : HasProduct fun j => (T j).obj₃
inst✝ : HasProduct fun j => (shiftFunctor C 1).obj (T j).obj₁
T' : Triangle C
φ : (j : J) → T' ⟶ T j
⊢ (T'.mor₃ ≫
      (shiftFunctor C 1).map (Pi.lift fun j => (φ j).hom₁) ≫ piComparison (shiftFunctor C 1) fun j => (T j).obj₁) =
    (Pi.lift fun j => (φ j).hom₃) ≫ Pi.map fun j => (T j).mor₃
tactic: rw [← cancel_mono (piComparison _ _), assoc, assoc, assoc, IsIso.inv_hom_id, comp_id]
state_before: C : Type u
inst✝⁵ : Category.{v, u} C
inst✝⁴ : HasShift C ℤ
T₁ T₂ T₃ : Triangle C
J : Type u_1
T : J → Triangle C
inst✝³ : HasProduct fun j => (T j).obj₁
inst✝² : HasProduct fun j => (T j).obj₂
inst✝¹ : HasProduct fun j => (T j).obj₃
inst✝ : HasProduct fun j => (shiftFunctor C 1).obj (T j).obj₁
T' : Triangle C
φ : (j : J) → T' ⟶ T j
⊢ (T'.mor₃ ≫
      (shiftFunctor C 1).map (Pi.lift fun j => (φ j).hom₁) ≫ piComparison (shiftFunctor C 1) fun j => (T j).obj₁) =
    (Pi.lift fun j => (φ j).hom₃) ≫ Pi.map fun j => (T j).mor₃
state_after: no goals
tactic: aesop_cat
Theorem: List.prev_getLast_cons'
File: Mathlib/Data/List/Cycle.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
l : List α
x y : α
hxy : x ∈ y :: l
hx : x = y
⊢ (y :: l).prev x hxy = (y :: l).getLast ⋯
state_after: no goals
tactic: cases l <;> simp [prev, hx]
Theorem: Submodule.fg_iff_addSubmonoid_fg
File: Mathlib/RingTheory/Finiteness.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
P : Submodule ℕ M
x✝ : P.FG
S : Finset M
hS : span ℕ ↑S = P
⊢ AddSubmonoid.closure ↑S = P.toAddSubmonoid
state_after: no goals
tactic: simpa [← span_nat_eq_addSubmonoid_closure] using hS
state_before: R : Type u_1
M : Type u_2
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
P : Submodule ℕ M
x✝ : P.FG
S : Finset M
hS : AddSubmonoid.closure ↑S = P.toAddSubmonoid
⊢ span ℕ ↑S = P
state_after: no goals
tactic: simpa [← span_nat_eq_addSubmonoid_closure] using hS