ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: matPolyEquiv_symm_X
File: Mathlib/RingTheory/PolynomialAlgebra.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
⊢ matPolyEquiv.symm X = diagonal fun x => X
state_after: R : Type u_1
A : Type u_2
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
⊢ (Matrix.map 1 fun x => X * (algebraMap R R[X]) x) = diagonal fun x => X
tactic: suffices (Matrix.map 1 fun x ↦ X * algebraMap R R[X] x) = diagonal fun _ : n => (X : R[X]) by
    simpa [matPolyEquiv]
state_before: R : Type u_1
A : Type u_2
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
⊢ (Matrix.map 1 fun x => X * (algebraMap R R[X]) x) = diagonal fun x => X
state_after: R : Type u_1
A : Type u_2
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
⊢ ((diagonal fun x => 1).map fun x => X * (algebraMap R R[X]) x) = diagonal fun x => X
tactic: rw [← Matrix.diagonal_one]
state_before: R : Type u_1
A : Type u_2
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
⊢ ((diagonal fun x => 1).map fun x => X * (algebraMap R R[X]) x) = diagonal fun x => X
state_after: no goals
tactic: simp [-Matrix.diagonal_one]
Theorem: List.erase_comm
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : BEq α
inst✝ : LawfulBEq α
a b : α
l : List α
⊢ (l.erase a).erase b = (l.erase b).erase a
state_after: α : Type u_1
inst✝¹ : BEq α
inst✝ : LawfulBEq α
a b : α
l : List α
ab : ¬(a == b) = true
⊢ (l.erase a).erase b = (l.erase b).erase a
tactic: if ab : a == b then rw [eq_of_beq ab] else ?_
state_before: α : Type u_1
inst✝¹ : BEq α
inst✝ : LawfulBEq α
a b : α
l : List α
ab : ¬(a == b) = true
⊢ (l.erase a).erase b = (l.erase b).erase a
state_after: α : Type u_1
inst✝¹ : BEq α
inst✝ : LawfulBEq α
a b : α
l : List α
ab : ¬(a == b) = true
ha : a ∈ l
⊢ (l.erase a).erase b = (l.erase b).erase a
tactic: if ha : a ∈ l then ?_ else
    simp only [erase_of_not_mem ha, erase_of_not_mem (mt mem_of_mem_erase ha)]
state_before: α : Type u_1
inst✝¹ : BEq α
inst✝ : LawfulBEq α
a b : α
l : List α
ab : ¬(a == b) = true
ha : a ∈ l
⊢ (l.erase a).erase b = (l.erase b).erase a
state_after: α : Type u_1
inst✝¹ : BEq α
inst✝ : LawfulBEq α
a b : α
l : List α
ab : ¬(a == b) = true
ha : a ∈ l
hb : b ∈ l
⊢ (l.erase a).erase b = (l.erase b).erase a
tactic: if hb : b ∈ l then ?_ else
    simp only [erase_of_not_mem hb, erase_of_not_mem (mt mem_of_mem_erase hb)]
