ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: _private.Mathlib.NumberTheory.FLT.Three.0.cube_of_castHom_ne_zero
File: Mathlib/NumberTheory/FLT/Three.lean

Proof steps:
state_before: n : ZMod 9
⊢ 3 ∣ 9
state_after: no goals
tactic: norm_num
state_before: n : ZMod 9
⊢ (castHom ⋯ (ZMod 3)) n ≠ 0 → n ^ 3 = 1 ∨ n ^ 3 = 8
state_after: ⊢ ∀ {n : ZMod 9}, (castHom ⋯ (ZMod 3)) n ≠ 0 → n ^ 3 = 1 ∨ n ^ 3 = 8
tactic: revert n
state_before: ⊢ ∀ {n : ZMod 9}, (castHom ⋯ (ZMod 3)) n ≠ 0 → n ^ 3 = 1 ∨ n ^ 3 = 8
state_after: no goals
tactic: decide
Theorem: Matrix.SpecialLinearGroup.center_eq_bot_of_subsingleton
File: Mathlib/LinearAlgebra/Matrix/SpecialLinearGroup.lean

Proof steps:
state_before: n : Type u
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
R : Type v
inst✝² : CommRing R
S : Type u_1
inst✝¹ : CommRing S
inst✝ : Subsingleton n
x : SpecialLinearGroup n R
x✝ : x ∈ center (SpecialLinearGroup n R)
⊢ x ∈ ⊥
state_after: no goals
tactic: rw [mem_bot, Subsingleton.elim x 1]
Theorem: Mathlib.Tactic.Qify.intCast_ne
File: Mathlib/Tactic/Qify.lean

Proof steps:
state_before: a b : ℤ
⊢ a ≠ b ↔ ↑a ≠ ↑b
state_after: no goals
tactic: simp only [ne_eq, Int.cast_inj]
Theorem: ENNReal.iInf_sum
File: Mathlib/Data/ENNReal/Real.lean

Proof steps:
state_before: ι : Sort u_1
f✝ g : ι → ℝ≥0∞
a b c d : ℝ≥0∞
r p q : ℝ≥0
α : Type u_2
f : ι → α → ℝ≥0∞
s : Finset α
inst✝ : Nonempty ι
h : ∀ (t : Finset α) (i j : ι), ∃ k, ∀ a ∈ t, f k a ≤ f i a ∧ f k a ≤ f j a
⊢ ⨅ i, ∑ a ∈ s, f i a = ∑ a ∈ s, ⨅ i, f i a
state_after: case h₁
ι : Sort u_1
f✝ g : ι → ℝ≥0∞
a b c d : ℝ≥0∞
r p q : ℝ≥0
α : Type u_2
f : ι → α → ℝ≥0∞
inst✝ : Nonempty ι
h : ∀ (t : Finset α) (i j : ι), ∃ k, ∀ a ∈ t, f k a ≤ f i a ∧ f k a ≤ f j a
⊢ ⨅ i, ∑ a ∈ ∅, f i a = ∑ a ∈ ∅, ⨅ i, f i a

case h₂
ι : Sort u_1
f✝ g : ι → ℝ≥0∞
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
α : Type u_2
f : ι → α → ℝ≥0∞
inst✝ : Nonempty ι
h : ∀ (t : Finset α) (i j : ι), ∃ k, ∀ a ∈ t, f k a ≤ f i a ∧ f k a ≤ f j a
a : α
s : Finset α
ha : a ∉ s
ih : ⨅ i, ∑ a ∈ s, f i a = ∑ a ∈ s, ⨅ i, f i a
⊢ ⨅ i, ∑ a ∈ Finset.cons a s ha, f i a = ∑ a ∈ Finset.cons a s ha, ⨅ i, f i a
tactic: induction' s using Finset.cons_induction_on with a s ha ih
Theorem: Finsupp.supported_comap_lmapDomain
File: Mathlib/LinearAlgebra/Finsupp.lean

