ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: _private.Mathlib.SetTheory.ZFC.Basic.0.PSet.mem_wf_aux
File: Mathlib/SetTheory/ZFC/Basic.lean

Proof steps:
state_before: α : Type u
A : α → PSet
β : Type u
B : β → PSet
H : (mk α A).Equiv (mk β B)
⊢ ∀ y ∈ mk β B, Acc (fun x x_1 => x ∈ x_1) y
state_after: case mk.intro
α : Type u
A : α → PSet
β : Type u
B : β → PSet
H : (mk α A).Equiv (mk β B)
γ : Type u
C : γ → PSet
b : (mk β B).Type
hc : (mk γ C).Equiv ((mk β B).Func b)
⊢ Acc (fun x x_1 => x ∈ x_1) (mk γ C)
tactic: rintro ⟨γ, C⟩ ⟨b, hc⟩
state_before: case mk.intro
α : Type u
A : α → PSet
β : Type u
B : β → PSet
H : (mk α A).Equiv (mk β B)
γ : Type u
C : γ → PSet
b : (mk β B).Type
hc : (mk γ C).Equiv ((mk β B).Func b)
⊢ Acc (fun x x_1 => x ∈ x_1) (mk γ C)
state_after: case mk.intro.intro
α : Type u
A : α → PSet
β : Type u
B : β → PSet
H : (mk α A).Equiv (mk β B)
γ : Type u
C : γ → PSet
b : (mk β B).Type
hc : (mk γ C).Equiv ((mk β B).Func b)
a : (mk α A).Type
ha : ((mk α A).Func a).Equiv ((mk β B).Func b)
⊢ Acc (fun x x_1 => x ∈ x_1) (mk γ C)
tactic: cases' H.exists_right b with a ha
state_before: case mk.intro.intro
α : Type u
A : α → PSet
β : Type u
B : β → PSet
H : (mk α A).Equiv (mk β B)
γ : Type u
C : γ → PSet
b : (mk β B).Type
hc : (mk γ C).Equiv ((mk β B).Func b)
a : (mk α A).Type
ha : ((mk α A).Func a).Equiv ((mk β B).Func b)
⊢ Acc (fun x x_1 => x ∈ x_1) (mk γ C)
state_after: case mk.intro.intro
α : Type u
A : α → PSet
β : Type u
B : β → PSet
H✝ : (mk α A).Equiv (mk β B)
γ : Type u
C : γ → PSet
b : (mk β B).Type
hc : (mk γ C).Equiv ((mk β B).Func b)
a : (mk α A).Type
ha : ((mk α A).Func a).Equiv ((mk β B).Func b)
H : ((mk α A).Func a).Equiv (mk γ C)
⊢ Acc (fun x x_1 => x ∈ x_1) (mk γ C)
tactic: have H := ha.trans hc.symm
state_before: case mk.intro.intro
α : Type u
A : α → PSet
β : Type u
B : β → PSet
H✝ : (mk α A).Equiv (mk β B)
γ : Type u
C : γ → PSet
b : (mk β B).Type
hc : (mk γ C).Equiv ((mk β B).Func b)
a : (mk α A).Type
ha : ((mk α A).Func a).Equiv ((mk β B).Func b)
H : ((mk α A).Func a).Equiv (mk γ C)
⊢ Acc (fun x x_1 => x ∈ x_1) (mk γ C)
state_after: case mk.intro.intro
α : Type u
A : α → PSet
β : Type u
B : β → PSet
H✝ : (mk α A).Equiv (mk β B)
γ : Type u
C : γ → PSet
b : (mk β B).Type
hc : (mk γ C).Equiv ((mk β B).Func b)
a : (mk α A).Type
ha : ((mk α A).Func a).Equiv ((mk β B).Func b)
H : (A a).Equiv (mk γ C)
⊢ Acc (fun x x_1 => x ∈ x_1) (mk γ C)
tactic: rw [mk_func] at H
state_before: case mk.intro.intro
α : Type u
A : α → PSet
β : Type u
B : β → PSet
H✝ : (mk α A).Equiv (mk β B)
γ : Type u
C : γ → PSet
b : (mk β B).Type
hc : (mk γ C).Equiv ((mk β B).Func b)
a : (mk α A).Type
ha : ((mk α A).Func a).Equiv ((mk β B).Func b)
H : (A a).Equiv (mk γ C)
⊢ Acc (fun x x_1 => x ∈ x_1) (mk γ C)
state_after: no goals
tactic: exact mem_wf_aux H
Theorem: BoundedContinuousFunction.norm_le_of_nonempty
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 : ℝ
inst✝ : Nonempty α
f : α →ᵇ β
M : ℝ
⊢ ‖f‖ ≤ M ↔ ∀ (x : α), ‖f x‖ ≤ M
state_after: F : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝² : TopologicalSpace α
inst✝¹ : SeminormedAddCommGroup β
f✝ g : α →ᵇ β
x : α
C : ℝ
inst✝ : Nonempty α
f : α →ᵇ β
M : ℝ
⊢ dist f 0 ≤ M ↔ ∀ (x : α), dist (f x) 0 ≤ M
tactic: simp_rw [norm_def, ← dist_zero_right]
state_before: F : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝² : TopologicalSpace α
inst✝¹ : SeminormedAddCommGroup β
f✝ g : α →ᵇ β
x : α
C : ℝ
inst✝ : Nonempty α
f : α →ᵇ β
M : ℝ
⊢ dist f 0 ≤ M ↔ ∀ (x : α), dist (f x) 0 ≤ M
state_after: no goals
tactic: exact dist_le_iff_of_nonempty
Theorem: Submonoid.LocalizationMap.mk'_eq_iff_eq
File: Mathlib/GroupTheory/MonoidLocalization/Basic.lean

