1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: MeasureTheory.integrableOn_iff_integrable_of_support_subset
File: Mathlib/MeasureTheory/Integral/IntegrableOn.lean

tactic: refine ⟨fun h => ?_, fun h => h.integrableOn⟩
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : MeasurableSpace α
inst✝ : NormedAddCommGroup E
f g : α → E
s t : Set α
μ ν : Measure α
h1s : support f ⊆ s
⊢ IntegrableOn f s μ ↔ Integrable f μ
state_after: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : MeasurableSpace α
inst✝ : NormedAddCommGroup E
f g : α → E
s t : Set α
μ ν : Measure α
h1s : support f ⊆ s
h : IntegrableOn f s μ
⊢ Integrable f μ

tactic: refine h.integrable_of_forall_not_mem_eq_zero fun x hx => ?_
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : MeasurableSpace α
inst✝ : NormedAddCommGroup E
f g : α → E
s t : Set α
μ ν : Measure α
h1s : support f ⊆ s
h : IntegrableOn f s μ
⊢ Integrable f μ
state_after: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : MeasurableSpace α
inst✝ : NormedAddCommGroup E
f g : α → E
s t : Set α
μ ν : Measure α
h1s : support f ⊆ s
h : IntegrableOn f s μ
x : α
hx : x ∉ s
⊢ f x = 0

tactic: contrapose! hx
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : MeasurableSpace α
inst✝ : NormedAddCommGroup E
f g : α → E
s t : Set α
μ ν : Measure α
h1s : support f ⊆ s
h : IntegrableOn f s μ
x : α
hx : x ∉ s
⊢ f x = 0
state_after: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : MeasurableSpace α
inst✝ : NormedAddCommGroup E
f g : α → E
s t : Set α
μ ν : Measure α
h1s : support f ⊆ s
h : IntegrableOn f s μ
x : α
hx : f x ≠ 0
⊢ x ∈ s

tactic: exact h1s (mem_support.2 hx)
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : MeasurableSpace α
inst✝ : NormedAddCommGroup E
f g : α → E
s t : Set α
μ ν : Measure α
h1s : support f ⊆ s
h : IntegrableOn f s μ
x : α
hx : f x ≠ 0
⊢ x ∈ s
state_after: no goals
Theorem: List.Palindrome.append_reverse
File: Mathlib/Data/List/Palindrome.lean

tactic: apply of_reverse_eq
state_before: α : Type u_1
β : Type u_2
l✝ l : List α
⊢ (l ++ l.reverse).Palindrome
state_after: case a
α : Type u_1
β : Type u_2
l✝ l : List α
⊢ (l ++ l.reverse).reverse = l ++ l.reverse

tactic: rw [reverse_append, reverse_reverse]
state_before: case a
α : Type u_1
β : Type u_2
l✝ l : List α
⊢ (l ++ l.reverse).reverse = l ++ l.reverse
state_after: no goals
Theorem: Orientation.two_zsmul_oangle_neg_self_left
File: Mathlib/Geometry/Euclidean/Angle/Oriented/Basic.lean