state_before: α : Type u_1
inst✝¹ : BEq α
inst✝ : LawfulBEq α
a b : α
l : List α
ab : ¬(a == b) = true
ha : a ∈ l
hb : b ∈ l
⊢ (l.erase a).erase b = (l.erase b).erase a
state_after: no goals
tactic: match l, l.erase a, exists_erase_eq ha with
  | _, _, ⟨l₁, l₂, ha', rfl, rfl⟩ =>
    if h₁ : b ∈ l₁ then
      rw [erase_append_left _ h₁, erase_append_left _ h₁,
          erase_append_right _ (mt mem_of_mem_erase ha'), erase_cons_head]
    else
      rw [erase_append_right _ h₁, erase_append_right _ h₁, erase_append_right _ ha',
          erase_cons_tail _ ab, erase_cons_head]
Theorem: Matrix.mulVec.addMonoidHomLeft_apply
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✝¹ : NonUnitalNonAssocSemiring α
inst✝ : Fintype n
v : n → α
⊢ (fun M => M *ᵥ v) 0 = 0
state_after: case h
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝¹ : NonUnitalNonAssocSemiring α
inst✝ : Fintype n
v : n → α
x✝ : m
⊢ (fun M => M *ᵥ v) 0 x✝ = 0 x✝
tactic: ext
state_before: case h
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝¹ : NonUnitalNonAssocSemiring α
inst✝ : Fintype n
v : n → α
x✝ : m
⊢ (fun M => M *ᵥ v) 0 x✝ = 0 x✝
state_after: no goals
tactic: simp [mulVec]
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✝¹ : NonUnitalNonAssocSemiring α
inst✝ : Fintype n
v : n → α
x y : Matrix m n α
⊢ { toFun := fun M => M *ᵥ v, map_zero' := ⋯ }.toFun (x + y) =
    { toFun := fun M => M *ᵥ v, map_zero' := ⋯ }.toFun x + { toFun := fun M => M *ᵥ v, map_zero' := ⋯ }.toFun y
state_after: case h
l : Type u_1
m✝ : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝¹ : NonUnitalNonAssocSemiring α
inst✝ : Fintype n
v : n → α
x y : Matrix m✝ n α
m : m✝
⊢ { toFun := fun M => M *ᵥ v, map_zero' := ⋯ }.toFun (x + y) m =
    ({ toFun := fun M => M *ᵥ v, map_zero' := ⋯ }.toFun x + { toFun := fun M => M *ᵥ v, map_zero' := ⋯ }.toFun y) m
tactic: ext m
state_before: case h
l : Type u_1
m✝ : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝¹ : NonUnitalNonAssocSemiring α
inst✝ : Fintype n
v : n → α
x y : Matrix m✝ n α
m : m✝
⊢ { toFun := fun M => M *ᵥ v, map_zero' := ⋯ }.toFun (x + y) m =
    ({ toFun := fun M => M *ᵥ v, map_zero' := ⋯ }.toFun x + { toFun := fun M => M *ᵥ v, map_zero' := ⋯ }.toFun y) m
state_after: no goals
tactic: apply add_dotProduct
Theorem: Fin.add_zero
File: Mathlib/Data/Fin/Basic.lean

Proof steps:
state_before: n m : ℕ
inst✝ : NeZero n
k : Fin n
⊢ k + 0 = k
state_after: no goals
tactic: simp only [add_def, val_zero', Nat.add_zero, mod_eq_of_lt (is_lt k)]
Theorem: Equiv.Perm.card_support_eq_two
File: Mathlib/GroupTheory/Perm/Support.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g f : Perm α
⊢ f.support.card = 2 ↔ f.IsSwap
state_after: case mp
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g f : Perm α
h : f.support.card = 2
⊢ f.IsSwap

case mpr
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g f : Perm α
h : f.IsSwap
⊢ f.support.card = 2
tactic: constructor <;> intro h
Theorem: EMetric.infEdist_closure_pos_iff_not_mem_closure
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
x✝ y : α
s t : Set α
Φ : α → β
x : α
E : Set α
⊢ 0 < infEdist x (closure E) ↔ x ∉ closure E
state_after: no goals
tactic: rw [infEdist_closure, infEdist_pos_iff_not_mem_closure]
Theorem: CategoryTheory.epi_of_nonzero_to_simple
File: Mathlib/CategoryTheory/Simple.lean

Proof steps:
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
inst✝² : HasEqualizers C
X Y : C
inst✝¹ : Simple Y
f : X ⟶ Y
inst✝ : HasImage f
w : f ≠ 0
⊢ Epi f
state_after: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
inst✝² : HasEqualizers C
X Y : C
inst✝¹ : Simple Y
f : X ⟶ Y
inst✝ : HasImage f
w : f ≠ 0
⊢ Epi (factorThruImage f ≫ image.ι f)
tactic: rw [← image.fac f]
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
inst✝² : HasEqualizers C
X Y : C
inst✝¹ : Simple Y
f : X ⟶ Y
inst✝ : HasImage f
w : f ≠ 0
⊢ Epi (factorThruImage f ≫ image.ι f)
state_after: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
inst✝² : HasEqualizers C
X Y : C
inst✝¹ : Simple Y
f : X ⟶ Y
inst✝ : HasImage f
w : f ≠ 0
this : IsIso (image.ι f)
⊢ Epi (factorThruImage f ≫ image.ι f)
tactic: haveI : IsIso (image.ι f) := isIso_of_mono_of_nonzero fun h => w (eq_zero_of_image_eq_zero h)
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
inst✝² : HasEqualizers C
X Y : C
inst✝¹ : Simple Y
f : X ⟶ Y
inst✝ : HasImage f
w : f ≠ 0
this : IsIso (image.ι f)
⊢ Epi (factorThruImage f ≫ image.ι f)
state_after: no goals
tactic: apply epi_comp
Theorem: Set.iUnion₂_subset_iff
File: Mathlib/Data/Set/Lattice.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
s : (i : ι) → κ i → Set α
t : Set α
⊢ ⋃ i, ⋃ j, s i j ⊆ t ↔ ∀ (i : ι) (j : κ i), s i j ⊆ t
state_after: no goals
tactic: simp_rw [iUnion_subset_iff]
Theorem: Module.exists_nontrivial_relation_sum_zero_of_finrank_succ_lt_card
File: Mathlib/LinearAlgebra/Dimension/Finite.lean

Proof steps:
state_before: R : Type u
M M₁ : Type v
M' : Type v'
ι : Type w
inst✝⁹ : Ring R
inst✝⁸ : AddCommGroup M
inst✝⁷ : AddCommGroup M'
inst✝⁶ : AddCommGroup M₁
inst✝⁵ : Module R M
inst✝⁴ : Module R M'
inst✝³ : Module R M₁
inst✝² : StrongRankCondition R
inst✝¹ : Finite R M
inst✝ : NoZeroSMulDivisors R M
t : Finset M
h : finrank R M + 1 < t.card
⊢ ∃ f, ∑ e ∈ t, f e • e = 0 ∧ ∑ e ∈ t, f e = 0 ∧ ∃ x ∈ t, f x ≠ 0
state_after: case intro
R : Type u
M M₁ : Type v
M' : Type v'
ι : Type w
inst✝⁹ : Ring R
inst✝⁸ : AddCommGroup M
inst✝⁷ : AddCommGroup M'
inst✝⁶ : AddCommGroup M₁
inst✝⁵ : Module R M
inst✝⁴ : Module R M'
inst✝³ : Module R M₁
inst✝² : StrongRankCondition R
inst✝¹ : Finite R M
inst✝ : NoZeroSMulDivisors R M
t : Finset M
h : finrank R M + 1 < t.card
x₀ : M
x₀_mem : x₀ ∈ t
⊢ ∃ f, ∑ e ∈ t, f e • e = 0 ∧ ∑ e ∈ t, f e = 0 ∧ ∃ x ∈ t, f x ≠ 0
tactic: obtain ⟨x₀, x₀_mem⟩ := card_pos.1 ((Nat.succ_pos _).trans h)
Theorem: DFinsupp.sum_mapRange_index
File: Mathlib/Data/DFinsupp/Basic.lean

Proof steps:
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁✝ : ι → Type v₁
β₂✝ : ι → Type v₂
inst✝⁵ : DecidableEq ι
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝⁴ : (i : ι) → Zero (β₁ i)
inst✝³ : (i : ι) → Zero (β₂ i)
inst✝² : (i : ι) → (x : β₁ i) → Decidable (x ≠ 0)
inst✝¹ : (i : ι) → (x : β₂ i) → Decidable (x ≠ 0)
inst✝ : CommMonoid γ
f : (i : ι) → β₁ i → β₂ i
hf : ∀ (i : ι), f i 0 = 0
g : Π₀ (i : ι), β₁ i
h : (i : ι) → β₂ i → γ
h0 : ∀ (i : ι), h i 0 = 1
⊢ (mapRange f hf g).prod h = g.prod fun i b => h i (f i b)
state_after: ι : Type u
γ : Type w
β : ι → Type v
β₁✝ : ι → Type v₁
β₂✝ : ι → Type v₂
inst✝⁵ : DecidableEq ι
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝⁴ : (i : ι) → Zero (β₁ i)
inst✝³ : (i : ι) → Zero (β₂ i)
inst✝² : (i : ι) → (x : β₁ i) → Decidable (x ≠ 0)
inst✝¹ : (i : ι) → (x : β₂ i) → Decidable (x ≠ 0)
inst✝ : CommMonoid γ
f : (i : ι) → β₁ i → β₂ i
hf : ∀ (i : ι), f i 0 = 0
g : Π₀ (i : ι), β₁ i
h : (i : ι) → β₂ i → γ
h0 : ∀ (i : ι), h i 0 = 1
⊢ (mk g.support fun i => f (↑i) (g ↑i)).prod h = g.prod fun i b => h i (f i b)
tactic: rw [mapRange_def]
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁✝ : ι → Type v₁
β₂✝ : ι → Type v₂
inst✝⁵ : DecidableEq ι
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝⁴ : (i : ι) → Zero (β₁ i)
inst✝³ : (i : ι) → Zero (β₂ i)
inst✝² : (i : ι) → (x : β₁ i) → Decidable (x ≠ 0)
inst✝¹ : (i : ι) → (x : β₂ i) → Decidable (x ≠ 0)
inst✝ : CommMonoid γ
f : (i : ι) → β₁ i → β₂ i
hf : ∀ (i : ι), f i 0 = 0
g : Π₀ (i : ι), β₁ i
h : (i : ι) → β₂ i → γ
h0 : ∀ (i : ι), h i 0 = 1
⊢ (mk g.support fun i => f (↑i) (g ↑i)).prod h = g.prod fun i b => h i (f i b)
state_after: case refine_1
ι : Type u
γ : Type w
β : ι → Type v
β₁✝ : ι → Type v₁
β₂✝ : ι → Type v₂
inst✝⁵ : DecidableEq ι
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝⁴ : (i : ι) → Zero (β₁ i)
inst✝³ : (i : ι) → Zero (β₂ i)
inst✝² : (i : ι) → (x : β₁ i) → Decidable (x ≠ 0)
inst✝¹ : (i : ι) → (x : β₂ i) → Decidable (x ≠ 0)
inst✝ : CommMonoid γ
f : (i : ι) → β₁ i → β₂ i
hf : ∀ (i : ι), f i 0 = 0
g : Π₀ (i : ι), β₁ i
h : (i : ι) → β₂ i → γ
h0 : ∀ (i : ι), h i 0 = 1
⊢ ∀ x ∈ g.support, x ∉ (mk g.support fun i => f (↑i) (g ↑i)).support → h x ((mk g.support fun i => f (↑i) (g ↑i)) x) = 1

case refine_2
ι : Type u
γ : Type w
β : ι → Type v
β₁✝ : ι → Type v₁
β₂✝ : ι → Type v₂
inst✝⁵ : DecidableEq ι
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝⁴ : (i : ι) → Zero (β₁ i)
inst✝³ : (i : ι) → Zero (β₂ i)
inst✝² : (i : ι) → (x : β₁ i) → Decidable (x ≠ 0)
inst✝¹ : (i : ι) → (x : β₂ i) → Decidable (x ≠ 0)
inst✝ : CommMonoid γ
f : (i : ι) → β₁ i → β₂ i
hf : ∀ (i : ι), f i 0 = 0
g : Π₀ (i : ι), β₁ i
h : (i : ι) → β₂ i → γ
h0 : ∀ (i : ι), h i 0 = 1
⊢ ∏ x ∈ g.support, h x ((mk g.support fun i => f (↑i) (g ↑i)) x) = g.prod fun i b => h i (f i b)
tactic: refine (Finset.prod_subset support_mk_subset ?_).trans ?_
Theorem: ProbabilityTheory.Kernel.setLIntegral_compProd
File: Mathlib/Probability/Kernel/Composition.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s✝ : Set (β × γ)
κ : Kernel α β
inst✝¹ : IsSFiniteKernel κ
η : Kernel (α × β) γ
inst✝ : IsSFiniteKernel η
a : α
f : β × γ → ℝ≥0∞
hf : Measurable f
s : Set β
t : Set γ
hs : MeasurableSet s
ht : MeasurableSet t
⊢ ∫⁻ (z : β × γ) in s ×ˢ t, f z ∂(κ ⊗ₖ η) a = ∫⁻ (x : β) in s, ∫⁻ (y : γ) in t, f (x, y) ∂η (a, x) ∂κ a
state_after: no goals
tactic: simp_rw [← Kernel.restrict_apply (κ ⊗ₖ η) (hs.prod ht), ← compProd_restrict hs ht,
    lintegral_compProd _ _ _ hf, Kernel.restrict_apply]
Theorem: Localization.mk_left_injective
File: Mathlib/GroupTheory/MonoidLocalization/Basic.lean

Proof steps:
state_before: α : Type u_1
inst✝ : CancelCommMonoid α
s : Submonoid α
a₁ b₁ : α
a₂ b₂ b : ↥s
c d : α
h : (fun a => mk a b) c = (fun a => mk a b) d
⊢ c = d
state_after: no goals
tactic: simpa [-mk_eq_monoidOf_mk', mk_eq_mk_iff, r_iff_exists] using h
Theorem: Subtype.preimage_coe_eq_preimage_coe_iff
File: Mathlib/Data/Set/Image.lean

Proof steps:
state_before: α : Type u_1
s t u : Set α
⊢ val ⁻¹' t = val ⁻¹' u ↔ s ∩ t = s ∩ u
state_after: no goals
tactic: rw [← image_preimage_coe, ← image_preimage_coe, coe_injective.image_injective.eq_iff]
Theorem: List.replicate_right_inj'
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
a b : α
⊢ replicate 0 a = replicate 0 b ↔ 0 = 0 ∨ a = b
state_after: no goals
tactic: simp
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
a b : α
n : ℕ
⊢ a = b ↔ n + 1 = 0 ∨ a = b
state_after: no goals
tactic: simp only [n.succ_ne_zero, false_or]
Theorem: Equiv.extendSubtype_not_mem
File: Mathlib/Logic/Equiv/Fintype.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : Finite α
p q : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
e : { x // p x } ≃ { x // q x }
x : α
hx : ¬p x
⊢ ¬q (e.extendSubtype x)
state_after: case h.e'_1.h.e'_1
α : Type u_1
β : Type u_2
inst✝² : Finite α
p q : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
e : { x // p x } ≃ { x // q x }
x : α
hx : ¬p x
⊢ e.extendSubtype x = ↑(e.toCompl ⟨x, hx⟩)
tactic: convert (e.toCompl ⟨x, hx⟩).2
state_before: case h.e'_1.h.e'_1
α : Type u_1
β : Type u_2
inst✝² : Finite α
p q : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
e : { x // p x } ≃ { x // q x }
x : α
hx : ¬p x
⊢ e.extendSubtype x = ↑(e.toCompl ⟨x, hx⟩)
state_after: no goals
tactic: rw [e.extendSubtype_apply_of_not_mem _ hx]
Theorem: AddSubgroup.coe_inclusion
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
H✝ K✝ H K : Subgroup G
h : H ≤ K
a : ↥H
⊢ ↑((inclusion h) a) = ↑a
state_after: case mk
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
H✝ K✝ H K : Subgroup G
h : H ≤ K
val✝ : G
property✝ : val✝ ∈ H
⊢ ↑((inclusion h) ⟨val✝, property✝⟩) = ↑⟨val✝, property✝⟩
tactic: cases a
state_before: case mk
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
H✝ K✝ H K : Subgroup G
h : H ≤ K
val✝ : G
property✝ : val✝ ∈ H
⊢ ↑((inclusion h) ⟨val✝, property✝⟩) = ↑⟨val✝, property✝⟩
state_after: no goals
tactic: simp only [inclusion, coe_mk, MonoidHom.mk'_apply]
Theorem: Nat.mod_add_div'
File: Mathlib/Data/Nat/Defs.lean

Proof steps:
state_before: a✝ b✝ c d m n k : ℕ
p q : ℕ → Prop
a b : ℕ
⊢ a % b + a / b * b = a
state_after: a✝ b✝ c d m n k : ℕ
p q : ℕ → Prop
a b : ℕ
⊢ a % b + b * (a / b) = a
tactic: rw [Nat.mul_comm]
state_before: a✝ b✝ c d m n k : ℕ
p q : ℕ → Prop
a b : ℕ
⊢ a % b + b * (a / b) = a
state_after: no goals
tactic: exact mod_add_div _ _
Theorem: MeasureTheory.measure_union_congr_of_subset
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s s₁ s₂ t t₁ t₂ : Set α
hs : s₁ ⊆ s₂
hsμ : μ s₂ ≤ μ s₁
ht : t₁ ⊆ t₂
htμ : μ t₂ ≤ μ t₁
⊢ μ (s₁ ∪ t₁) = μ (s₂ ∪ t₂)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s s₁ s₂ t t₁ t₂ : Set α
hs : s₁ ⊆ s₂
hsμ : μ s₂ ≤ μ s₁
ht : t₁ ⊆ t₂
htμ : μ t₂ ≤ μ t₁
⊢ μ (⋃ b, bif b then s₁ else t₁) = μ (⋃ b, bif b then s₂ else t₂)
tactic: rw [union_eq_iUnion, union_eq_iUnion]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s s₁ s₂ t t₁ t₂ : Set α
hs : s₁ ⊆ s₂
hsμ : μ s₂ ≤ μ s₁
ht : t₁ ⊆ t₂
htμ : μ t₂ ≤ μ t₁
⊢ μ (⋃ b, bif b then s₁ else t₁) = μ (⋃ b, bif b then s₂ else t₂)
state_after: no goals
tactic: exact measure_iUnion_congr_of_subset (Bool.forall_bool.2 ⟨ht, hs⟩) (Bool.forall_bool.2 ⟨htμ, hsμ⟩)
Theorem: Ordinal.div_opow_log_lt
File: Mathlib/SetTheory/Ordinal/Exponential.lean

Proof steps:
state_before: b o : Ordinal.{u_1}
hb : 1 < b
⊢ o / b ^ log b o < b
state_after: b o : Ordinal.{u_1}
hb : 1 < b
⊢ o < b ^ succ (log b o)
tactic: rw [div_lt (opow_pos _ (zero_lt_one.trans hb)).ne', ← opow_succ]
state_before: b o : Ordinal.{u_1}
hb : 1 < b
⊢ o < b ^ succ (log b o)
state_after: no goals
tactic: exact lt_opow_succ_log_self hb o
Theorem: ProjectiveSpectrum.vanishingIdeal_closure
File: Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Topology.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
inst✝³ : CommSemiring R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
t : Set (ProjectiveSpectrum 𝒜)
⊢ vanishingIdeal (closure t) = vanishingIdeal t
state_after: R : Type u_1
A : Type u_2
inst✝³ : CommSemiring R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
t : Set (ProjectiveSpectrum 𝒜)
this : (vanishingIdeal (zeroLocus 𝒜 ↑(vanishingIdeal t).toIdeal)).toIdeal = (vanishingIdeal t).toIdeal
⊢ vanishingIdeal (closure t) = vanishingIdeal t
tactic: have := (gc_ideal 𝒜).u_l_u_eq_u t
state_before: R : Type u_1
A : Type u_2
inst✝³ : CommSemiring R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
t : Set (ProjectiveSpectrum 𝒜)
this : (vanishingIdeal (zeroLocus 𝒜 ↑(vanishingIdeal t).toIdeal)).toIdeal = (vanishingIdeal t).toIdeal
⊢ vanishingIdeal (closure t) = vanishingIdeal t
state_after: case h
R : Type u_1
A : Type u_2
inst✝³ : CommSemiring R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
t : Set (ProjectiveSpectrum 𝒜)
this : (vanishingIdeal (zeroLocus 𝒜 ↑(vanishingIdeal t).toIdeal)).toIdeal = (vanishingIdeal t).toIdeal
⊢ (vanishingIdeal (closure t)).toIdeal = (vanishingIdeal t).toIdeal
tactic: ext1
state_before: case h
R : Type u_1
A : Type u_2
inst✝³ : CommSemiring R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
t : Set (ProjectiveSpectrum 𝒜)
this : (vanishingIdeal (zeroLocus 𝒜 ↑(vanishingIdeal t).toIdeal)).toIdeal = (vanishingIdeal t).toIdeal
⊢ (vanishingIdeal (closure t)).toIdeal = (vanishingIdeal t).toIdeal
state_after: case h
R : Type u_1
A : Type u_2
inst✝³ : CommSemiring R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
t : Set (ProjectiveSpectrum 𝒜)
this : (vanishingIdeal (closure t)).toIdeal = (vanishingIdeal t).toIdeal
⊢ (vanishingIdeal (closure t)).toIdeal = (vanishingIdeal t).toIdeal
tactic: erw [zeroLocus_vanishingIdeal_eq_closure 𝒜 t] at this
state_before: case h
R : Type u_1
A : Type u_2
inst✝³ : CommSemiring R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
t : Set (ProjectiveSpectrum 𝒜)
this : (vanishingIdeal (closure t)).toIdeal = (vanishingIdeal t).toIdeal
⊢ (vanishingIdeal (closure t)).toIdeal = (vanishingIdeal t).toIdeal
state_after: no goals
tactic: exact this
Theorem: ContinuousMap.hasSum_of_hasSum_Lp
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
inst✝⁸ : TopologicalSpace α
inst✝⁷ : BorelSpace α
inst✝⁶ : SecondCountableTopologyEither α E
inst✝⁵ : CompactSpace α
inst✝⁴ : IsFiniteMeasure μ
𝕜 : Type u_5
inst✝³ : Fact (1 ≤ p)
β : Type u_6
inst✝² : μ.IsOpenPosMeasure
inst✝¹ : NormedField 𝕜
inst✝ : NormedSpace 𝕜 E
g : β → C(α, E)
f : C(α, E)
hg : Summable g
hg2 : HasSum (⇑(toLp p μ 𝕜) ∘ g) ((toLp p μ 𝕜) f)
⊢ HasSum g f
state_after: case h.e'_6
α : 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
inst✝⁸ : TopologicalSpace α
inst✝⁷ : BorelSpace α
inst✝⁶ : SecondCountableTopologyEither α E
inst✝⁵ : CompactSpace α
inst✝⁴ : IsFiniteMeasure μ
𝕜 : Type u_5
inst✝³ : Fact (1 ≤ p)
β : Type u_6
inst✝² : μ.IsOpenPosMeasure
inst✝¹ : NormedField 𝕜
inst✝ : NormedSpace 𝕜 E
g : β → C(α, E)
f : C(α, E)
hg : Summable g
hg2 : HasSum (⇑(toLp p μ 𝕜) ∘ g) ((toLp p μ 𝕜) f)
⊢ f = ∑' (b : β), g b
tactic: convert Summable.hasSum hg
state_before: case h.e'_6
α : 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
inst✝⁸ : TopologicalSpace α
inst✝⁷ : BorelSpace α
inst✝⁶ : SecondCountableTopologyEither α E
inst✝⁵ : CompactSpace α
inst✝⁴ : IsFiniteMeasure μ
𝕜 : Type u_5
inst✝³ : Fact (1 ≤ p)
β : Type u_6
inst✝² : μ.IsOpenPosMeasure
inst✝¹ : NormedField 𝕜
inst✝ : NormedSpace 𝕜 E
g : β → C(α, E)
f : C(α, E)
hg : Summable g
hg2 : HasSum (⇑(toLp p μ 𝕜) ∘ g) ((toLp p μ 𝕜) f)
⊢ f = ∑' (b : β), g b
state_after: no goals
tactic: exact toLp_injective μ (hg2.unique ((toLp p μ 𝕜).hasSum <| Summable.hasSum hg))
Theorem: StrictConcaveOn.slope_lt_of_hasDerivAt
File: Mathlib/Analysis/Convex/Deriv.lean

Proof steps:
state_before: S : Set ℝ
f : ℝ → ℝ
x y f' : ℝ
hfc : StrictConcaveOn ℝ S f
hx : x ∈ S
hy : y ∈ S
hxy : x < y
hfd : HasDerivAt f f' x
⊢ slope f x y < f'
state_after: no goals
tactic: simpa only [Pi.neg_def, slope_neg, neg_neg] using
    neg_lt_neg (hfc.neg.lt_slope_of_hasDerivAt hx hy hxy hfd.neg)