Proof steps:
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type u_3
inst✝ : CommMonoid P
f : S.LocalizationMap N
x₁ x₂ : M
y₁ y₂ : ↥S
H : f.mk' x₁ y₁ = f.mk' x₂ y₂
⊢ f.toMap (↑y₂ * x₁) = f.toMap (↑y₁ * x₂)
state_after: no goals
tactic: rw [f.toMap.map_mul, f.toMap.map_mul, f.mk'_eq_iff_eq_mul.1 H,← mul_assoc, mk'_spec',
      mul_comm ((toMap f) x₂) _]
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type u_3
inst✝ : CommMonoid P
f : S.LocalizationMap N
x₁ x₂ : M
y₁ y₂ : ↥S
H : f.toMap (↑y₂ * x₁) = f.toMap (↑y₁ * x₂)
⊢ f.mk' x₁ y₁ = f.mk' x₂ y₂
state_after: no goals
tactic: rw [mk'_eq_iff_eq_mul, mk', mul_assoc, mul_comm _ (f.toMap y₁), ← mul_assoc, ←
      f.toMap.map_mul, mul_comm x₂, ← H, ← mul_comm x₁, f.toMap.map_mul,
      mul_inv_right f.map_units]
Theorem: LinearMap.isScalarTower_of_injective
File: Mathlib/Algebra/Module/LinearMap/Defs.lean