tactic: by_cases hx : x = 0 <;> simp [hx]
state_before: V : Type u_1
V' : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : NormedAddCommGroup V'
inst✝³ : InnerProductSpace ℝ V
inst✝² : InnerProductSpace ℝ V'
inst✝¹ : Fact (finrank ℝ V = 2)
inst✝ : Fact (finrank ℝ V' = 2)
o : Orientation ℝ V (Fin 2)
x : V
⊢ 2 • o.oangle (-x) x = 0
state_after: no goals
Theorem: Matrix.norm_eq_sup_sup_nnnorm
File: Mathlib/Analysis/Matrix.lean

tactic: simp_rw [Matrix.norm_def, Pi.norm_def, Pi.nnnorm_def]
state_before: R : Type u_1
l : Type u_2
m : Type u_3
n : Type u_4
α : Type u_5
β : Type u_6
ι : Type u_7
inst✝⁵ : Fintype l
inst✝⁴ : Fintype m
inst✝³ : Fintype n
inst✝² : Unique ι
inst✝¹ : SeminormedAddCommGroup α
inst✝ : SeminormedAddCommGroup β
A : Matrix m n α
⊢ ‖A‖ = ↑(Finset.univ.sup fun i => Finset.univ.sup fun j => ‖A i j‖₊)
state_after: no goals
Theorem: HNNExtension.of_mul_t
File: Mathlib/GroupTheory/HNNExtension.lean

tactic: rw [t_mul_of]
state_before: G : Type u_1
inst✝² : Group G
A B : Subgroup G
φ : ↥A ≃* ↥B
H : Type u_2
inst✝¹ : Group H
M : Type u_3
inst✝ : Monoid M
b : ↥B
⊢ of ↑b * t = t * of ↑(φ.symm b)
state_after: G : Type u_1
inst✝² : Group G
A B : Subgroup G
φ : ↥A ≃* ↥B
H : Type u_2
inst✝¹ : Group H
M : Type u_3
inst✝ : Monoid M
b : ↥B
⊢ of ↑b * t = of ↑(φ (φ.symm b)) * t

tactic: simp
state_before: G : Type u_1
inst✝² : Group G
A B : Subgroup G
φ : ↥A ≃* ↥B
H : Type u_2
inst✝¹ : Group H
M : Type u_3
inst✝ : Monoid M
b : ↥B
⊢ of ↑b * t = of ↑(φ (φ.symm b)) * t
state_after: no goals
Theorem: MeasureTheory.Measure.zero_le_toSignedMeasure
File: Mathlib/MeasureTheory/Measure/VectorMeasure.lean

tactic: rw [← le_restrict_univ_iff_le]
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ : Measure α
inst✝ : IsFiniteMeasure μ
⊢ 0 ≤ μ.toSignedMeasure
state_after: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ : Measure α
inst✝ : IsFiniteMeasure μ
⊢ VectorMeasure.restrict 0 univ ≤ VectorMeasure.restrict μ.toSignedMeasure univ

tactic: refine restrict_le_restrict_of_subset_le _ _ fun j hj₁ _ => ?_
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ : Measure α
inst✝ : IsFiniteMeasure μ
⊢ VectorMeasure.restrict 0 univ ≤ VectorMeasure.restrict μ.toSignedMeasure univ
state_after: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ : Measure α
inst✝ : IsFiniteMeasure μ
j : Set α
hj₁ : MeasurableSet j
x✝ : j ⊆ univ
⊢ ↑0 j ≤ ↑μ.toSignedMeasure j

tactic: simp only [Measure.toSignedMeasure_apply_measurable hj₁, coe_zero, Pi.zero_apply,
  ENNReal.toReal_nonneg, VectorMeasure.coe_zero]
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ : Measure α
inst✝ : IsFiniteMeasure μ
j : Set α
hj₁ : MeasurableSet j
x✝ : j ⊆ univ
⊢ ↑0 j ≤ ↑μ.toSignedMeasure j
state_after: no goals
Theorem: Stream'.map_append_stream
File: Mathlib/Data/Stream/Init.lean

tactic: rw [cons_append_stream, List.map_cons, map_cons, cons_append_stream, map_append_stream f l]
state_before: α : Type u
β : Type v
δ : Type w
f : α → β
a : α
l : List α
s : Stream' α
⊢ map f (a :: l ++ₛ s) = List.map f (a :: l) ++ₛ map f s
state_after: no goals
Theorem: Nat.Primrec'.if_lt
File: Mathlib/Computability/Primrec.lean

tactic: cases e : b v - a v
state_before: n : ℕ
a b f g : Vector ℕ n → ℕ
ha : Primrec' a
hb : Primrec' b
hf : Primrec' f
hg : Primrec' g
v : Vector ℕ n
⊢ Nat.rec (g v) (fun y IH => f (y ::ᵥ IH ::ᵥ v).tail.tail) (b v - a v) = if a v < b v then f v else g v
state_after: case zero
n : ℕ
a b f g : Vector ℕ n → ℕ
ha : Primrec' a
hb : Primrec' b
hf : Primrec' f
hg : Primrec' g
v : Vector ℕ n
e : b v - a v = 0
⊢ Nat.rec (g v) (fun y IH => f (y ::ᵥ IH ::ᵥ v).tail.tail) 0 = if a v < b v then f v else g v

case succ
n : ℕ
a b f g : Vector ℕ n → ℕ
ha : Primrec' a
hb : Primrec' b
hf : Primrec' f
hg : Primrec' g
v : Vector ℕ n
n✝ : ℕ
e : b v - a v = n✝ + 1
⊢ Nat.rec (g v) (fun y IH => f (y ::ᵥ IH ::ᵥ v).tail.tail) (n✝ + 1) = if a v < b v then f v else g v

tactic: simp [not_lt.2 (tsub_eq_zero_iff_le.mp e)]
state_before: case zero
n : ℕ
a b f g : Vector ℕ n → ℕ
ha : Primrec' a
hb : Primrec' b
hf : Primrec' f
hg : Primrec' g
v : Vector ℕ n
e : b v - a v = 0
⊢ Nat.rec (g v) (fun y IH => f (y ::ᵥ IH ::ᵥ v).tail.tail) 0 = if a v < b v then f v else g v
state_after: no goals

tactic: simp [Nat.lt_of_sub_eq_succ e]
state_before: case succ
n : ℕ
a b f g : Vector ℕ n → ℕ
ha : Primrec' a
hb : Primrec' b
hf : Primrec' f
hg : Primrec' g
v : Vector ℕ n
n✝ : ℕ
e : b v - a v = n✝ + 1
⊢ Nat.rec (g v) (fun y IH => f (y ::ᵥ IH ::ᵥ v).tail.tail) (n✝ + 1) = if a v < b v then f v else g v
state_after: no goals
Theorem: DFinsupp.mapRange_id
File: Mathlib/Data/DFinsupp/Basic.lean

tactic: ext
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : (i : ι) → Zero (β i)
inst✝¹ : (i : ι) → Zero (β₁ i)
inst✝ : (i : ι) → Zero (β₂ i)
h : optParam (∀ (i : ι), id 0 = 0) ⋯
g : Π₀ (i : ι), β₁ i
⊢ mapRange (fun i => id) h g = g
state_after: case h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : (i : ι) → Zero (β i)
inst✝¹ : (i : ι) → Zero (β₁ i)
inst✝ : (i : ι) → Zero (β₂ i)
h : optParam (∀ (i : ι), id 0 = 0) ⋯
g : Π₀ (i : ι), β₁ i
i✝ : ι
⊢ (mapRange (fun i => id) h g) i✝ = g i✝

tactic: rfl
state_before: case h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : (i : ι) → Zero (β i)
inst✝¹ : (i : ι) → Zero (β₁ i)
inst✝ : (i : ι) → Zero (β₂ i)
h : optParam (∀ (i : ι), id 0 = 0) ⋯
g : Π₀ (i : ι), β₁ i
i✝ : ι
⊢ (mapRange (fun i => id) h g) i✝ = g i✝
state_after: no goals
Theorem: MeasureTheory.forall_measure_preimage_mul_right_iff
File: Mathlib/MeasureTheory/Group/Measure.lean

tactic: exact ⟨fun h => ⟨h⟩, fun h => h.1⟩
state_before: 𝕜 : Type u_1
G : Type u_2
H : Type u_3
inst✝³ : MeasurableSpace G
inst✝² : MeasurableSpace H
inst✝¹ : Mul G
μ✝ : Measure G
inst✝ : MeasurableMul G
μ : Measure G
⊢ (∀ (g : G), Measure.map (fun x => x * g) μ = μ) ↔ μ.IsMulRightInvariant
state_after: no goals

tactic: simp_rw [Measure.ext_iff]
state_before: 𝕜 : Type u_1
G : Type u_2
H : Type u_3
inst✝³ : MeasurableSpace G
inst✝² : MeasurableSpace H
inst✝¹ : Mul G
μ✝ : Measure G
inst✝ : MeasurableMul G
μ : Measure G
⊢ (∀ (g : G) (A : Set G), MeasurableSet A → μ ((fun h => h * g) ⁻¹' A) = μ A) ↔
    ∀ (g : G), Measure.map (fun x => x * g) μ = μ
state_after: 𝕜 : Type u_1
G : Type u_2
H : Type u_3
inst✝³ : MeasurableSpace G
inst✝² : MeasurableSpace H
inst✝¹ : Mul G
μ✝ : Measure G
inst✝ : MeasurableMul G
μ : Measure G
⊢ (∀ (g : G) (A : Set G), MeasurableSet A → μ ((fun h => h * g) ⁻¹' A) = μ A) ↔
    ∀ (g : G) (s : Set G), MeasurableSet s → (Measure.map (fun x => x * g) μ) s = μ s

tactic: refine forall_congr' fun g => forall_congr' fun A => forall_congr' fun hA => ?_
state_before: 𝕜 : Type u_1
G : Type u_2
H : Type u_3
inst✝³ : MeasurableSpace G
inst✝² : MeasurableSpace H
inst✝¹ : Mul G
μ✝ : Measure G
inst✝ : MeasurableMul G
μ : Measure G
⊢ (∀ (g : G) (A : Set G), MeasurableSet A → μ ((fun h => h * g) ⁻¹' A) = μ A) ↔
    ∀ (g : G) (s : Set G), MeasurableSet s → (Measure.map (fun x => x * g) μ) s = μ s
state_after: 𝕜 : Type u_1
G : Type u_2
H : Type u_3
inst✝³ : MeasurableSpace G
inst✝² : MeasurableSpace H
inst✝¹ : Mul G
μ✝ : Measure G
inst✝ : MeasurableMul G
μ : Measure G
g : G
A : Set G
hA : MeasurableSet A
⊢ μ ((fun h => h * g) ⁻¹' A) = μ A ↔ (Measure.map (fun x => x * g) μ) A = μ A

tactic: rw [map_apply (measurable_mul_const g) hA]
state_before: 𝕜 : Type u_1
G : Type u_2
H : Type u_3
inst✝³ : MeasurableSpace G
inst✝² : MeasurableSpace H
inst✝¹ : Mul G
μ✝ : Measure G
inst✝ : MeasurableMul G
μ : Measure G
g : G
A : Set G
hA : MeasurableSet A
⊢ μ ((fun h => h * g) ⁻¹' A) = μ A ↔ (Measure.map (fun x => x * g) μ) A = μ A
state_after: no goals
Theorem: Encodable.Subtype.encode_eq
File: Mathlib/Logic/Encodable/Basic.lean

tactic: cases a
state_before: α : Type u_1
β : Type u_2
P : α → Prop
encA : Encodable α
decP : DecidablePred P
a : Subtype P
⊢ encode a = encode ↑a
state_after: case mk
α : Type u_1
β : Type u_2
P : α → Prop
encA : Encodable α
decP : DecidablePred P
val✝ : α
property✝ : P val✝
⊢ encode ⟨val✝, property✝⟩ = encode ↑⟨val✝, property✝⟩

tactic: rfl
state_before: case mk
α : Type u_1
β : Type u_2
P : α → Prop
encA : Encodable α
decP : DecidablePred P
val✝ : α
property✝ : P val✝
⊢ encode ⟨val✝, property✝⟩ = encode ↑⟨val✝, property✝⟩
state_after: no goals
Theorem: Set.image2_singleton_right
File: Mathlib/Data/Set/NAry.lean

tactic: simp
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
ζ : Type u_11
ζ' : Type u_12
ν : Type u_13
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
x : γ
⊢ x ∈ image2 f s {b} ↔ x ∈ (fun a => f a b) '' s
state_after: no goals
Theorem: List.mem_inter_iff
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

tactic: cases l₁ <;> simp [List.inter_def, mem_filter]
state_before: α : Type u_1
inst✝¹ : BEq α
inst✝ : LawfulBEq α
x : α
l₁ l₂ : List α
⊢ x ∈ l₁ ∩ l₂ ↔ x ∈ l₁ ∧ x ∈ l₂
state_after: no goals
Theorem: right_eq_midpoint_iff
File: Mathlib/LinearAlgebra/AffineSpace/Midpoint.lean

tactic: rw [eq_comm, midpoint_eq_right_iff]
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁷ : Ring R
inst✝⁶ : Invertible 2
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x✝ y✝ z x y : P
⊢ y = midpoint R x y ↔ x = y
state_after: no goals
Theorem: HahnSeries.order_eq_orderTop_of_ne
File: Mathlib/RingTheory/HahnSeries/Basic.lean

tactic: rw [order_of_ne hx, orderTop_of_ne hx]
state_before: Γ : Type u_1
R : Type u_2
inst✝² : PartialOrder Γ
inst✝¹ : Zero R
a b : Γ
r : R
inst✝ : Zero Γ
x : HahnSeries Γ R
hx : x ≠ 0
⊢ ↑x.order = x.orderTop
state_after: no goals
Theorem: minpoly.dvd_iff
File: Mathlib/FieldTheory/Minpoly/Field.lean

tactic: rw [hq, map_mul, aeval, zero_mul]
state_before: A : Type u_1
B : Type u_2
inst✝² : Field A
inst✝¹ : Ring B
inst✝ : Algebra A B
x : B
p : A[X]
x✝ : minpoly A x ∣ p
q : A[X]
hq : p = minpoly A x * q
⊢ (Polynomial.aeval x) p = 0
state_after: no goals
Theorem: Units.ext
File: Mathlib/Algebra/Group/Units.lean

tactic: simp only at e
state_before: α : Type u
inst✝ : Monoid α
v i₁ : α
vi₁ : v * i₁ = 1
iv₁ : i₁ * v = 1
v' i₂ : α
vi₂ : v' * i₂ = 1
iv₂ : i₂ * v' = 1
e : ↑{ val := v, inv := i₁, val_inv := vi₁, inv_val := iv₁ } = ↑{ val := v', inv := i₂, val_inv := vi₂, inv_val := iv₂ }
⊢ { val := v, inv := i₁, val_inv := vi₁, inv_val := iv₁ } = { val := v', inv := i₂, val_inv := vi₂, inv_val := iv₂ }
state_after: α : Type u
inst✝ : Monoid α
v i₁ : α
vi₁ : v * i₁ = 1
iv₁ : i₁ * v = 1
v' i₂ : α
vi₂ : v' * i₂ = 1
iv₂ : i₂ * v' = 1
e : v = v'
⊢ { val := v, inv := i₁, val_inv := vi₁, inv_val := iv₁ } = { val := v', inv := i₂, val_inv := vi₂, inv_val := iv₂ }

tactic: subst v'
state_before: α : Type u
inst✝ : Monoid α
v i₁ : α
vi₁ : v * i₁ = 1
iv₁ : i₁ * v = 1
v' i₂ : α
vi₂ : v' * i₂ = 1
iv₂ : i₂ * v' = 1
e : v = v'
⊢ { val := v, inv := i₁, val_inv := vi₁, inv_val := iv₁ } = { val := v', inv := i₂, val_inv := vi₂, inv_val := iv₂ }
state_after: α : Type u
inst✝ : Monoid α
v i₁ : α
vi₁ : v * i₁ = 1
iv₁ : i₁ * v = 1
i₂ : α
vi₂ : v * i₂ = 1
iv₂ : i₂ * v = 1
⊢ { val := v, inv := i₁, val_inv := vi₁, inv_val := iv₁ } = { val := v, inv := i₂, val_inv := vi₂, inv_val := iv₂ }

tactic: congr
state_before: α : Type u
inst✝ : Monoid α
v i₁ : α
vi₁ : v * i₁ = 1
iv₁ : i₁ * v = 1
i₂ : α
vi₂ : v * i₂ = 1
iv₂ : i₂ * v = 1
⊢ { val := v, inv := i₁, val_inv := vi₁, inv_val := iv₁ } = { val := v, inv := i₂, val_inv := vi₂, inv_val := iv₂ }
state_after: case e_inv
α : Type u
inst✝ : Monoid α
v i₁ : α
vi₁ : v * i₁ = 1
iv₁ : i₁ * v = 1
i₂ : α
vi₂ : v * i₂ = 1
iv₂ : i₂ * v = 1
⊢ i₁ = i₂

tactic: simpa only [iv₂, vi₁, one_mul, mul_one] using mul_assoc i₂ v i₁
state_before: case e_inv
α : Type u
inst✝ : Monoid α
v i₁ : α
vi₁ : v * i₁ = 1
iv₁ : i₁ * v = 1
i₂ : α
vi₂ : v * i₂ = 1
iv₂ : i₂ * v = 1
⊢ i₁ = i₂
state_after: no goals
Theorem: Set.ite_right
File: Mathlib/Data/Set/Basic.lean

tactic: simp [Set.ite]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t✝ t₁ t₂ u s t : Set α
⊢ s.ite t s = t ∩ s
state_after: no goals
Theorem: Complex.log_zero
File: Mathlib/Analysis/SpecialFunctions/Complex/Log.lean

tactic: simp [log]
state_before: ⊢ log 0 = 0
state_after: no goals
Theorem: Equiv.Perm.IsCycleOn.pow_apply_eq_pow_apply
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: rw [Nat.modEq_iff_dvd, ← hf.zpow_apply_eq ha]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
s✝ t : Set α
a b x y : α
s : Finset α
hf : f.IsCycleOn ↑s
ha : a ∈ s
m n : ℕ
⊢ (f ^ m) a = (f ^ n) a ↔ m ≡ n [MOD s.card]
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
s✝ t : Set α
a b x y : α
s : Finset α
hf : f.IsCycleOn ↑s
ha : a ∈ s
m n : ℕ
⊢ (f ^ m) a = (f ^ n) a ↔ (f ^ (↑n - ↑m)) a = a

tactic: simp [sub_eq_neg_add, zpow_add, eq_inv_iff_eq, eq_comm]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
s✝ t : Set α
a b x y : α
s : Finset α
hf : f.IsCycleOn ↑s
ha : a ∈ s
m n : ℕ
⊢ (f ^ m) a = (f ^ n) a ↔ (f ^ (↑n - ↑m)) a = a
state_after: no goals
Theorem: Ring.DirectLimit.map_id
File: Mathlib/Algebra/DirectLimit.lean

tactic: simp
state_before: R : Type u
inst✝⁷ : Ring R
ι : Type v
inst✝⁶ : Preorder ι
G : ι → Type w
inst✝⁵ : (i : ι) → CommRing (G i)
f✝ : (i j : ι) → i ≤ j → G i → G j
f'✝ : (i j : ι) → i ≤ j → G i →+* G j
P : Type u₁
inst✝⁴ : CommRing P
g✝ : (i : ι) → G i →+* P
Hg : ∀ (i j : ι) (hij : i ≤ j) (x : G i), (g✝ j) (f✝ i j hij x) = (g✝ i) x
f : (i j : ι) → i ≤ j → G i →+* G j
G' : ι → Type v'
inst✝³ : (i : ι) → CommRing (G' i)
f' : (i j : ι) → i ≤ j → G' i →+* G' j
G'' : ι → Type v''
inst✝² : (i : ι) → CommRing (G'' i)
f'' : (i j : ι) → i ≤ j → G'' i →+* G'' j
inst✝¹ : Nonempty ι
inst✝ : IsDirected ι fun x x_1 => x ≤ x_1
x : DirectLimit G fun x x_1 h => ⇑(f x x_1 h)
i : ι
g : G i
⊢ (map (fun i => RingHom.id (G i)) ⋯) ((of G (fun x x_1 h => ⇑(f x x_1 h)) i) g) =
    (RingHom.id (DirectLimit G fun x x_1 h => ⇑(f x x_1 h))) ((of G (fun x x_1 h => ⇑(f x x_1 h)) i) g)
state_after: no goals
Theorem: MeasureTheory.convolution_smul
File: Mathlib/Analysis/Convolution.lean

tactic: ext
state_before: 𝕜 : Type u𝕜
G : Type uG
E : Type uE
E' : Type uE'
E'' : Type uE''
F : Type uF
F' : Type uF'
F'' : Type uF''
P : Type uP
inst✝¹² : NormedAddCommGroup E
inst✝¹¹ : NormedAddCommGroup E'
inst✝¹⁰ : NormedAddCommGroup E''
inst✝⁹ : NormedAddCommGroup F
f f' : G → E
g g' : G → E'
x x' : G
y✝ y' : E
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedSpace 𝕜 E
inst✝⁶ : NormedSpace 𝕜 E'
inst✝⁵ : NormedSpace 𝕜 E''
inst✝⁴ : NormedSpace 𝕜 F
L : E →L[𝕜] E' →L[𝕜] F
inst✝³ : MeasurableSpace G
μ ν : Measure G
inst✝² : NormedSpace ℝ F
inst✝¹ : AddGroup G
inst✝ : SMulCommClass ℝ 𝕜 F
y : 𝕜
⊢ f ⋆[L, μ] y • g = y • (f ⋆[L, μ] g)
state_after: case h
𝕜 : Type u𝕜
G : Type uG
E : Type uE
E' : Type uE'
E'' : Type uE''
F : Type uF
F' : Type uF'
F'' : Type uF''
P : Type uP
inst✝¹² : NormedAddCommGroup E
inst✝¹¹ : NormedAddCommGroup E'
inst✝¹⁰ : NormedAddCommGroup E''
inst✝⁹ : NormedAddCommGroup F
f f' : G → E
g g' : G → E'
x x' : G
y✝ y' : E
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedSpace 𝕜 E
inst✝⁶ : NormedSpace 𝕜 E'
inst✝⁵ : NormedSpace 𝕜 E''
inst✝⁴ : NormedSpace 𝕜 F
L : E →L[𝕜] E' →L[𝕜] F
inst✝³ : MeasurableSpace G
μ ν : Measure G
inst✝² : NormedSpace ℝ F
inst✝¹ : AddGroup G
inst✝ : SMulCommClass ℝ 𝕜 F
y : 𝕜
x✝ : G
⊢ (f ⋆[L, μ] y • g) x✝ = (y • (f ⋆[L, μ] g)) x✝

tactic: simp only [Pi.smul_apply, convolution_def, ← integral_smul, (L _).map_smul]
state_before: case h
𝕜 : Type u𝕜
G : Type uG
E : Type uE
E' : Type uE'
E'' : Type uE''
F : Type uF
F' : Type uF'
F'' : Type uF''
P : Type uP
inst✝¹² : NormedAddCommGroup E
inst✝¹¹ : NormedAddCommGroup E'
inst✝¹⁰ : NormedAddCommGroup E''
inst✝⁹ : NormedAddCommGroup F
f f' : G → E
g g' : G → E'
x x' : G
y✝ y' : E
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedSpace 𝕜 E
inst✝⁶ : NormedSpace 𝕜 E'
inst✝⁵ : NormedSpace 𝕜 E''
inst✝⁴ : NormedSpace 𝕜 F
L : E →L[𝕜] E' →L[𝕜] F
inst✝³ : MeasurableSpace G
μ ν : Measure G
inst✝² : NormedSpace ℝ F
inst✝¹ : AddGroup G
inst✝ : SMulCommClass ℝ 𝕜 F
y : 𝕜
x✝ : G
⊢ (f ⋆[L, μ] y • g) x✝ = (y • (f ⋆[L, μ] g)) x✝
state_after: no goals
Theorem: CategoryTheory.Subgroupoid.disconnect_le
File: Mathlib/CategoryTheory/Groupoid/Subgroupoid.lean

tactic: rw [le_iff]
state_before: C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
⊢ S.disconnect ≤ S
state_after: C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
⊢ ∀ {c d : C}, S.disconnect.arrows c d ⊆ S.arrows c d

tactic: rintro _ _ _ ⟨⟩
state_before: C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
⊢ ∀ {c d : C}, S.disconnect.arrows c d ⊆ S.arrows c d
state_after: case intro
C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
c✝ d✝ : C
a✝ : c✝ ⟶ d✝
left✝ : c✝ = d✝
right✝ : a✝ ∈ S.arrows c✝ d✝
⊢ a✝ ∈ S.arrows c✝ d✝

tactic: assumption
state_before: case intro
C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
c✝ d✝ : C
a✝ : c✝ ⟶ d✝
left✝ : c✝ = d✝
right✝ : a✝ ∈ S.arrows c✝ d✝
⊢ a✝ ∈ S.arrows c✝ d✝
state_after: no goals
Theorem: AdjoinRoot.mk_self
File: Mathlib/RingTheory/AdjoinRoot.lean

tactic: simp
state_before: R : Type u
S : Type v
K : Type w
inst✝ : CommRing R
f : R[X]
⊢ f ∣ -f + 0
state_after: no goals
Theorem: CategoryTheory.Limits.pullbackDiagonalMapIso_hom_snd
File: Mathlib/CategoryTheory/Limits/Shapes/Diagonal.lean

tactic: delta pullbackDiagonalMapIso
state_before: C : Type u_1
inst✝² : Category.{u_2, u_1} C
X Y Z : C
inst✝¹ : HasPullbacks C
U V₁ V₂ : C
f : X ⟶ Y
i : U ⟶ Y
i₁ : V₁ ⟶ pullback f i
i₂ : V₂ ⟶ pullback f i
inst✝ : HasPullback i₁ i₂
⊢ (pullbackDiagonalMapIso f i i₁ i₂).hom ≫ snd = snd ≫ snd
state_after: C : Type u_1
inst✝² : Category.{u_2, u_1} C
X Y Z : C
inst✝¹ : HasPullbacks C
U V₁ V₂ : C
f : X ⟶ Y
i : U ⟶ Y
i₁ : V₁ ⟶ pullback f i
i₂ : V₂ ⟶ pullback f i
inst✝ : HasPullback i₁ i₂
⊢ { hom := lift (snd ≫ fst) (snd ≫ snd) ⋯,
          inv := lift (fst ≫ i₁ ≫ fst) (map i₁ i₂ (i₁ ≫ snd) (i₂ ≫ snd) (𝟙 V₁) (𝟙 V₂) snd ⋯ ⋯) ⋯, hom_inv_id := ⋯,
          inv_hom_id := ⋯ }.hom ≫
      snd =
    snd ≫ snd

tactic: simp
state_before: C : Type u_1
inst✝² : Category.{u_2, u_1} C
X Y Z : C
inst✝¹ : HasPullbacks C
U V₁ V₂ : C
f : X ⟶ Y
i : U ⟶ Y
i₁ : V₁ ⟶ pullback f i
i₂ : V₂ ⟶ pullback f i
inst✝ : HasPullback i₁ i₂
⊢ { hom := lift (snd ≫ fst) (snd ≫ snd) ⋯,
          inv := lift (fst ≫ i₁ ≫ fst) (map i₁ i₂ (i₁ ≫ snd) (i₂ ≫ snd) (𝟙 V₁) (𝟙 V₂) snd ⋯ ⋯) ⋯, hom_inv_id := ⋯,
          inv_hom_id := ⋯ }.hom ≫
      snd =
    snd ≫ snd
state_after: no goals
Theorem: Ordinal.lsub_le_of_range_subset
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: convert Set.image_subset succ h <;> apply Set.range_comp
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
ι : Type u
ι' : Type v
f : ι → Ordinal.{max (max u v) w}
g : ι' → Ordinal.{max (max u v) w}
h : range f ⊆ range g
⊢ range (succ ∘ f) ⊆ range (succ ∘ g)
state_after: no goals
Theorem: IsCompactlyGenerated.BooleanGenerators.isAtomistic_of_sSup_eq_top
File: Mathlib/Order/BooleanGenerators.lean

tactic: refine ⟨fun a ↦ ?_⟩
state_before: α : Type u_1
inst✝¹ : CompleteLattice α
inst✝ : IsCompactlyGenerated α
S : Set α
hS : BooleanGenerators S
h : sSup S = ⊤
⊢ IsAtomistic α
state_after: α : Type u_1
inst✝¹ : CompleteLattice α
inst✝ : IsCompactlyGenerated α
S : Set α
hS : BooleanGenerators S
h : sSup S = ⊤
a : α
⊢ ∃ s, a = sSup s ∧ ∀ a ∈ s, IsAtom a

tactic: obtain ⟨s, hs, hs'⟩ := hS.atomistic a (h ▸ le_top)
state_before: α : Type u_1
inst✝¹ : CompleteLattice α
inst✝ : IsCompactlyGenerated α
S : Set α
hS : BooleanGenerators S
h : sSup S = ⊤
a : α
⊢ ∃ s, a = sSup s ∧ ∀ a ∈ s, IsAtom a
state_after: case intro.intro
α : Type u_1
inst✝¹ : CompleteLattice α
inst✝ : IsCompactlyGenerated α
S : Set α
hS : BooleanGenerators S
h : sSup S = ⊤
a : α
s : Set α
hs : s ⊆ S
hs' : a = sSup s
⊢ ∃ s, a = sSup s ∧ ∀ a ∈ s, IsAtom a

tactic: exact ⟨s, hs', fun I hI ↦ hS.isAtom I (hs hI)⟩
state_before: case intro.intro
α : Type u_1
inst✝¹ : CompleteLattice α
inst✝ : IsCompactlyGenerated α
S : Set α
hS : BooleanGenerators S
h : sSup S = ⊤
a : α
s : Set α
hs : s ⊆ S
hs' : a = sSup s
⊢ ∃ s, a = sSup s ∧ ∀ a ∈ s, IsAtom a
state_after: no goals
Theorem: Cardinal.one_lt_iff_nontrivial
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: rw [← not_le, le_one_iff_subsingleton, ← not_nontrivial_iff_subsingleton, Classical.not_not]
state_before: α✝ β α : Type u
⊢ 1 < #α ↔ Nontrivial α
state_after: no goals
Theorem: Ordinal.one_out_eq
File: Mathlib/SetTheory/Ordinal/Basic.lean

tactic: simp
state_before: α : Type u
β : Type u_1
γ : Type u_2
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
x : (Quotient.out 1).α
⊢ 0 < type fun x x_1 => x < x_1
state_after: no goals
Theorem: Real.toNNReal_le_toNNReal_iff_of_pos
File: Mathlib/Data/NNReal/Basic.lean

tactic: simp [toNNReal_le_toNNReal_iff', hr.not_le]
state_before: r p : ℝ
hr : 0 < r
⊢ r.toNNReal ≤ p.toNNReal ↔ r ≤ p
state_after: no goals
Theorem: AddCircle.norm_neg_period
File: Mathlib/Analysis/Normed/Group/AddCircle.lean

tactic: suffices ‖(↑(-1 * x) : AddCircle (-1 * p))‖ = ‖(x : AddCircle p)‖ by
  rw [← this, neg_one_mul]
  simp
state_before: p x : ℝ
⊢ ‖↑x‖ = ‖↑x‖
state_after: p x : ℝ
⊢ ‖↑(-1 * x)‖ = ‖↑x‖

tactic: simp only [norm_coe_mul, abs_neg, abs_one, one_mul]
state_before: p x : ℝ
⊢ ‖↑(-1 * x)‖ = ‖↑x‖
state_after: no goals

tactic: rw [← this, neg_one_mul]
state_before: p x : ℝ
this : ‖↑(-1 * x)‖ = ‖↑x‖
⊢ ‖↑x‖ = ‖↑x‖
state_after: p x : ℝ
this : ‖↑(-1 * x)‖ = ‖↑x‖
⊢ ‖↑x‖ = ‖↑(-1 * x)‖

tactic: simp
state_before: p x : ℝ
this : ‖↑(-1 * x)‖ = ‖↑x‖
⊢ ‖↑x‖ = ‖↑(-1 * x)‖
state_after: no goals