Proof steps:
state_before: α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
R : Type u_5
S : Type u_6
inst✝⁷ : Semiring R
inst✝⁶ : Semiring S
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : AddCommMonoid N
inst✝² : Module R N
inst✝¹ : AddCommMonoid P
inst✝ : Module R P
α' : Type u_7
α'' : Type u_8
f : α → α'
s : Set α'
⊢ supported M R (f ⁻¹' s) ≤ comap (lmapDomain M R f) (supported M R s)
state_after: no goals
tactic: classical
  intro l (hl : (l.support : Set α) ⊆ f ⁻¹' s)
  show ↑(mapDomain f l).support ⊆ s
  rw [← Set.image_subset_iff, ← Finset.coe_image] at hl
  exact Set.Subset.trans mapDomain_support hl
Theorem: MeasureTheory.integrable_add_iff_of_nonpos
File: Mathlib/MeasureTheory/Function/L1Space.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f g : α → ℝ
h_meas : AEStronglyMeasurable f μ
hf : f ≤ᶠ[ae μ] 0
hg : g ≤ᶠ[ae μ] 0
⊢ Integrable (f + g) μ ↔ Integrable f μ ∧ Integrable g μ
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f g : α → ℝ
h_meas : AEStronglyMeasurable f μ
hf : f ≤ᶠ[ae μ] 0
hg : g ≤ᶠ[ae μ] 0
⊢ Integrable (-f + -g) μ ↔ Integrable (-f) μ ∧ Integrable (-g) μ
tactic: rw [← integrable_neg_iff, ← integrable_neg_iff (f := f), ← integrable_neg_iff (f := g), neg_add]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f g : α → ℝ
h_meas : AEStronglyMeasurable f μ
hf : f ≤ᶠ[ae μ] 0
hg : g ≤ᶠ[ae μ] 0
⊢ Integrable (-f + -g) μ ↔ Integrable (-f) μ ∧ Integrable (-g) μ
state_after: no goals
tactic: exact integrable_add_iff_of_nonneg h_meas.neg (hf.mono (fun _ ↦ neg_nonneg_of_nonpos))
    (hg.mono (fun _ ↦ neg_nonneg_of_nonpos))
Theorem: Linarith.le_of_eq_of_le
File: Mathlib/Tactic/Linarith/Lemmas.lean

Proof steps:
state_before: α : Type u_1
inst✝ : OrderedSemiring α
a b : α
ha : a = 0
hb : b ≤ 0
⊢ a + b ≤ 0
state_after: no goals
tactic: simp [*]
Theorem: FirstOrder.Language.Structure.CG.map_of_surjective
File: Mathlib/ModelTheory/FinitelyGenerated.lean

Proof steps:
state_before: L : Language
M : Type u_1
inst✝¹ : L.Structure M
N : Type u_2
inst✝ : L.Structure N
h : CG L M
f : M →[L] N
hs : Function.Surjective ⇑f
⊢ CG L N
state_after: L : Language
M : Type u_1
inst✝¹ : L.Structure M
N : Type u_2
inst✝ : L.Structure N
h : CG L M
f : M →[L] N
hs : f.range = ⊤
⊢ CG L N
tactic: rw [← Hom.range_eq_top] at hs
state_before: L : Language
M : Type u_1
inst✝¹ : L.Structure M
N : Type u_2
inst✝ : L.Structure N
h : CG L M
f : M →[L] N
hs : f.range = ⊤
⊢ CG L N
state_after: L : Language
M : Type u_1
inst✝¹ : L.Structure M
N : Type u_2
inst✝ : L.Structure N
h : CG L M
f : M →[L] N
hs : f.range = ⊤
⊢ f.range.CG
tactic: rw [cg_def, ← hs]
state_before: L : Language
M : Type u_1
inst✝¹ : L.Structure M
N : Type u_2
inst✝ : L.Structure N
h : CG L M
f : M →[L] N
hs : f.range = ⊤
⊢ f.range.CG
state_after: no goals
tactic: exact h.range f
Theorem: Multiset.le_prod_of_submultiplicative
File: Mathlib/Algebra/Order/BigOperators/Group/Multiset.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : CommMonoid α
inst✝ : OrderedCommMonoid β
f : α → β
h_one : f 1 = 1
h_mul : ∀ (a b : α), f (a * b) ≤ f a * f b
s : Multiset α
⊢ ∀ (a b : α), (fun x => True) a → (fun x => True) b → (fun x => True) (a * b)
state_after: no goals
tactic: simp
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : CommMonoid α
inst✝ : OrderedCommMonoid β
f : α → β
h_one : f 1 = 1
h_mul : ∀ (a b : α), f (a * b) ≤ f a * f b
s : Multiset α
⊢ ∀ a ∈ s, (fun x => True) a
state_after: no goals
tactic: simp
Theorem: PiTensorProduct.mapL_apply
File: Mathlib/Analysis/NormedSpace/PiTensorProduct/InjectiveSeminorm.lean

Proof steps:
state_before: ι : Type uι
inst✝⁹ : Fintype ι
𝕜 : Type u𝕜
inst✝⁸ : NontriviallyNormedField 𝕜
E : ι → Type uE
inst✝⁷ : (i : ι) → SeminormedAddCommGroup (E i)
inst✝⁶ : (i : ι) → NormedSpace 𝕜 (E i)
F : Type uF
inst✝⁵ : SeminormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
E' : ι → Type u_1
E'' : ι → Type u_2
inst✝³ : (i : ι) → SeminormedAddCommGroup (E' i)
inst✝² : (i : ι) → NormedSpace 𝕜 (E' i)
inst✝¹ : (i : ι) → SeminormedAddCommGroup (E'' i)
inst✝ : (i : ι) → NormedSpace 𝕜 (E'' i)
g : (i : ι) → E' i →L[𝕜] E'' i
f : (i : ι) → E i →L[𝕜] E' i
x : ⨂[𝕜] (i : ι), E i
⊢ (mapL f) x = (map fun i => ↑(f i)) x
state_after: case smul_tprod
ι : Type uι
inst✝⁹ : Fintype ι
𝕜 : Type u𝕜
inst✝⁸ : NontriviallyNormedField 𝕜
E : ι → Type uE
inst✝⁷ : (i : ι) → SeminormedAddCommGroup (E i)
inst✝⁶ : (i : ι) → NormedSpace 𝕜 (E i)
F : Type uF
inst✝⁵ : SeminormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
E' : ι → Type u_1
E'' : ι → Type u_2
inst✝³ : (i : ι) → SeminormedAddCommGroup (E' i)
inst✝² : (i : ι) → NormedSpace 𝕜 (E' i)
inst✝¹ : (i : ι) → SeminormedAddCommGroup (E'' i)
inst✝ : (i : ι) → NormedSpace 𝕜 (E'' i)
g : (i : ι) → E' i →L[𝕜] E'' i
f : (i : ι) → E i →L[𝕜] E' i
r✝ : 𝕜
f✝ : (i : ι) → E i
⊢ (mapL f) (r✝ • (tprod 𝕜) f✝) = (map fun i => ↑(f i)) (r✝ • (tprod 𝕜) f✝)

case add
ι : Type uι
inst✝⁹ : Fintype ι
𝕜 : Type u𝕜
inst✝⁸ : NontriviallyNormedField 𝕜
E : ι → Type uE
inst✝⁷ : (i : ι) → SeminormedAddCommGroup (E i)
inst✝⁶ : (i : ι) → NormedSpace 𝕜 (E i)
F : Type uF
inst✝⁵ : SeminormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
E' : ι → Type u_1
E'' : ι → Type u_2
inst✝³ : (i : ι) → SeminormedAddCommGroup (E' i)
inst✝² : (i : ι) → NormedSpace 𝕜 (E' i)
inst✝¹ : (i : ι) → SeminormedAddCommGroup (E'' i)
inst✝ : (i : ι) → NormedSpace 𝕜 (E'' i)
g : (i : ι) → E' i →L[𝕜] E'' i
f : (i : ι) → E i →L[𝕜] E' i
x✝ y✝ : ⨂[𝕜] (i : ι), E i
hx : (mapL f) x✝ = (map fun i => ↑(f i)) x✝
hy : (mapL f) y✝ = (map fun i => ↑(f i)) y✝
⊢ (mapL f) (x✝ + y✝) = (map fun i => ↑(f i)) (x✝ + y✝)
tactic: induction' x using PiTensorProduct.induction_on with _ _ _ _ hx hy
Theorem: MeasurableEmbedding.comap_restrict
File: Mathlib/MeasureTheory/Measure/Restrict.lean

Proof steps:
state_before: R : Type u_1
α : Type u_2
β : Type u_3
δ : Type u_4
γ : Type u_5
ι : Type u_6
m0 : MeasurableSpace α
m1 : MeasurableSpace β
f : α → β
hf : MeasurableEmbedding f
μ : Measure β
s : Set β
⊢ Measure.comap f (μ.restrict s) = (Measure.comap f μ).restrict (f ⁻¹' s)
state_after: case h
R : Type u_1
α : Type u_2
β : Type u_3
δ : Type u_4
γ : Type u_5
ι : Type u_6
m0 : MeasurableSpace α
m1 : MeasurableSpace β
f : α → β
hf : MeasurableEmbedding f
μ : Measure β
s : Set β
t : Set α
ht : MeasurableSet t
⊢ (Measure.comap f (μ.restrict s)) t = ((Measure.comap f μ).restrict (f ⁻¹' s)) t
tactic: ext t ht
state_before: case h
R : Type u_1
α : Type u_2
β : Type u_3
δ : Type u_4
γ : Type u_5
ι : Type u_6
m0 : MeasurableSpace α
m1 : MeasurableSpace β
f : α → β
hf : MeasurableEmbedding f
μ : Measure β
s : Set β
t : Set α
ht : MeasurableSet t
⊢ (Measure.comap f (μ.restrict s)) t = ((Measure.comap f μ).restrict (f ⁻¹' s)) t
state_after: no goals
tactic: rw [Measure.restrict_apply ht, comap_apply hf, comap_apply hf,
    Measure.restrict_apply (hf.measurableSet_image.2 ht), image_inter_preimage]
Theorem: le_div_self
File: Mathlib/Algebra/Order/Field/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
ha : 0 ≤ a
hb₀ : 0 < b
hb₁ : b ≤ 1
⊢ a ≤ a / b
state_after: no goals
tactic: simpa only [div_one] using div_le_div_of_nonneg_left ha hb₀ hb₁
Theorem: HomologicalComplex.quasiIso_map_iff_of_preservesHomology
File: Mathlib/Algebra/Homology/QuasiIso.lean

Proof steps:
state_before: ι : Type u_1
C : Type u
inst✝¹² : Category.{v, u} C
inst✝¹¹ : HasZeroMorphisms C
c : ComplexShape ι
K✝ L✝ M K' L' : HomologicalComplex C c
C₁ : Type u_2
C₂ : Type u_3
inst✝¹⁰ : Category.{u_4, u_2} C₁
inst✝⁹ : Category.{u_5, u_3} C₂
inst✝⁸ : Preadditive C₁
inst✝⁷ : Preadditive C₂
K L : HomologicalComplex C₁ c
φ : K ⟶ L
F : C₁ ⥤ C₂
inst✝⁶ : F.Additive
inst✝⁵ : F.PreservesHomology
inst✝⁴ : ∀ (i : ι), K.HasHomology i
inst✝³ : ∀ (i : ι), L.HasHomology i
inst✝² : ∀ (i : ι), ((F.mapHomologicalComplex c).obj K).HasHomology i
inst✝¹ : ∀ (i : ι), ((F.mapHomologicalComplex c).obj L).HasHomology i
inst✝ : F.ReflectsIsomorphisms
⊢ QuasiIso ((F.mapHomologicalComplex c).map φ) ↔ QuasiIso φ
state_after: no goals
tactic: simp only [quasiIso_iff, quasiIsoAt_map_iff_of_preservesHomology φ F]
Theorem: Nat.not_prime_mul
File: Mathlib/Data/Nat/Prime/Defs.lean

Proof steps:
state_before: n a b : ℕ
a1 : a ≠ 1
b1 : b ≠ 1
⊢ ¬Prime (a * b)
state_after: no goals
tactic: simp [prime_mul_iff, _root_.not_or, *]
Theorem: CategoryTheory.Localization.comp_liftNatTrans
File: Mathlib/CategoryTheory/Localization/Predicate.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝³ : Category.{u_4, u_1} C
inst✝² : Category.{u_6, u_2} D
L : C ⥤ D
W : MorphismProperty C
E : Type u_3
inst✝¹ : Category.{u_5, u_3} E
inst✝ : L.IsLocalization W
F₁ F₂ F₃ : C ⥤ E
F₁' F₂' F₃' : D ⥤ E
h₁ : Lifting L W F₁ F₁'
h₂ : Lifting L W F₂ F₂'
h₃ : Lifting L W F₃ F₃'
τ : F₁ ⟶ F₂
τ' : F₂ ⟶ F₃
X : C
⊢ (liftNatTrans L W F₁ F₂ F₁' F₂' τ ≫ liftNatTrans L W F₂ F₃ F₂' F₃' τ').app (L.obj X) =
    (liftNatTrans L W F₁ F₃ F₁' F₃' (τ ≫ τ')).app (L.obj X)
state_after: no goals
tactic: simp only [NatTrans.comp_app, liftNatTrans_app, assoc, Iso.inv_hom_id_app_assoc]
Theorem: Fintype.piFinset_empty
File: Mathlib/Data/Fintype/Pi.lean

Proof steps:
state_before: α : Type u_1
inst✝² : DecidableEq α
inst✝¹ : Fintype α
γ : α → Type u_2
δ : α → Type u_3
s : (a : α) → Finset (γ a)
inst✝ : Nonempty α
x✝ : (a : α) → δ a
⊢ x✝ ∉ piFinset fun x => ∅
state_after: no goals
tactic: simp
Theorem: MvPolynomial.map_esymm
File: Mathlib/RingTheory/MvPolynomial/Symmetric.lean

Proof steps:
state_before: σ : Type u_1
R : Type u_2
τ : Type u_3
S : Type u_4
inst✝³ : CommSemiring R
inst✝² : CommSemiring S
inst✝¹ : Fintype σ
inst✝ : Fintype τ
n : ℕ
f : R →+* S
⊢ (map f) (esymm σ R n) = esymm σ S n
state_after: no goals
tactic: simp_rw [esymm, map_sum, map_prod, map_X]
Theorem: FormalMultilinearSeries.summable_norm_mul_pow
File: Mathlib/Analysis/Analytic/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
p✝ : FormalMultilinearSeries 𝕜 E F
r✝ : ℝ≥0
p : FormalMultilinearSeries 𝕜 E F
r : ℝ≥0
h : ↑r < p.radius
⊢ Summable fun n => ‖p n‖ * ↑r ^ n
state_after: case intro.intro.intro.intro
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
p✝ : FormalMultilinearSeries 𝕜 E F
r✝ : ℝ≥0
p : FormalMultilinearSeries 𝕜 E F
r : ℝ≥0
h : ↑r < p.radius
a : ℝ
ha : a ∈ Ioo 0 1
C : ℝ
hp : ∀ (n : ℕ), ‖p n‖ * ↑r ^ n ≤ C * a ^ n
⊢ Summable fun n => ‖p n‖ * ↑r ^ n
tactic: obtain ⟨a, ha : a ∈ Ioo (0 : ℝ) 1, C, - : 0 < C, hp⟩ := p.norm_mul_pow_le_mul_pow_of_lt_radius h
state_before: case intro.intro.intro.intro
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
p✝ : FormalMultilinearSeries 𝕜 E F
r✝ : ℝ≥0
p : FormalMultilinearSeries 𝕜 E F
r : ℝ≥0
h : ↑r < p.radius
a : ℝ
ha : a ∈ Ioo 0 1
C : ℝ
hp : ∀ (n : ℕ), ‖p n‖ * ↑r ^ n ≤ C * a ^ n
⊢ Summable fun n => ‖p n‖ * ↑r ^ n
state_after: no goals
tactic: exact .of_nonneg_of_le (fun n => mul_nonneg (norm_nonneg _) (pow_nonneg r.coe_nonneg _))
    hp ((summable_geometric_of_lt_one ha.1.le ha.2).mul_left _)
Theorem: CategoryTheory.Limits.factorThruKernelSubobject_comp_kernelSubobjectIso
File: Mathlib/CategoryTheory/Subobject/Limits.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
X Y Z : C
inst✝¹ : HasZeroMorphisms C
f : X ⟶ Y
inst✝ : HasKernel f
W : C
h : W ⟶ X
w : h ≫ f = 0
⊢ (factorThruKernelSubobject f h w ≫ (kernelSubobjectIso f).hom) ≫ kernel.ι f = kernel.lift f h w ≫ kernel.ι f
state_after: no goals
tactic: simp
Theorem: List.pairwise_of_forall_mem_list
File: Mathlib/Data/List/Pairwise.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
R S T : α → α → Prop
a : α
l✝ l : List α
r : α → α → Prop
h : ∀ (a : α), a ∈ l → ∀ (b : α), b ∈ l → r a b
⊢ Pairwise r l
state_after: α : Type u_1
β : Type u_2
R S T : α → α → Prop
a : α
l✝ l : List α
r : α → α → Prop
h : ∀ (a : α), a ∈ l → ∀ (b : α), b ∈ l → r a b
⊢ ∀ {a b : α}, [a, b] <+ l → r a b
tactic: rw [pairwise_iff_forall_sublist]
state_before: α : Type u_1
β : Type u_2
R S T : α → α → Prop
a : α
l✝ l : List α
r : α → α → Prop
h : ∀ (a : α), a ∈ l → ∀ (b : α), b ∈ l → r a b
⊢ ∀ {a b : α}, [a, b] <+ l → r a b
state_after: α : Type u_1
β : Type u_2
R S T : α → α → Prop
a✝ : α
l✝ l : List α
r : α → α → Prop
h : ∀ (a : α), a ∈ l → ∀ (b : α), b ∈ l → r a b
a b : α
hab : [a, b] <+ l
⊢ r a b
tactic: intro a b hab
state_before: α : Type u_1
β : Type u_2
R S T : α → α → Prop
a✝ : α
l✝ l : List α
r : α → α → Prop
h : ∀ (a : α), a ∈ l → ∀ (b : α), b ∈ l → r a b
a b : α
hab : [a, b] <+ l
⊢ r a b
state_after: no goals
tactic: apply h <;> (apply hab.subset; simp)
Theorem: List.mapIdxMGo_eq_mapIdxMAuxSpec
File: Mathlib/Data/List/Indexes.lean

Proof steps:
state_before: α : Type u
β✝ : Type v
m : Type u → Type v
inst✝¹ : Monad m
inst✝ : LawfulMonad m
β : Type u
f : ℕ → α → m β
arr : Array β
as : List α
⊢ mapIdxM.go f as arr = (fun x => arr.toList ++ x) <$> mapIdxMAuxSpec f arr.size as
state_after: α : Type u
β✝ : Type v
m : Type u → Type v
inst✝¹ : Monad m
inst✝ : LawfulMonad m
β : Type u
f : ℕ → α → m β
arr : Array β
as : List α
len : ℕ
e : as.length = len
⊢ mapIdxM.go f as arr = (fun x => arr.toList ++ x) <$> mapIdxMAuxSpec f arr.size as
tactic: generalize e : as.length = len
state_before: α : Type u
β✝ : Type v
m : Type u → Type v
inst✝¹ : Monad m
inst✝ : LawfulMonad m
β : Type u
f : ℕ → α → m β
arr : Array β
as : List α
len : ℕ
e : as.length = len
⊢ mapIdxM.go f as arr = (fun x => arr.toList ++ x) <$> mapIdxMAuxSpec f arr.size as
state_after: α : Type u
β✝ : Type v
m : Type u → Type v
inst✝¹ : Monad m
inst✝ : LawfulMonad m
β : Type u
f : ℕ → α → m β
len : ℕ
⊢ ∀ (arr : Array β) (as : List α),
    as.length = len → mapIdxM.go f as arr = (fun x => arr.toList ++ x) <$> mapIdxMAuxSpec f arr.size as
tactic: revert as arr
state_before: α : Type u
β✝ : Type v
m : Type u → Type v
inst✝¹ : Monad m
inst✝ : LawfulMonad m
β : Type u
f : ℕ → α → m β
len : ℕ
⊢ ∀ (arr : Array β) (as : List α),
    as.length = len → mapIdxM.go f as arr = (fun x => arr.toList ++ x) <$> mapIdxMAuxSpec f arr.size as
state_after: case zero
α : Type u
β✝ : Type v
m : Type u → Type v
inst✝¹ : Monad m
inst✝ : LawfulMonad m
β : Type u
f : ℕ → α → m β
arr : Array β
as : List α
h : as.length = 0
⊢ mapIdxM.go f as arr = (fun x => arr.toList ++ x) <$> mapIdxMAuxSpec f arr.size as

case succ
α : Type u
β✝ : Type v
m : Type u → Type v
inst✝¹ : Monad m
inst✝ : LawfulMonad m
β : Type u
f : ℕ → α → m β
len : ℕ
ih :
  ∀ (arr : Array β) (as : List α),
    as.length = len → mapIdxM.go f as arr = (fun x => arr.toList ++ x) <$> mapIdxMAuxSpec f arr.size as
arr : Array β
as : List α
h : as.length = len + 1
⊢ mapIdxM.go f as arr = (fun x => arr.toList ++ x) <$> mapIdxMAuxSpec f arr.size as
tactic: induction' len with len ih <;> intro arr as h
Theorem: Monotone.eq_of_le_of_le
File: Mathlib/Order/Monotone/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type u_2
π : ι → Type u_3
r : α → α → Prop
inst✝¹ : LinearOrder α
inst✝ : PartialOrder β
f : α → β
a₁ a₂ : α
h_mon : Monotone f
h_fa : f a₁ = f a₂
i : α
h₁ : a₁ ≤ i
h₂ : i ≤ a₂
⊢ f i = f a₁
state_after: case a
ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type u_2
π : ι → Type u_3
r : α → α → Prop
inst✝¹ : LinearOrder α
inst✝ : PartialOrder β
f : α → β
a₁ a₂ : α
h_mon : Monotone f
h_fa : f a₁ = f a₂
i : α
h₁ : a₁ ≤ i
h₂ : i ≤ a₂
⊢ f i ≤ f a₁

case a
ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type u_2
π : ι → Type u_3
r : α → α → Prop
inst✝¹ : LinearOrder α
inst✝ : PartialOrder β
f : α → β
a₁ a₂ : α
h_mon : Monotone f
h_fa : f a₁ = f a₂
i : α
h₁ : a₁ ≤ i
h₂ : i ≤ a₂
⊢ f a₁ ≤ f i
tactic: apply le_antisymm
Theorem: add_mem_closedBall_add_iff
File: Mathlib/Analysis/Normed/Group/Basic.lean

Proof steps:
state_before: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
c : E
⊢ a * c ∈ closedBall (b * c) r ↔ a ∈ closedBall b r
state_after: no goals
tactic: simp only [mem_closedBall, dist_eq_norm_div, mul_div_mul_right_eq_div]
Theorem: Polynomial.aroots_C
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
inst✝² : CommRing S
inst✝¹ : IsDomain S
inst✝ : Algebra T S
a : T
⊢ (C a).aroots S = 0
state_after: no goals
tactic: rw [aroots_def, map_C, roots_C]
Theorem: Cardinal.mk_list_le_max
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

Proof steps:
state_before: α : Type u
⊢ #(List α) ≤ max ℵ₀ #α
state_after: case inl
α : Type u
h✝ : Finite α
⊢ #(List α) ≤ max ℵ₀ #α

case inr
α : Type u
h✝ : Infinite α
⊢ #(List α) ≤ max ℵ₀ #α
tactic: cases finite_or_infinite α
Theorem: List.get_tails
File: Mathlib/Data/List/Infix.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
l✝ l₁ l₂ l₃ : List α
a b : α
m n✝ : ℕ
l : List α
n : Fin l.tails.length
⊢ l.tails.get n = drop (↑n) l
state_after: no goals
tactic: simp
Theorem: CategoryTheory.isPreconnected_induction
File: Mathlib/CategoryTheory/IsConnected.lean

Proof steps:
state_before: J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
inst✝ : IsPreconnected J
Z : J → Sort u_1
h₁ : {j₁ j₂ : J} → (j₁ ⟶ j₂) → Z j₁ → Z j₂
h₂ : {j₁ j₂ : J} → (j₁ ⟶ j₂) → Z j₂ → Z j₁
j₀ : J
x : Z j₀
j j₁✝ j₂✝ : J
f : j₁✝ ⟶ j₂✝
⊢ j₁✝ ∈ {j | Nonempty (Z j)} → j₂✝ ∈ {j | Nonempty (Z j)}
state_after: case intro
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
inst✝ : IsPreconnected J
Z : J → Sort u_1
h₁ : {j₁ j₂ : J} → (j₁ ⟶ j₂) → Z j₁ → Z j₂
h₂ : {j₁ j₂ : J} → (j₁ ⟶ j₂) → Z j₂ → Z j₁
j₀ : J
x : Z j₀
j j₁✝ j₂✝ : J
f : j₁✝ ⟶ j₂✝
y : Z j₁✝
⊢ j₂✝ ∈ {j | Nonempty (Z j)}
tactic: rintro ⟨y⟩
state_before: case intro
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
inst✝ : IsPreconnected J
Z : J → Sort u_1
h₁ : {j₁ j₂ : J} → (j₁ ⟶ j₂) → Z j₁ → Z j₂
h₂ : {j₁ j₂ : J} → (j₁ ⟶ j₂) → Z j₂ → Z j₁
j₀ : J
x : Z j₀
j j₁✝ j₂✝ : J
f : j₁✝ ⟶ j₂✝
y : Z j₁✝
⊢ j₂✝ ∈ {j | Nonempty (Z j)}
state_after: no goals
tactic: exact ⟨h₁ f y⟩
state_before: J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
inst✝ : IsPreconnected J
Z : J → Sort u_1
h₁ : {j₁ j₂ : J} → (j₁ ⟶ j₂) → Z j₁ → Z j₂
h₂ : {j₁ j₂ : J} → (j₁ ⟶ j₂) → Z j₂ → Z j₁
j₀ : J
x : Z j₀
j j₁✝ j₂✝ : J
f : j₁✝ ⟶ j₂✝
⊢ j₂✝ ∈ {j | Nonempty (Z j)} → j₁✝ ∈ {j | Nonempty (Z j)}
state_after: case intro
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
inst✝ : IsPreconnected J
Z : J → Sort u_1
h₁ : {j₁ j₂ : J} → (j₁ ⟶ j₂) → Z j₁ → Z j₂
h₂ : {j₁ j₂ : J} → (j₁ ⟶ j₂) → Z j₂ → Z j₁
j₀ : J
x : Z j₀
j j₁✝ j₂✝ : J
f : j₁✝ ⟶ j₂✝
y : Z j₂✝
⊢ j₁✝ ∈ {j | Nonempty (Z j)}
tactic: rintro ⟨y⟩
state_before: case intro
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
inst✝ : IsPreconnected J
Z : J → Sort u_1
h₁ : {j₁ j₂ : J} → (j₁ ⟶ j₂) → Z j₁ → Z j₂
h₂ : {j₁ j₂ : J} → (j₁ ⟶ j₂) → Z j₂ → Z j₁
j₀ : J
x : Z j₀
j j₁✝ j₂✝ : J
f : j₁✝ ⟶ j₂✝
y : Z j₂✝
⊢ j₁✝ ∈ {j | Nonempty (Z j)}
state_after: no goals
tactic: exact ⟨h₂ f y⟩
Theorem: SemidirectProduct.rightHom_comp_inr
File: Mathlib/GroupTheory/SemidirectProduct.lean

Proof steps:
state_before: N : Type u_1
G : Type u_2
H : Type u_3
inst✝² : Group N
inst✝¹ : Group G
inst✝ : Group H
φ : G →* MulAut N
⊢ rightHom.comp inr = MonoidHom.id G
state_after: case h
N : Type u_1
G : Type u_2
H : Type u_3
inst✝² : Group N
inst✝¹ : Group G
inst✝ : Group H
φ : G →* MulAut N
x✝ : G
⊢ (rightHom.comp inr) x✝ = (MonoidHom.id G) x✝
tactic: ext
state_before: case h
N : Type u_1
G : Type u_2
H : Type u_3
inst✝² : Group N
inst✝¹ : Group G
inst✝ : Group H
φ : G →* MulAut N
x✝ : G
⊢ (rightHom.comp inr) x✝ = (MonoidHom.id G) x✝
state_after: no goals
tactic: simp [rightHom]
Theorem: Fin.partialSum_succ'
File: Mathlib/Algebra/BigOperators/Fin.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : Monoid α
n : ℕ
f : Fin (n + 1) → α
j : Fin (n + 1)
⊢ partialProd f j.succ = f 0 * partialProd (tail f) j
state_after: α : Type u_1
β : Type u_2
inst✝ : Monoid α
n : ℕ
f : Fin (n + 1) → α
j : Fin (n + 1)
⊢ f 0 * (List.take (↑j) (List.ofFn fun i => f i.succ)).prod = f 0 * (List.take (↑j) (List.ofFn (tail f))).prod
tactic: simp [partialProd]
state_before: α : Type u_1
β : Type u_2
inst✝ : Monoid α
n : ℕ
f : Fin (n + 1) → α
j : Fin (n + 1)
⊢ f 0 * (List.take (↑j) (List.ofFn fun i => f i.succ)).prod = f 0 * (List.take (↑j) (List.ofFn (tail f))).prod
state_after: no goals
tactic: rfl