Proof steps:
state_before: R✝ : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
k : Type u_5
S✝ : Type u_6
S₃ : Type u_7
T : Type u_8
M : Type u_9
M₁ : Type u_10
M₂ : Type u_11
M₃ : Type u_12
N₁ : Type u_13
N₂ : Type u_14
N₃ : Type u_15
ι : Type u_16
inst✝¹⁹ : Semiring R✝
inst✝¹⁸ : Semiring S✝
inst✝¹⁷ : AddCommMonoid M
inst✝¹⁶ : AddCommMonoid M₁
inst✝¹⁵ : AddCommMonoid M₂
inst✝¹⁴ : AddCommMonoid M₃
inst✝¹³ : AddCommMonoid N₁
inst✝¹² : AddCommMonoid N₂
inst✝¹¹ : AddCommMonoid N₃
inst✝¹⁰ : Module R✝ M
inst✝⁹ : Module R✝ M₂
inst✝⁸ : Module S✝ M₃
σ : R✝ →+* S✝
fₗ gₗ : M →ₗ[R✝] M₂
f✝ g : M →ₛₗ[σ] M₃
R : Type u_17
S : Type u_18
inst✝⁷ : Semiring S
inst✝⁶ : SMul R M
inst✝⁵ : Module S M
inst✝⁴ : SMul R M₂
inst✝³ : Module S M₂
inst✝² : SMul R S
inst✝¹ : CompatibleSMul M M₂ R S
inst✝ : IsScalarTower R S M₂
f : M →ₗ[S] M₂
hf : Injective ⇑f
r : R
s : S
x✝ : M
⊢ f ((r • s) • x✝) = f (r • s • x✝)
state_after: no goals
tactic: rw [f.map_smul_of_tower r, map_smul, map_smul, smul_assoc]
Theorem: Polynomial.rootSet_one
File: Mathlib/Algebra/Polynomial/Roots.lean

