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

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
r : ℝ≥0∞
f : α → ℝ≥0∞
⊢ r * ∫⁻ (a : α), f a ∂μ ≤ ∫⁻ (a : α), r * f a ∂μ
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
r : ℝ≥0∞
f : α → ℝ≥0∞
⊢ ⨆ i, r * ⨆ (_ : ↑i ≤ fun a => f a), i.lintegral μ ≤ ∫⁻ (a : α), r * f a ∂μ
tactic: rw [lintegral, ENNReal.mul_iSup]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
r : ℝ≥0∞
f : α → ℝ≥0∞
⊢ ⨆ i, r * ⨆ (_ : ↑i ≤ fun a => f a), i.lintegral μ ≤ ∫⁻ (a : α), r * f a ∂μ
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
r : ℝ≥0∞
f : α → ℝ≥0∞
s : α →ₛ ℝ≥0∞
⊢ r * ⨆ (_ : ↑s ≤ fun a => f a), s.lintegral μ ≤ ∫⁻ (a : α), r * f a ∂μ
tactic: refine iSup_le fun s => ?_
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
r : ℝ≥0∞
f : α → ℝ≥0∞
s : α →ₛ ℝ≥0∞
⊢ r * ⨆ (_ : ↑s ≤ fun a => f a), s.lintegral μ ≤ ∫⁻ (a : α), r * f a ∂μ
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
r : ℝ≥0∞
f : α → ℝ≥0∞
s : α →ₛ ℝ≥0∞
⊢ (↑s ≤ fun a => f a) → r * s.lintegral μ ≤ ∫⁻ (a : α), r * f a ∂μ
tactic: rw [ENNReal.mul_iSup, iSup_le_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
r : ℝ≥0∞
f : α → ℝ≥0∞
s : α →ₛ ℝ≥0∞
⊢ (↑s ≤ fun a => f a) → r * s.lintegral μ ≤ ∫⁻ (a : α), r * f a ∂μ
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
r : ℝ≥0∞
f : α → ℝ≥0∞
s : α →ₛ ℝ≥0∞
hs : ↑s ≤ fun a => f a
⊢ r * s.lintegral μ ≤ ∫⁻ (a : α), r * f a ∂μ
tactic: intro hs
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
r : ℝ≥0∞
f : α → ℝ≥0∞
s : α →ₛ ℝ≥0∞
hs : ↑s ≤ fun a => f a
⊢ r * s.lintegral μ ≤ ∫⁻ (a : α), r * f a ∂μ
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
r : ℝ≥0∞
f : α → ℝ≥0∞
s : α →ₛ ℝ≥0∞
hs : ↑s ≤ fun a => f a
⊢ (const α r * s).lintegral μ ≤ ⨆ g, ⨆ (_ : ↑g ≤ fun a => r * f a), g.lintegral μ
tactic: rw [← SimpleFunc.const_mul_lintegral, lintegral]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
r : ℝ≥0∞
f : α → ℝ≥0∞
s : α →ₛ ℝ≥0∞
hs : ↑s ≤ fun a => f a
⊢ (const α r * s).lintegral μ ≤ ⨆ g, ⨆ (_ : ↑g ≤ fun a => r * f a), g.lintegral μ
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
r : ℝ≥0∞
f : α → ℝ≥0∞
s : α →ₛ ℝ≥0∞
hs : ↑s ≤ fun a => f a
x : α
⊢ ↑(const α r * s) x ≤ (fun a => r * f a) x
tactic: refine le_iSup_of_le (const α r * s) (le_iSup_of_le (fun x => ?_) le_rfl)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
r : ℝ≥0∞
f : α → ℝ≥0∞
s : α →ₛ ℝ≥0∞
hs : ↑s ≤ fun a => f a
x : α
⊢ ↑(const α r * s) x ≤ (fun a => r * f a) x
state_after: no goals
tactic: exact mul_le_mul_left' (hs x) _
Theorem: BddAbove.bddBelow_image2_of_bddAbove
File: Mathlib/Order/Bounds/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
f : α → β → γ
s : Set α
t : Set β
a : α
b : β
h₀ : ∀ (b : β), Antitone (swap f b)
h₁ : ∀ (a : α), Monotone (f a)
⊢ BddAbove s → BddBelow t → BddBelow (image2 f s t)
state_after: case intro.intro
α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
f : α → β → γ
s : Set α
t : Set β
a✝ : α
b✝ : β
h₀ : ∀ (b : β), Antitone (swap f b)
h₁ : ∀ (a : α), Monotone (f a)
a : α
ha : a ∈ upperBounds s
b : β
hb : b ∈ lowerBounds t
⊢ BddBelow (image2 f s t)
tactic: rintro ⟨a, ha⟩ ⟨b, hb⟩
state_before: case intro.intro
α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
f : α → β → γ
s : Set α
t : Set β
a✝ : α
b✝ : β
h₀ : ∀ (b : β), Antitone (swap f b)
h₁ : ∀ (a : α), Monotone (f a)
a : α
ha : a ∈ upperBounds s
b : β
hb : b ∈ lowerBounds t
⊢ BddBelow (image2 f s t)
state_after: no goals
tactic: exact ⟨f a b, mem_lowerBounds_image2_of_mem_lowerBounds_of_mem_lowerBounds h₀ h₁ ha hb⟩
Theorem: normEDS_one
File: Mathlib/NumberTheory/EllipticDivisibilitySequence.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : ℤ → R
f : R →+* S
b c d : R
⊢ normEDS b c d 1 = 1
state_after: no goals
tactic: erw [normEDS_ofNat, preNormEDS'_one, one_mul, if_neg Nat.not_even_one]
Theorem: AddMonoidAlgebra.prod_single
File: Mathlib/Algebra/MonoidAlgebra/Basic.lean

Proof steps:
state_before: k : Type u₁
G : Type u₂
H : Type u_1
R : Type u_2
ι : Type ui
inst✝¹ : CommSemiring k
inst✝ : AddCommMonoid G
s✝ : Finset ι
a✝ : ι → G
b : ι → k
a : ι
s : Finset ι
has : a ∉ s
ih : ∏ i ∈ s, single (a✝ i) (b i) = single (∑ i ∈ s, a✝ i) (∏ i ∈ s, b i)
⊢ ∏ i ∈ Finset.cons a s has, single (a✝ i) (b i) =
    single (∑ i ∈ Finset.cons a s has, a✝ i) (∏ i ∈ Finset.cons a s has, b i)
state_after: no goals
tactic: rw [prod_cons has, ih, single_mul_single, sum_cons has, prod_cons has]
Theorem: Cardinal.sum_le_sum
File: Mathlib/SetTheory/Cardinal/Basic.lean

Proof steps:
state_before: α β : Type u
ι : Type u_1
f g : ι → Cardinal.{u_2}
H : ∀ (i : ι), f i ≤ g i
i : ι
⊢ Nonempty (Quotient.out (f i) ↪ Quotient.out (g ((Embedding.refl ι) i)))
state_after: α β : Type u
ι : Type u_1
f g : ι → Cardinal.{u_2}
H : ∀ (i : ι), f i ≤ g i
i : ι
this : f i ≤ g i
⊢ Nonempty (Quotient.out (f i) ↪ Quotient.out (g ((Embedding.refl ι) i)))
tactic: have := H i
state_before: α β : Type u
ι : Type u_1
f g : ι → Cardinal.{u_2}
H : ∀ (i : ι), f i ≤ g i
i : ι
this : f i ≤ g i
⊢ Nonempty (Quotient.out (f i) ↪ Quotient.out (g ((Embedding.refl ι) i)))
state_after: no goals
tactic: rwa [← Quot.out_eq (f i), ← Quot.out_eq (g i)] at this
Theorem: Finset.ordConnected_range_coe
File: Mathlib/Data/Finset/Grade.lean

Proof steps:
state_before: α : Type u_1
s t : Finset α
a : α
⊢ ∀ ⦃x : Set α⦄, x ∈ Set.range toSet → ∀ ⦃y : Set α⦄, y ∈ Set.range toSet → Set.Icc x y ⊆ Set.range toSet
state_after: case intro
α : Type u_1
s✝ t✝ : Finset α
a : α
x✝ : Set α
hx✝ : x✝ ∈ Set.range toSet
s : Finset α
t : Set α
ht : t ∈ Set.Icc x✝ ↑s
⊢ t ∈ Set.range toSet
tactic: rintro _ _ _ ⟨s, rfl⟩ t ht
state_before: case intro
α : Type u_1
s✝ t✝ : Finset α
a : α
x✝ : Set α
hx✝ : x✝ ∈ Set.range toSet
s : Finset α
t : Set α
ht : t ∈ Set.Icc x✝ ↑s
⊢ t ∈ Set.range toSet
state_after: no goals
tactic: exact ⟨_, (s.finite_toSet.subset ht.2).coe_toFinset⟩
Theorem: MulAction.stabilizer_finset_univ
File: Mathlib/Algebra/Pointwise/Stabilizer.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
α : Type u_3
inst✝⁴ : Group G
inst✝³ : Group H
inst✝² : MulAction G α
a : G
inst✝¹ : DecidableEq α
inst✝ : Fintype α
⊢ stabilizer G Finset.univ = ⊤
state_after: case h
G : Type u_1
H : Type u_2
α : Type u_3
inst✝⁴ : Group G
inst✝³ : Group H
inst✝² : MulAction G α
a : G
inst✝¹ : DecidableEq α
inst✝ : Fintype α
x✝ : G
⊢ x✝ ∈ stabilizer G Finset.univ ↔ x✝ ∈ ⊤
tactic: ext
state_before: case h
G : Type u_1
H : Type u_2
α : Type u_3
inst✝⁴ : Group G
inst✝³ : Group H
inst✝² : MulAction G α
a : G
inst✝¹ : DecidableEq α
inst✝ : Fintype α
x✝ : G
⊢ x✝ ∈ stabilizer G Finset.univ ↔ x✝ ∈ ⊤
state_after: no goals
tactic: simp
Theorem: Polynomial.eval_eq_sum_degreeLTEquiv
File: Mathlib/RingTheory/Polynomial/Basic.lean

Proof steps:
state_before: R : Type u
S : Type u_1
inst✝ : Semiring R
n : ℕ
p : R[X]
hp : p ∈ degreeLT R n
x : R
⊢ eval x p = ∑ i : Fin n, (degreeLTEquiv R n) ⟨p, hp⟩ i * x ^ ↑i
state_after: R : Type u
S : Type u_1
inst✝ : Semiring R
n : ℕ
p : R[X]
hp : p ∈ degreeLT R n
x : R
⊢ (p.sum fun e a => a * x ^ e) = ∑ i : Fin n, (degreeLTEquiv R n) ⟨p, hp⟩ i * x ^ ↑i
tactic: simp_rw [eval_eq_sum]
state_before: R : Type u
S : Type u_1
inst✝ : Semiring R
n : ℕ
p : R[X]
hp : p ∈ degreeLT R n
x : R
⊢ (p.sum fun e a => a * x ^ e) = ∑ i : Fin n, (degreeLTEquiv R n) ⟨p, hp⟩ i * x ^ ↑i
state_after: no goals
tactic: exact (sum_fin _ (by simp_rw [zero_mul, forall_const]) (mem_degreeLT.mp hp)).symm
Theorem: MeasureTheory.DominatedFinMeasAdditive.add
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 α
β : Type u_7
inst✝ : SeminormedAddCommGroup β
T T' : Set α → β
C C' : ℝ
hT : DominatedFinMeasAdditive μ T C
hT' : DominatedFinMeasAdditive μ T' C'
⊢ DominatedFinMeasAdditive μ (T + T') (C + C')
state_after: α : 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 α
β : Type u_7
inst✝ : SeminormedAddCommGroup β
T T' : Set α → β
C C' : ℝ
hT : DominatedFinMeasAdditive μ T C
hT' : DominatedFinMeasAdditive μ T' C'
s : Set α
hs : MeasurableSet s
hμs : μ s < ⊤
⊢ ‖(T + T') s‖ ≤ (C + C') * (μ s).toReal
tactic: refine ⟨hT.1.add hT'.1, fun s hs hμs => ?_⟩
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 α
β : Type u_7
inst✝ : SeminormedAddCommGroup β
T T' : Set α → β
C C' : ℝ
hT : DominatedFinMeasAdditive μ T C
hT' : DominatedFinMeasAdditive μ T' C'
s : Set α
hs : MeasurableSet s
hμs : μ s < ⊤
⊢ ‖(T + T') s‖ ≤ (C + C') * (μ s).toReal
state_after: α : 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 α
β : Type u_7
inst✝ : SeminormedAddCommGroup β
T T' : Set α → β
C C' : ℝ
hT : DominatedFinMeasAdditive μ T C
hT' : DominatedFinMeasAdditive μ T' C'
s : Set α
hs : MeasurableSet s
hμs : μ s < ⊤
⊢ ‖T s + T' s‖ ≤ C * (μ s).toReal + C' * (μ s).toReal
tactic: rw [Pi.add_apply, add_mul]
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 α
β : Type u_7
inst✝ : SeminormedAddCommGroup β
T T' : Set α → β
C C' : ℝ
hT : DominatedFinMeasAdditive μ T C
hT' : DominatedFinMeasAdditive μ T' C'
s : Set α
hs : MeasurableSet s
hμs : μ s < ⊤
⊢ ‖T s + T' s‖ ≤ C * (μ s).toReal + C' * (μ s).toReal
state_after: no goals
tactic: exact (norm_add_le _ _).trans (add_le_add (hT.2 s hs hμs) (hT'.2 s hs hμs))
Theorem: CategoryTheory.strongMono_comp
File: Mathlib/CategoryTheory/Limits/Shapes/StrongEpi.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
P Q R : C
f : P ⟶ Q
g : Q ⟶ R
inst✝¹ : StrongMono f
inst✝ : StrongMono g
⊢ ∀ ⦃X Y : C⦄ (z : X ⟶ Y) [inst : Epi z], HasLiftingProperty z (f ≫ g)
state_after: C : Type u
inst✝³ : Category.{v, u} C
P Q R : C
f : P ⟶ Q
g : Q ⟶ R
inst✝² : StrongMono f
inst✝¹ : StrongMono g
X✝ Y✝ : C
z✝ : X✝ ⟶ Y✝
inst✝ : Epi z✝
⊢ HasLiftingProperty z✝ (f ≫ g)
tactic: intros
state_before: C : Type u
inst✝³ : Category.{v, u} C
P Q R : C
f : P ⟶ Q
g : Q ⟶ R
inst✝² : StrongMono f
inst✝¹ : StrongMono g
X✝ Y✝ : C
z✝ : X✝ ⟶ Y✝
inst✝ : Epi z✝
⊢ HasLiftingProperty z✝ (f ≫ g)
state_after: no goals
tactic: infer_instance
Theorem: PythagoreanTriple.even_odd_of_coprime
File: Mathlib/NumberTheory/PythagoreanTriples.lean

Proof steps:
state_before: x y z : ℤ
h : PythagoreanTriple x y z
hc : x.gcd y = 1
⊢ x % 2 = 0 ∧ y % 2 = 1 ∨ x % 2 = 1 ∧ y % 2 = 0
state_after: case inl.inl
x y z : ℤ
h : PythagoreanTriple x y z
hc : x.gcd y = 1
hx : x % 2 = 0
hy : y % 2 = 0
⊢ x % 2 = 0 ∧ y % 2 = 1 ∨ x % 2 = 1 ∧ y % 2 = 0

case inl.inr
x y z : ℤ
h : PythagoreanTriple x y z
hc : x.gcd y = 1
hx : x % 2 = 0
hy : y % 2 = 1
⊢ x % 2 = 0 ∧ y % 2 = 1 ∨ x % 2 = 1 ∧ y % 2 = 0

case inr.inl
x y z : ℤ
h : PythagoreanTriple x y z
hc : x.gcd y = 1
hx : x % 2 = 1
hy : y % 2 = 0
⊢ x % 2 = 0 ∧ y % 2 = 1 ∨ x % 2 = 1 ∧ y % 2 = 0

case inr.inr
x y z : ℤ
h : PythagoreanTriple x y z
hc : x.gcd y = 1
hx : x % 2 = 1
hy : y % 2 = 1
⊢ x % 2 = 0 ∧ y % 2 = 1 ∨ x % 2 = 1 ∧ y % 2 = 0
tactic: cases' Int.emod_two_eq_zero_or_one x with hx hx <;>
    cases' Int.emod_two_eq_zero_or_one y with hy hy
Theorem: Ideal.homogeneousHull_mono
File: Mathlib/RingTheory/GradedAlgebra/HomogeneousIdeal.lean

Proof steps:
state_before: ι : Type u_1
σ : Type u_2
R : Type u_3
A : Type u_4
inst✝⁵ : Semiring A
inst✝⁴ : DecidableEq ι
inst✝³ : AddMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I✝ I J : Ideal A
I_le_J : I ≤ J
⊢ homogeneousHull 𝒜 I ≤ homogeneousHull 𝒜 J
state_after: case a
ι : Type u_1
σ : Type u_2
R : Type u_3
A : Type u_4
inst✝⁵ : Semiring A
inst✝⁴ : DecidableEq ι
inst✝³ : AddMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I✝ I J : Ideal A
I_le_J : I ≤ J
⊢ {r | ∃ i x, ↑(((decompose 𝒜) ↑x) i) = r} ⊆ {r | ∃ i x, ↑(((decompose 𝒜) ↑x) i) = r}
tactic: apply Ideal.span_mono
state_before: case a
ι : Type u_1
σ : Type u_2
R : Type u_3
A : Type u_4
inst✝⁵ : Semiring A
inst✝⁴ : DecidableEq ι
inst✝³ : AddMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I✝ I J : Ideal A
I_le_J : I ≤ J
⊢ {r | ∃ i x, ↑(((decompose 𝒜) ↑x) i) = r} ⊆ {r | ∃ i x, ↑(((decompose 𝒜) ↑x) i) = r}
state_after: case a.intro.intro.mk
ι : Type u_1
σ : Type u_2
R : Type u_3
A : Type u_4
inst✝⁵ : Semiring A
inst✝⁴ : DecidableEq ι
inst✝³ : AddMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I✝ I J : Ideal A
I_le_J : I ≤ J
hr1 : ι
x : A
hx : x ∈ I
⊢ ↑(((decompose 𝒜) ↑⟨x, hx⟩) hr1) ∈ {r | ∃ i x, ↑(((decompose 𝒜) ↑x) i) = r}
tactic: rintro r ⟨hr1, ⟨x, hx⟩, rfl⟩
state_before: case a.intro.intro.mk
ι : Type u_1
σ : Type u_2
R : Type u_3
A : Type u_4
inst✝⁵ : Semiring A
inst✝⁴ : DecidableEq ι
inst✝³ : AddMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I✝ I J : Ideal A
I_le_J : I ≤ J
hr1 : ι
x : A
hx : x ∈ I
⊢ ↑(((decompose 𝒜) ↑⟨x, hx⟩) hr1) ∈ {r | ∃ i x, ↑(((decompose 𝒜) ↑x) i) = r}
state_after: no goals
tactic: exact ⟨hr1, ⟨⟨x, I_le_J hx⟩, rfl⟩⟩
Theorem: DFA.reindex_apply_start
File: Mathlib/Computability/DFA.lean

Proof steps:
state_before: α : Type u
σ : Type v
M✝ : DFA α σ
α' : Type u_1
σ' : Type u_2
g : σ ≃ σ'
M : DFA α σ
⊢ (fun M => { step := fun s a => g.symm (M.step (g s) a), start := g.symm M.start, accept := ⇑g ⁻¹' M.accept })
      ((fun M => { step := fun s a => g (M.step (g.symm s) a), start := g M.start, accept := ⇑g.symm ⁻¹' M.accept })
        M) =
    M
state_after: no goals
tactic: simp
state_before: α : Type u
σ : Type v
M✝ : DFA α σ
α' : Type u_1
σ' : Type u_2
g : σ ≃ σ'
M : DFA α σ'
⊢ (fun M => { step := fun s a => g (M.step (g.symm s) a), start := g M.start, accept := ⇑g.symm ⁻¹' M.accept })
      ((fun M => { step := fun s a => g.symm (M.step (g s) a), start := g.symm M.start, accept := ⇑g ⁻¹' M.accept })
        M) =
    M
state_after: no goals
tactic: simp
Theorem: CategoryTheory.Presheaf.isLeftKanExtension_along_yoneda_iff
File: Mathlib/CategoryTheory/Limits/Presheaf.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
ℰ : Type u₂
inst✝¹ : Category.{v₁, u₂} ℰ
A✝ A : C ⥤ ℰ
inst✝ : yoneda.HasPointwiseLeftKanExtension A
L : (Cᵒᵖ ⥤ Type v₁) ⥤ ℰ
α : A ⟶ yoneda ⋙ L
⊢ L.IsLeftKanExtension α ↔
    IsIso α ∧ Nonempty (PreservesColimitsOfSize.{v₁, max u₁ v₁, max u₁ v₁, v₁, max u₁ (v₁ + 1), u₂} L)
state_after: case mp
C : Type u₁
inst✝² : Category.{v₁, u₁} C
ℰ : Type u₂
inst✝¹ : Category.{v₁, u₂} ℰ
A✝ A : C ⥤ ℰ
inst✝ : yoneda.HasPointwiseLeftKanExtension A
L : (Cᵒᵖ ⥤ Type v₁) ⥤ ℰ
α : A ⟶ yoneda ⋙ L
⊢ L.IsLeftKanExtension α →
    IsIso α ∧ Nonempty (PreservesColimitsOfSize.{v₁, max u₁ v₁, max u₁ v₁, v₁, max u₁ (v₁ + 1), u₂} L)

case mpr
C : Type u₁
inst✝² : Category.{v₁, u₁} C
ℰ : Type u₂
inst✝¹ : Category.{v₁, u₂} ℰ
A✝ A : C ⥤ ℰ
inst✝ : yoneda.HasPointwiseLeftKanExtension A
L : (Cᵒᵖ ⥤ Type v₁) ⥤ ℰ
α : A ⟶ yoneda ⋙ L
⊢ IsIso α ∧ Nonempty (PreservesColimitsOfSize.{v₁, max u₁ v₁, max u₁ v₁, v₁, max u₁ (v₁ + 1), u₂} L) →
    L.IsLeftKanExtension α
tactic: constructor
Theorem: Option.map_map₂_distrib_left
File: Mathlib/Data/Option/NAry.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
f : α → β → γ
a : Option α
b : Option β
c : Option γ
α' : Type u_5
β' : Type u_6
δ' : Type u_7
ε : Type u_8
ε' : Type u_9
g : γ → δ
f' : α' → β → δ
g' : α → α'
h_distrib : ∀ (a : α) (b : β), g (f a b) = f' (g' a) b
⊢ Option.map g (map₂ f a b) = map₂ f' (Option.map g' a) b
state_after: no goals
tactic: cases a <;> cases b <;> simp [h_distrib]
Theorem: Subgroup.comap_normalizer_eq_of_injective_of_le_range
File: Mathlib/Algebra/Group/Subgroup/Basic.lean

Proof steps:
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁵ : Group G
inst✝⁴ : Group G'
inst✝³ : Group G''
A : Type u_4
inst✝² : AddGroup A
N✝ : Type u_5
inst✝¹ : Group N✝
f✝ : G →* N✝
N : Type u_6
inst✝ : Group N
H : Subgroup G
f : N →* G
hf : Injective ⇑f
h : H.normalizer ≤ f.range
⊢ comap f H.normalizer = (comap f H).normalizer
state_after: case a
G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁵ : Group G
inst✝⁴ : Group G'
inst✝³ : Group G''
A : Type u_4
inst✝² : AddGroup A
N✝ : Type u_5
inst✝¹ : Group N✝
f✝ : G →* N✝
N : Type u_6
inst✝ : Group N
H : Subgroup G
f : N →* G
hf : Injective ⇑f
h : H.normalizer ≤ f.range
⊢ map f (comap f H.normalizer) = map f (comap f H).normalizer
tactic: apply Subgroup.map_injective hf
state_before: case a
G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁵ : Group G
inst✝⁴ : Group G'
inst✝³ : Group G''
A : Type u_4
inst✝² : AddGroup A
N✝ : Type u_5
inst✝¹ : Group N✝
f✝ : G →* N✝
N : Type u_6
inst✝ : Group N
H : Subgroup G
f : N →* G
hf : Injective ⇑f
h : H.normalizer ≤ f.range
⊢ map f (comap f H.normalizer) = map f (comap f H).normalizer
state_after: case a
G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁵ : Group G
inst✝⁴ : Group G'
inst✝³ : Group G''
A : Type u_4
inst✝² : AddGroup A
N✝ : Type u_5
inst✝¹ : Group N✝
f✝ : G →* N✝
N : Type u_6
inst✝ : Group N
H : Subgroup G
f : N →* G
hf : Injective ⇑f
h : H.normalizer ≤ f.range
⊢ H.normalizer = map f (comap f H).normalizer
tactic: rw [map_comap_eq_self h]
state_before: case a
G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁵ : Group G
inst✝⁴ : Group G'
inst✝³ : Group G''
A : Type u_4
inst✝² : AddGroup A
N✝ : Type u_5
inst✝¹ : Group N✝
f✝ : G →* N✝
N : Type u_6
inst✝ : Group N
H : Subgroup G
f : N →* G
hf : Injective ⇑f
h : H.normalizer ≤ f.range
⊢ H.normalizer = map f (comap f H).normalizer
state_after: case a.a
G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁵ : Group G
inst✝⁴ : Group G'
inst✝³ : Group G''
A : Type u_4
inst✝² : AddGroup A
N✝ : Type u_5
inst✝¹ : Group N✝
f✝ : G →* N✝
N : Type u_6
inst✝ : Group N
H : Subgroup G
f : N →* G
hf : Injective ⇑f
h : H.normalizer ≤ f.range
⊢ H.normalizer ≤ map f (comap f H).normalizer

case a.a
G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁵ : Group G
inst✝⁴ : Group G'
inst✝³ : Group G''
A : Type u_4
inst✝² : AddGroup A
N✝ : Type u_5
inst✝¹ : Group N✝
f✝ : G →* N✝
N : Type u_6
inst✝ : Group N
H : Subgroup G
f : N →* G
hf : Injective ⇑f
h : H.normalizer ≤ f.range
⊢ map f (comap f H).normalizer ≤ H.normalizer
tactic: apply le_antisymm
Theorem: InnerProductSpaceable.nat
File: Mathlib/Analysis/InnerProductSpace/OfNorm.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝³ : RCLike 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : InnerProductSpaceable E
n : ℕ
x y : E
⊢ inner_ 𝕜 (↑n • x) y = ↑n * inner_ 𝕜 x y
state_after: case zero
𝕜 : Type u_1
inst✝³ : RCLike 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : InnerProductSpaceable E
x y : E
⊢ inner_ 𝕜 (↑0 • x) y = ↑0 * inner_ 𝕜 x y

case succ
𝕜 : Type u_1
inst✝³ : RCLike 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : InnerProductSpaceable E
x y : E
n : ℕ
ih : inner_ 𝕜 (↑n • x) y = ↑n * inner_ 𝕜 x y
⊢ inner_ 𝕜 (↑(n + 1) • x) y = ↑(n + 1) * inner_ 𝕜 x y
tactic: induction' n with n ih
Theorem: Finset.eq_zero_iff_eq_zero_of_mem_box
File: Mathlib/Order/Interval/Finset/Box.lean

Proof steps:
state_before: α : Type u_1
inst✝² : OrderedRing α
inst✝¹ : LocallyFiniteOrder α
inst✝ : DecidableEq α
n : ℕ
x : α
hx : x ∈ box n
hn : n = 0
⊢ x = 0
state_after: no goals
tactic: rwa [hn, box_zero, mem_singleton] at hx
Theorem: Sum.exists_sum
File: Mathlib/Data/Sum/Basic.lean

Proof steps:
state_before: α : Type u
α' : Type w
β : Type v
β' : Type x
γ✝ : Type u_1
δ : Type u_2
γ : α ⊕ β → Sort u_3
p : ((ab : α ⊕ β) → γ ab) → Prop
⊢ (∃ fab, p fab) ↔ ∃ fa fb, p fun t => rec fa fb t
state_after: α : Type u
α' : Type w
β : Type v
β' : Type x
γ✝ : Type u_1
δ : Type u_2
γ : α ⊕ β → Sort u_3
p : ((ab : α ⊕ β) → γ ab) → Prop
⊢ (¬∀ (fa : (val : α) → γ (inl val)) (fb : (val : β) → γ (inr val)), ¬p fun t => rec fa fb t) ↔
    ∃ fa fb, p fun t => rec fa fb t
tactic: rw [← not_forall_not, forall_sum]
state_before: α : Type u
α' : Type w
β : Type v
β' : Type x
γ✝ : Type u_1
δ : Type u_2
γ : α ⊕ β → Sort u_3
p : ((ab : α ⊕ β) → γ ab) → Prop
⊢ (¬∀ (fa : (val : α) → γ (inl val)) (fb : (val : β) → γ (inr val)), ¬p fun t => rec fa fb t) ↔
    ∃ fa fb, p fun t => rec fa fb t
state_after: no goals
tactic: simp
Theorem: isClosed_sum_iff
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
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace W
s : Set (X ⊕ Y)
⊢ IsClosed s ↔ IsClosed (inl ⁻¹' s) ∧ IsClosed (inr ⁻¹' s)
state_after: no goals
tactic: simp only [← isOpen_compl_iff, isOpen_sum_iff, preimage_compl]
Theorem: Subsemiring.top_prod
File: Mathlib/Algebra/Ring/Subsemiring/Basic.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
inst✝² : NonAssocSemiring R
M : Submonoid R
inst✝¹ : NonAssocSemiring S
inst✝ : NonAssocSemiring T
s : Subsemiring S
x : R × S
⊢ x ∈ ⊤.prod s ↔ x ∈ comap (RingHom.snd R S) s
state_after: no goals
tactic: simp [mem_prod, MonoidHom.coe_snd]
Theorem: Multiset.nodup_iff_count_eq_one
File: Mathlib/Data/Multiset/Nodup.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s t : Multiset α
a : α
inst✝ : DecidableEq α
_l : List α
⊢ Nodup (Quot.mk Setoid.r _l) ↔ ∀ a ∈ Quot.mk Setoid.r _l, count a (Quot.mk Setoid.r _l) = 1
state_after: no goals
tactic: simpa using List.nodup_iff_count_eq_one