Proof steps:
state_before: R : Type u
S✝ : Type v
T : Type w
a b : R
n : ℕ
inst✝⁵ : CommRing R
inst✝⁴ : IsDomain R
p q : R[X]
inst✝³ : CommRing T
S : Type u_1
inst✝² : CommRing S
inst✝¹ : IsDomain S
inst✝ : Algebra T S
⊢ rootSet 1 S = ∅
state_after: no goals
tactic: rw [← C_1, rootSet_C]
Theorem: Finset.max'_insert
File: Mathlib/Data/Finset/Lattice.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : LinearOrder α
s✝ : Finset α
H✝ : s✝.Nonempty
x a : α
s : Finset α
H : s.Nonempty
⊢ IsGreatest (↑(insert a s)) (max (s.max' H) a)
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : LinearOrder α
s✝ : Finset α
H✝ : s✝.Nonempty
x a : α
s : Finset α
H : s.Nonempty
⊢ IsGreatest (insert a ↑s) (max a (s.max' H))
tactic: rw [coe_insert, max_comm]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : LinearOrder α
s✝ : Finset α
H✝ : s✝.Nonempty
x a : α
s : Finset α
H : s.Nonempty
⊢ IsGreatest (insert a ↑s) (max a (s.max' H))
state_after: no goals
tactic: exact (isGreatest_max' _ _).insert _
Theorem: Set.ncard_diff_singleton_lt_of_mem
File: Mathlib/Data/Set/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
s t : Set α
a : α
h : a ∈ s
hs : autoParam s.Finite _auto✝
⊢ (s \ {a}).ncard < s.ncard
state_after: α : Type u_1
β : Type u_2
s t : Set α
a : α
h : a ∈ s
hs : autoParam s.Finite _auto✝
⊢ (s \ {a}).ncard < (s \ {a}).ncard + 1
tactic: rw [← ncard_diff_singleton_add_one h hs]
state_before: α : Type u_1
β : Type u_2
s t : Set α
a : α
h : a ∈ s
hs : autoParam s.Finite _auto✝
⊢ (s \ {a}).ncard < (s \ {a}).ncard + 1
state_after: no goals
tactic: apply lt_add_one
Theorem: Set.pair_diff_left
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 α
hne : a ≠ b
⊢ {a, b} \ {a} = {b}
state_after: no goals
tactic: rw [insert_diff_of_mem _ (mem_singleton a), diff_singleton_eq_self (by simpa)]
Theorem: divp_mul_eq_mul_divp
File: Mathlib/Algebra/Group/Units.lean

Proof steps:
state_before: α : Type u
inst✝ : CommMonoid α
x y : α
u : αˣ
⊢ x /ₚ u * y = x * y /ₚ u
state_after: no goals
tactic: rw [divp, divp, mul_right_comm]
Theorem: Complex.restrictScalars_one_smulRight
File: Mathlib/Analysis/Complex/Basic.lean

Proof steps:
state_before: z : ℂ
E : Type u_1
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℂ E
x : ℂ
⊢ restrictScalars ℝ (smulRight 1 x) = x • 1
state_after: case h
z✝ : ℂ
E : Type u_1
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℂ E
x z : ℂ
⊢ (restrictScalars ℝ (smulRight 1 x)) z = (x • 1) z
tactic: ext1 z
state_before: case h
z✝ : ℂ
E : Type u_1
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℂ E
x z : ℂ
⊢ (restrictScalars ℝ (smulRight 1 x)) z = (x • 1) z
state_after: case h
z✝ : ℂ
E : Type u_1
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℂ E
x z : ℂ
⊢ z * x = x * z
tactic: dsimp
state_before: case h
z✝ : ℂ
E : Type u_1
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℂ E
x z : ℂ
⊢ z * x = x * z
state_after: no goals
tactic: apply mul_comm
Theorem: MeasureTheory.setToFun_sub
File: Mathlib/MeasureTheory/Integral/SetToL1.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type u_4
G : Type u_5
𝕜 : Type u_6
p : ℝ≥0∞
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f g : α → E
hT : DominatedFinMeasAdditive μ T C
hf : Integrable f μ
hg : Integrable g μ
⊢ setToFun μ T hT (f - g) = setToFun μ T hT f - setToFun μ T hT g
state_after: no goals
tactic: rw [sub_eq_add_neg, sub_eq_add_neg, setToFun_add hT hf hg.neg, setToFun_neg hT g]
Theorem: Finpartition.card_parts_le_card
File: Mathlib/Order/Partition/Finpartition.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
s t u : Finset α
P : Finpartition s
a : α
⊢ P.parts.card ≤ s.card
state_after: α : Type u_1
inst✝ : DecidableEq α
s t u : Finset α
P : Finpartition s
a : α
⊢ P.parts.card ≤ ⊥.parts.card
tactic: rw [← card_bot s]
state_before: α : Type u_1
inst✝ : DecidableEq α
s t u : Finset α
P : Finpartition s
a : α
⊢ P.parts.card ≤ ⊥.parts.card
state_after: no goals
tactic: exact card_mono bot_le
Theorem: Matrix.PosSemidef.zero
File: Mathlib/LinearAlgebra/Matrix/PosDef.lean

Proof steps:
state_before: m : Type u_1
n : Type u_2
R : Type u_3
𝕜 : Type u_4
inst✝⁶ : Fintype m
inst✝⁵ : Fintype n
inst✝⁴ : CommRing R
inst✝³ : PartialOrder R
inst✝² : StarRing R
inst✝¹ : StarOrderedRing R
inst✝ : RCLike 𝕜
⊢ ∀ (x : n → R), 0 ≤ star x ⬝ᵥ 0 *ᵥ x
state_after: no goals
tactic: simp
Theorem: dist_midpoint_midpoint_le
File: Mathlib/Analysis/NormedSpace/AddTorsor.lean

Proof steps:
state_before: α : Type u_1
V : Type u_2
P : Type u_3
W : Type u_4
Q : Type u_5
inst✝⁷ : SeminormedAddCommGroup V
inst✝⁶ : PseudoMetricSpace P
inst✝⁵ : NormedAddTorsor V P
inst✝⁴ : NormedAddCommGroup W
inst✝³ : MetricSpace Q
inst✝² : NormedAddTorsor W Q
inst✝¹ : NormedSpace ℝ V
inst✝ : NormedSpace ℝ W
p₁ p₂ p₃ p₄ : V
⊢ dist (midpoint ℝ p₁ p₂) (midpoint ℝ p₃ p₄) ≤ (dist p₁ p₃ + dist p₂ p₄) / 2
state_after: no goals
tactic: simpa using dist_midpoint_midpoint_le' (𝕜 := ℝ) p₁ p₂ p₃ p₄
Theorem: HomologicalComplex.extend_d_eq
File: Mathlib/Algebra/Homology/Embedding/Extend.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
c : ComplexShape ι
c' : ComplexShape ι'
C : Type u_3
inst✝² : Category.{u_4, u_3} C
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
K : HomologicalComplex C c
e : c.Embedding c'
i' j' : ι'
i j : ι
hi : e.f i = i'
hj : e.f j = j'
⊢ (K.extend e).d i' j' = (K.extendXIso e hi).hom ≫ K.d i j ≫ (K.extendXIso e hj).inv
state_after: no goals
tactic: apply extend.d_eq
Theorem: Submodule.toLinearPMap_range
File: Mathlib/LinearAlgebra/LinearPMap.lean

Proof steps:
state_before: R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
g : Submodule R (E × F)
hg : ∀ x ∈ g, x.1 = 0 → x.2 = 0
⊢ LinearMap.range g.toLinearPMap.toFun = map (LinearMap.snd R E F) g
state_after: no goals
tactic: rwa [← LinearPMap.graph_map_snd_eq_range, toLinearPMap_graph_eq]
Theorem: WeierstrassCurve.variableChange_b₄
File: Mathlib/AlgebraicGeometry/EllipticCurve/Weierstrass.lean

Proof steps:
state_before: R : Type u
inst✝ : CommRing R
W : WeierstrassCurve R
C : VariableChange R
⊢ (W.variableChange C).b₄ = ↑C.u⁻¹ ^ 4 * (W.b₄ + C.r * W.b₂ + 6 * C.r ^ 2)
state_after: R : Type u
inst✝ : CommRing R
W : WeierstrassCurve R
C : VariableChange R
⊢ 2 * (↑C.u⁻¹ ^ 4 * (W.a₄ - C.s * W.a₃ + 2 * C.r * W.a₂ - (C.t + C.r * C.s) * W.a₁ + 3 * C.r ^ 2 - 2 * C.s * C.t)) +
      ↑C.u⁻¹ * (W.a₁ + 2 * C.s) * (↑C.u⁻¹ ^ 3 * (W.a₃ + C.r * W.a₁ + 2 * C.t)) =
    ↑C.u⁻¹ ^ 4 * (2 * W.a₄ + W.a₁ * W.a₃ + C.r * (W.a₁ ^ 2 + 4 * W.a₂) + 6 * C.r ^ 2)
tactic: simp only [b₂, b₄, variableChange_a₁, variableChange_a₃, variableChange_a₄]
state_before: R : Type u
inst✝ : CommRing R
W : WeierstrassCurve R
C : VariableChange R
⊢ 2 * (↑C.u⁻¹ ^ 4 * (W.a₄ - C.s * W.a₃ + 2 * C.r * W.a₂ - (C.t + C.r * C.s) * W.a₁ + 3 * C.r ^ 2 - 2 * C.s * C.t)) +
      ↑C.u⁻¹ * (W.a₁ + 2 * C.s) * (↑C.u⁻¹ ^ 3 * (W.a₃ + C.r * W.a₁ + 2 * C.t)) =
    ↑C.u⁻¹ ^ 4 * (2 * W.a₄ + W.a₁ * W.a₃ + C.r * (W.a₁ ^ 2 + 4 * W.a₂) + 6 * C.r ^ 2)
state_after: no goals
tactic: ring1
Theorem: Set.indicator_inter_support
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 : α
s : Set α
f : α → M
⊢ (s ∩ mulSupport f).mulIndicator f = s.mulIndicator f
state_after: no goals
tactic: rw [← mulIndicator_mulIndicator, mulIndicator_mulSupport]
Theorem: continuous_bool_rng
File: Mathlib/Topology/Constructions.lean

Proof steps:
state_before: X : Type u
Y : Type v
Z : Type u_1
W : Type u_2
ε : Type u_3
ζ : Type u_4
inst✝ : TopologicalSpace X
f : X → Bool
b : Bool
⊢ Continuous f ↔ IsClopen (f ⁻¹' {b})
state_after: no goals
tactic: rw [continuous_discrete_rng, Bool.forall_bool' b, IsClopen, ← isOpen_compl_iff, ← preimage_compl,
    Bool.compl_singleton, and_comm]
Theorem: associated_zero_iff_eq_zero
File: Mathlib/Algebra/Associated/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : MonoidWithZero α
a : α
h : a ~ᵤ 0
⊢ a = 0
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : MonoidWithZero α
a : α
h✝ : a ~ᵤ 0
u : αˣ
h : 0 * ↑u = a
⊢ a = 0
tactic: let ⟨u, h⟩ := h.symm
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : MonoidWithZero α
a : α
h✝ : a ~ᵤ 0
u : αˣ
h : 0 * ↑u = a
⊢ a = 0
state_after: no goals
tactic: simpa using h.symm
Theorem: SemiNormedGrp.explicitCokernelIso_inv_π
File: Mathlib/Analysis/Normed/Group/SemiNormedGrp/Kernels.lean

Proof steps:
state_before: X Y : SemiNormedGrp
f : X ⟶ Y
⊢ cokernel.π f ≫ (explicitCokernelIso f).inv = explicitCokernelπ f
state_after: no goals
tactic: simp [explicitCokernelπ, explicitCokernelIso]
Theorem: Fin.foldl_loop
File: .lake/packages/batteries/Batteries/Data/Fin/Lemmas.lean

Proof steps:
state_before: α : Sort u_1
n m : Nat
f : α → Fin (n + 1) → α
x : α
h : m < n + 1
⊢ foldl.loop (n + 1) f x m = foldl.loop n (fun x i => f x i.succ) (f x ⟨m, h⟩) m
state_after: no goals
tactic: if h' : m < n then
    rw [foldl_loop_lt _ _ h, foldl_loop_lt _ _ h', foldl_loop]; rfl
  else
    cases Nat.le_antisymm (Nat.le_of_lt_succ h) (Nat.not_lt.1 h')
    rw [foldl_loop_lt, foldl_loop_eq, foldl_loop_eq]
Theorem: MeasureTheory.Lp.toLp_coeFn
File: Mathlib/MeasureTheory/Function/LpSpace.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : ↥(Lp E p μ)
hf : Memℒp (↑↑f) p μ
⊢ Memℒp.toLp (↑↑f) hf = f
state_after: case mk
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
val✝ : α →ₘ[μ] E
property✝ : val✝ ∈ Lp E p μ
hf : Memℒp (↑↑⟨val✝, property✝⟩) p μ
⊢ Memℒp.toLp (↑↑⟨val✝, property✝⟩) hf = ⟨val✝, property✝⟩
tactic: cases f
state_before: case mk
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
val✝ : α →ₘ[μ] E
property✝ : val✝ ∈ Lp E p μ
hf : Memℒp (↑↑⟨val✝, property✝⟩) p μ
⊢ Memℒp.toLp (↑↑⟨val✝, property✝⟩) hf = ⟨val✝, property✝⟩
state_after: no goals
tactic: simp [Memℒp.toLp]
Theorem: Matrix.dotProduct_neg
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✝² : Fintype m
inst✝¹ : Fintype n
inst✝ : NonUnitalNonAssocRing α
u v w : m → α
⊢ v ⬝ᵥ -w = -(v ⬝ᵥ w)
state_after: no goals
tactic: simp [dotProduct]
Theorem: IsOfFinOrder.val_inv_unit
File: Mathlib/GroupTheory/OrderOfElement.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : Monoid G
a b x✝ y : G
n m : ℕ
M : Type ?u.50075
inst✝ : Monoid M
x : M
hx : IsOfFinOrder x
⊢ x * x ^ (orderOf x - 1) = 1
state_after: no goals
tactic: rw [← _root_.pow_succ', tsub_add_cancel_of_le (by exact hx.orderOf_pos), pow_orderOf_eq_one]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : Monoid G
a b x✝ y : G
n m : ℕ
M : Type ?u.50075
inst✝ : Monoid M
x : M
hx : IsOfFinOrder x
⊢ x ^ (orderOf x - 1) * x = 1
state_after: no goals
tactic: rw [← _root_.pow_succ, tsub_add_cancel_of_le (by exact hx.orderOf_pos), pow_orderOf_eq_one]
Theorem: Finset.subset_vadd_finset_iff
File: Mathlib/Data/Finset/Pointwise.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : DecidableEq β
inst✝¹ : Group α
inst✝ : MulAction α β
s t : Finset β
a : α
b : β
⊢ s ⊆ a • t ↔ a⁻¹ • s ⊆ t
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : DecidableEq β
inst✝¹ : Group α
inst✝ : MulAction α β
s t : Finset β
a : α
b : β
⊢ ↑s ⊆ ↑(a • t) ↔ ↑(a⁻¹ • s) ⊆ ↑t
tactic: simp_rw [← coe_subset]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : DecidableEq β
inst✝¹ : Group α
inst✝ : MulAction α β
s t : Finset β
a : α
b : β
⊢ ↑s ⊆ ↑(a • t) ↔ ↑(a⁻¹ • s) ⊆ ↑t
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : DecidableEq β
inst✝¹ : Group α
inst✝ : MulAction α β
s t : Finset β
a : α
b : β
⊢ ↑s ⊆ a • ↑t ↔ a⁻¹ • ↑s ⊆ ↑t
tactic: push_cast
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : DecidableEq β
inst✝¹ : Group α
inst✝ : MulAction α β
s t : Finset β
a : α
b : β
⊢ ↑s ⊆ a • ↑t ↔ a⁻¹ • ↑s ⊆ ↑t
state_after: no goals
tactic: exact Set.subset_set_smul_iff
Theorem: GaussianFourier.integral_cexp_neg_mul_sum_add
File: Mathlib/Analysis/SpecialFunctions/Gaussian/FourierTransform.lean

Proof steps:
state_before: b : ℂ
V : Type u_1
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : InnerProductSpace ℝ V
inst✝³ : FiniteDimensional ℝ V
inst✝² : MeasurableSpace V
inst✝¹ : BorelSpace V
ι : Type u_2
inst✝ : Fintype ι
hb : 0 < b.re
c : ι → ℂ
⊢ ∫ (v : ι → ℝ), cexp (-b * ∑ i : ι, ↑(v i) ^ 2 + ∑ i : ι, c i * ↑(v i)) =
    (↑π / b) ^ (↑(Fintype.card ι) / 2) * cexp ((∑ i : ι, c i ^ 2) / (4 * b))
state_after: no goals
tactic: simp_rw [neg_mul, Finset.mul_sum, integral_cexp_neg_sum_mul_add (fun _ ↦ hb) c, one_div,
    Finset.prod_mul_distrib, Finset.prod_const, ← cpow_nat_mul, ← Complex.exp_sum, Fintype.card,
    Finset.sum_div, div_eq_mul_inv]
Theorem: Matroid.StrictRestriction.exists_eq_restrict
File: Mathlib/Data/Matroid/Restrict.lean

Proof steps:
state_before: α : Type u_1
M : Matroid α
R I J X Y : Set α
N : Matroid α
h : N <r M
⊢ N = M ↾ N.E
state_after: no goals
tactic: rw [h.eq_restrict]
Theorem: sdiff_eq_symm
File: Mathlib/Order/BooleanAlgebra.lean

Proof steps:
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
hy : y ≤ x
h : x \ y = z
⊢ x \ z = y
state_after: no goals
tactic: rw [← h, sdiff_sdiff_eq_self hy]
Theorem: IsAddUnit.sub_add_cancel_right
File: Mathlib/Algebra/Group/Units.lean

Proof steps:
state_before: α : Type u
M : Type u_1
N : Type u_2
inst✝ : DivisionMonoid α
a✝ b c : α
h : IsUnit b
a : α
⊢ b / (a * b) = a⁻¹
state_after: no goals
tactic: rw [div_eq_mul_inv, mul_inv_rev, h.mul_inv_cancel_left]
Theorem: Set.subsingleton_of_preimage
File: Mathlib/Data/Set/Image.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
s✝ : Set α
f : α → β
hf : Surjective f
s : Set β
hs : (f ⁻¹' s).Subsingleton
fx : β
hx : fx ∈ s
fy : β
hy : fy ∈ s
⊢ fx = fy
state_after: case intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
s✝ : Set α
f : α → β
hf : Surjective f
s : Set β
hs : (f ⁻¹' s).Subsingleton
x : α
hx : f x ∈ s
y : α
hy : f y ∈ s
⊢ f x = f y
tactic: rcases hf fx, hf fy with ⟨⟨x, rfl⟩, ⟨y, rfl⟩⟩
state_before: case intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
s✝ : Set α
f : α → β
hf : Surjective f
s : Set β
hs : (f ⁻¹' s).Subsingleton
x : α
hx : f x ∈ s
y : α
hy : f y ∈ s
⊢ f x = f y
state_after: no goals
tactic: exact congr_arg f (hs hx hy)
Theorem: OrderEmbedding.image_Ioo
File: Mathlib/Order/Interval/Set/OrdConnected.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : Preorder β
e : α ↪o β
he : (range ⇑e).OrdConnected
x y : α
⊢ ⇑e '' Ioo x y = Ioo (e x) (e y)
state_after: no goals
tactic: rw [← e.preimage_Ioo, image_preimage_eq_inter_range,
    inter_eq_left.2 <| Ioo_subset_Icc_self.trans <| he.out ⟨_, rfl⟩ ⟨_, rfl⟩]
Theorem: Finset.disjiUnion_filter_eq_of_maps_to
File: Mathlib/Data/Finset/Union.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s✝ s₁ s₂ : Finset α
t✝ t₁ t₂ : α → Finset β
inst✝ : DecidableEq β
s : Finset α
t : Finset β
f : α → β
h : ∀ x ∈ s, f x ∈ t
⊢ t.disjiUnion (fun a => filter (fun x => f x = a) s) ⋯ = s
state_after: no goals
tactic: simpa [filter_eq_self]
Theorem: EReal.exp_strictMono
File: Mathlib/Analysis/SpecialFunctions/Log/ERealExp.lean

Proof steps:
state_before: ⊢ StrictMono exp
state_after: x y : EReal
h : x < y
⊢ x.exp < y.exp
tactic: intro x y h
state_before: x y : EReal
h : x < y
⊢ x.exp < y.exp
state_after: case h_bot
y : EReal
h : ⊥ < y
⊢ ⊥.exp < y.exp

case h_real
y : EReal
a✝ : ℝ
h : ↑a✝ < y
⊢ (↑a✝).exp < y.exp

case h_top
y : EReal
h : ⊤ < y
⊢ ⊤.exp < y.exp
tactic: induction x
Theorem: Int.ceil_one
File: Mathlib/Algebra/Order/Floor.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a : α
⊢ ⌈1⌉ = 1
state_after: no goals
tactic: rw [← cast_one, ceil_intCast]