ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: LieSubalgebra.incl_range
File: Mathlib/Algebra/Lie/Subalgebra.lean

Proof steps:
state_before: R : Type u
L : Type v
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
L₂ : Type w
inst✝¹ : LieRing L₂
inst✝ : LieAlgebra R L₂
f : L →ₗ⁅R⁆ L₂
K K' : LieSubalgebra R L
K₂ : LieSubalgebra R L₂
⊢ K.incl.range = K
state_after: R : Type u
L : Type v
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
L₂ : Type w
inst✝¹ : LieRing L₂
inst✝ : LieAlgebra R L₂
f : L →ₗ⁅R⁆ L₂
K K' : LieSubalgebra R L
K₂ : LieSubalgebra R L₂
⊢ K.incl.range.toSubmodule = K.toSubmodule
tactic: rw [← coe_to_submodule_eq_iff]
state_before: R : Type u
L : Type v
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
L₂ : Type w
inst✝¹ : LieRing L₂
inst✝ : LieAlgebra R L₂
f : L →ₗ⁅R⁆ L₂
K K' : LieSubalgebra R L
K₂ : LieSubalgebra R L₂
⊢ K.incl.range.toSubmodule = K.toSubmodule
state_after: no goals
tactic: exact (K : Submodule R L).range_subtype
Theorem: SSet.horn.primitiveEdge_coe_down
File: Mathlib/AlgebraicTopology/SimplicialSet.lean

Proof steps:
state_before: n : ℕ
i : Fin (n + 1)
h₀ : 0 < i
hₙ : i < Fin.last n
j : Fin n
⊢ Λ[n, i] _[1]
state_after: case refine_1
n : ℕ
i : Fin (n + 1)
h₀ : 0 < i
hₙ : i < Fin.last n
j : Fin n
⊢ j.castSucc ≤ j.succ

case refine_2
n : ℕ
i : Fin (n + 1)
h₀ : 0 < i
hₙ : i < Fin.last n
j : Fin n
⊢ {i, j.castSucc, j.succ}.card ≤ n
tactic: refine horn.edge n i j.castSucc j.succ ?_ ?_
state_before: case refine_2
n : ℕ
i : Fin (n + 1)
h₀ : 0 < i
hₙ : i < Fin.last n
j : Fin n
⊢ {i, j.castSucc, j.succ}.card ≤ n
state_after: case refine_2
n : ℕ
i : Fin (n + 1)
j : Fin n
h₀ : 0 < ↑i
hₙ : ↑i < n
⊢ {i, j.castSucc, j.succ}.card ≤ n
tactic: simp only [← Fin.val_fin_lt, Fin.val_zero, Fin.val_last] at h₀ hₙ
state_before: case refine_2
n : ℕ
i : Fin (n + 1)
j : Fin n
h₀ : 0 < ↑i
hₙ : ↑i < n
⊢ {i, j.castSucc, j.succ}.card ≤ n
state_after: case refine_2.inl
i : Fin (2 + 1)
j : Fin 2
h₀ : 0 < ↑i
hₙ : ↑i < 2
⊢ {i, j.castSucc, j.succ}.card ≤ 2

case refine_2.inr
n : ℕ
i : Fin (n + 1)
j : Fin n
h₀ : 0 < ↑i
hₙ : ↑i < n
hn : 2 < n
⊢ {i, j.castSucc, j.succ}.card ≤ n
tactic: obtain rfl|hn : n = 2 ∨ 2 < n := by
    rw [eq_comm, or_comm, ← le_iff_lt_or_eq]; omega
Theorem: Set.seq_def
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 : Set (α → β)
t : Set α
⊢ s.seq t = ⋃ f ∈ s, f '' t
state_after: no goals
tactic: rw [seq_eq_image2, iUnion_image_left]
Theorem: Set.isAtom_iff
File: Mathlib/Order/Atoms.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
s : Set α
⊢ IsAtom s ↔ ∃ x, s = {x}
state_after: ι : Sort u_1
α : Type u_2
β : Type u_3
s : Set α
⊢ IsAtom s → ∃ x, s = {x}
tactic: refine
    ⟨?_, by
      rintro ⟨x, rfl⟩
      exact isAtom_singleton x⟩
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
s : Set α
⊢ IsAtom s → ∃ x, s = {x}
state_after: ι : Sort u_1
α : Type u_2
β : Type u_3
s : Set α
⊢ (s.Nonempty ∧ ∀ (b : Set α), b ≠ ∅ → b ≤ s → s ≤ b) → ∃ x, s = {x}
tactic: rw [isAtom_iff_le_of_ge, bot_eq_empty, ← nonempty_iff_ne_empty]
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
s : Set α
⊢ (s.Nonempty ∧ ∀ (b : Set α), b ≠ ∅ → b ≤ s → s ≤ b) → ∃ x, s = {x}
state_after: case intro.intro
ι : Sort u_1
α : Type u_2
β : Type u_3
s : Set α
hs : ∀ (b : Set α), b ≠ ∅ → b ≤ s → s ≤ b
x : α
hx : x ∈ s
⊢ ∃ x, s = {x}
tactic: rintro ⟨⟨x, hx⟩, hs⟩
state_before: case intro.intro
ι : Sort u_1
α : Type u_2
β : Type u_3
s : Set α
hs : ∀ (b : Set α), b ≠ ∅ → b ≤ s → s ≤ b
x : α
hx : x ∈ s
⊢ ∃ x, s = {x}
state_after: no goals
tactic: exact
    ⟨x, eq_singleton_iff_unique_mem.2
        ⟨hx, fun y hy => (hs {y} (singleton_ne_empty _) (singleton_subset_iff.2 hy) hx).symm⟩⟩
Theorem: Filter.Tendsto.div_const
File: Mathlib/Topology/Algebra/GroupWithZero.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G₀ : Type u_3
inst✝² : DivInvMonoid G₀
inst✝¹ : TopologicalSpace G₀
inst✝ : ContinuousMul G₀
f : α → G₀
s : Set α
l : Filter α
x : G₀
hf : Tendsto f l (𝓝 x)
y : G₀
⊢ Tendsto (fun a => f a / y) l (𝓝 (x / y))
state_after: no goals
tactic: simpa only [div_eq_mul_inv] using hf.mul tendsto_const_nhds
Theorem: Dense.smul
File: Mathlib/Topology/Algebra/ConstMulAction.lean

Proof steps:
state_before: M : Type u_1
α : Type u_2
β : Type u_3
G : Type u_4
inst✝⁴ : TopologicalSpace α
inst✝³ : Group G
inst✝² : MulAction G α
inst✝¹ : ContinuousConstSMul G α
inst✝ : TopologicalSpace β
f : β → α
b : β
s✝ : Set β
c : G
s : Set α
hs : Dense s
⊢ Dense (c • s)
state_after: M : Type u_1
α : Type u_2
β : Type u_3
G : Type u_4
inst✝⁴ : TopologicalSpace α
inst✝³ : Group G
inst✝² : MulAction G α
inst✝¹ : ContinuousConstSMul G α
inst✝ : TopologicalSpace β
f : β → α
b : β
s✝ : Set β
c : G
s : Set α
hs : closure s = univ
⊢ closure (c • s) = univ
tactic: rw [dense_iff_closure_eq] at hs ⊢
state_before: M : Type u_1
α : Type u_2
β : Type u_3
G : Type u_4
inst✝⁴ : TopologicalSpace α
inst✝³ : Group G
inst✝² : MulAction G α
inst✝¹ : ContinuousConstSMul G α
inst✝ : TopologicalSpace β
f : β → α
b : β
s✝ : Set β
c : G
s : Set α
hs : closure s = univ
⊢ closure (c • s) = univ
state_after: no goals
tactic: rw [closure_smul, hs, smul_set_univ]
Theorem: LieAlgebra.subsingleton_of_hasTrivialRadical_lie_abelian
File: Mathlib/Algebra/Lie/Semisimple/Basic.lean

Proof steps:
state_before: R : Type u_1
L : Type u_2
inst✝³ : CommRing R
inst✝² : LieRing L
inst✝¹ : LieAlgebra R L
inst✝ : HasTrivialRadical R L
h : IsLieAbelian L
⊢ Subsingleton L
state_after: R : Type u_1
L : Type u_2
inst✝³ : CommRing R
inst✝² : LieRing L
inst✝¹ : LieAlgebra R L
inst✝ : HasTrivialRadical R L
h : ⊥ = ⊤
⊢ Subsingleton L
tactic: rw [isLieAbelian_iff_center_eq_top R L, HasTrivialRadical.center_eq_bot] at h
state_before: R : Type u_1
L : Type u_2
inst✝³ : CommRing R
inst✝² : LieRing L
inst✝¹ : LieAlgebra R L
inst✝ : HasTrivialRadical R L
h : ⊥ = ⊤
⊢ Subsingleton L
state_after: no goals
tactic: exact (LieSubmodule.subsingleton_iff R L L).mp (subsingleton_of_bot_eq_top h)
Theorem: MvPolynomial.eval_eval₂
File: Mathlib/Algebra/MvPolynomial/Basic.lean

Proof steps:
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝³ : CommSemiring R
inst✝² : CommSemiring S₁
p✝ q : MvPolynomial σ R
f✝ : σ → R
S : Type u_2
τ : Type u_3
x : τ → S
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : R →+* MvPolynomial τ S
g : σ → MvPolynomial τ S
p : MvPolynomial σ R
⊢ (eval x) (eval₂ f g p) = eval₂ ((eval x).comp f) (fun s => (eval x) (g s)) p
state_after: case h_C
R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝³ : CommSemiring R
inst✝² : CommSemiring S₁
p✝ q : MvPolynomial σ R
f✝ : σ → R
S : Type u_2
τ : Type u_3
x : τ → S
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : R →+* MvPolynomial τ S
g : σ → MvPolynomial τ S
p : MvPolynomial σ R
⊢ ∀ (a : R), (eval x) (eval₂ f g (C a)) = eval₂ ((eval x).comp f) (fun s => (eval x) (g s)) (C a)

case h_add
R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝³ : CommSemiring R
inst✝² : CommSemiring S₁
p✝ q : MvPolynomial σ R
f✝ : σ → R
S : Type u_2
τ : Type u_3
x : τ → S
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : R →+* MvPolynomial τ S
g : σ → MvPolynomial τ S
p : MvPolynomial σ R
⊢ ∀ (p q : MvPolynomial σ R),
    (eval x) (eval₂ f g p) = eval₂ ((eval x).comp f) (fun s => (eval x) (g s)) p →
      (eval x) (eval₂ f g q) = eval₂ ((eval x).comp f) (fun s => (eval x) (g s)) q →
        (eval x) (eval₂ f g (p + q)) = eval₂ ((eval x).comp f) (fun s => (eval x) (g s)) (p + q)

case h_X
R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝³ : CommSemiring R
inst✝² : CommSemiring S₁
p✝ q : MvPolynomial σ R
f✝ : σ → R
S : Type u_2
τ : Type u_3
x : τ → S
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : R →+* MvPolynomial τ S
g : σ → MvPolynomial τ S
p : MvPolynomial σ R
⊢ ∀ (p : MvPolynomial σ R) (n : σ),
    (eval x) (eval₂ f g p) = eval₂ ((eval x).comp f) (fun s => (eval x) (g s)) p →
      (eval x) (eval₂ f g (p * X n)) = eval₂ ((eval x).comp f) (fun s => (eval x) (g s)) (p * X n)
tactic: apply induction_on p
Theorem: CochainComplex.mk'_d_1_0
File: Mathlib/Algebra/Homology/HomologicalComplex.lean

Proof steps:
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
X₀ X₁ X₂ : V
d₀ : X₀ ⟶ X₁
d₁ : X₁ ⟶ X₂
s : d₀ ≫ d₁ = 0
succ : (S : ShortComplex V) → (X₄ : V) ×' (d₂ : S.X₃ ⟶ X₄) ×' S.g ≫ d₂ = 0
succ' : {X₀ X₁ : V} → (f : X₀ ⟶ X₁) → (X₂ : V) ×' (d : X₁ ⟶ X₂) ×' f ≫ d = 0
⊢ (mk' X₀ X₁ d₀ fun {X₀ X₁} => succ').d 0 1 = d₀
state_after: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
X₀ X₁ X₂ : V
d₀ : X₀ ⟶ X₁
d₁ : X₁ ⟶ X₂
s : d₀ ≫ d₁ = 0
succ : (S : ShortComplex V) → (X₄ : V) ×' (d₂ : S.X₃ ⟶ X₄) ×' S.g ≫ d₂ = 0
succ' : {X₀ X₁ : V} → (f : X₀ ⟶ X₁) → (X₂ : V) ×' (d : X₁ ⟶ X₂) ×' f ≫ d = 0
⊢ (if 1 = 0 + 1 then d₀ ≫ 𝟙 X₁ else 0) = d₀
tactic: change ite (1 = 0 + 1) (d₀ ≫ 𝟙 X₁) 0 = d₀
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
X₀ X₁ X₂ : V
d₀ : X₀ ⟶ X₁
d₁ : X₁ ⟶ X₂
s : d₀ ≫ d₁ = 0
succ : (S : ShortComplex V) → (X₄ : V) ×' (d₂ : S.X₃ ⟶ X₄) ×' S.g ≫ d₂ = 0
succ' : {X₀ X₁ : V} → (f : X₀ ⟶ X₁) → (X₂ : V) ×' (d : X₁ ⟶ X₂) ×' f ≫ d = 0
⊢ (if 1 = 0 + 1 then d₀ ≫ 𝟙 X₁ else 0) = d₀
state_after: no goals
tactic: rw [if_pos rfl, Category.comp_id]
Theorem: Filter.EventuallyLE.isMaxFilter
File: Mathlib/Order/Filter/Extr.lean

Proof steps:
state_before: α✝ : Type u
β✝ : Type v
γ : Type w
δ : Type x
α : Type u_1
β : Type u_2
inst✝ : Preorder β
f g : α → β
a : α
l : Filter α
hle : g ≤ᶠ[l] f
hfga : f a = g a
h : IsMaxFilter f l a
⊢ IsMaxFilter g l a
state_after: α✝ : Type u
β✝ : Type v
γ : Type w
δ : Type x
α : Type u_1
β : Type u_2
inst✝ : Preorder β
f g : α → β
a : α
l : Filter α
hle : g ≤ᶠ[l] f
hfga : f a = g a
h : IsMaxFilter f l a
x : α
hf : f x ≤ f a
hgf : g x ≤ f x
⊢ g x ≤ g a
tactic: refine hle.mp (h.mono fun x hf hgf => ?_)
state_before: α✝ : Type u
β✝ : Type v
γ : Type w
δ : Type x
α : Type u_1
β : Type u_2
inst✝ : Preorder β
f g : α → β
a : α
l : Filter α
hle : g ≤ᶠ[l] f
hfga : f a = g a
h : IsMaxFilter f l a
x : α
hf : f x ≤ f a
hgf : g x ≤ f x
⊢ g x ≤ g a
state_after: α✝ : Type u
β✝ : Type v
γ : Type w
δ : Type x
α : Type u_1
β : Type u_2
inst✝ : Preorder β
f g : α → β
a : α
l : Filter α
hle : g ≤ᶠ[l] f
hfga : f a = g a
h : IsMaxFilter f l a
x : α
hf : f x ≤ f a
hgf : g x ≤ f x
⊢ g x ≤ f a
tactic: rw [← hfga]
state_before: α✝ : Type u
β✝ : Type v
γ : Type w
δ : Type x
α : Type u_1
β : Type u_2
inst✝ : Preorder β
f g : α → β
a : α
l : Filter α
hle : g ≤ᶠ[l] f
hfga : f a = g a
h : IsMaxFilter f l a
x : α
hf : f x ≤ f a
hgf : g x ≤ f x
⊢ g x ≤ f a
state_after: no goals
tactic: exact le_trans hgf hf
Theorem: gold_lt_two
File: Mathlib/Data/Real/GoldenRatio.lean

Proof steps:
state_before: ⊢ φ < 2
state_after: no goals
tactic: calc
  (1 + sqrt 5) / 2 < (1 + 3) / 2 := by gcongr; rw [sqrt_lt'] <;> norm_num
  _ = 2 := by norm_num
Theorem: Matrix.conjTranspose_zero
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✝¹ : AddMonoid α
inst✝ : StarAddMonoid α
⊢ ∀ (i : n) (j : m), 0ᴴ i j = 0 i j
state_after: no goals
tactic: simp
Theorem: SubfieldClass.ratCast_mem
File: Mathlib/Algebra/Field/Subfield.lean

Proof steps:
state_before: K : Type u
L : Type v
M : Type w
inst✝³ : DivisionRing K
inst✝² : DivisionRing L
inst✝¹ : DivisionRing M
S : Type u_1
inst✝ : SetLike S K
h : SubfieldClass S K
x : K
s : S
q : ℚ
⊢ ↑q ∈ s
state_after: no goals
tactic: simpa only [Rat.cast_def] using div_mem (intCast_mem s q.num) (natCast_mem s q.den)
Theorem: Finset.not_disjoint_iff
File: Mathlib/Data/Finset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f : α → β
s t u : Finset α
a b x✝ : α
⊢ ¬(x✝ ∈ s → x✝ ∉ t) ↔ x✝ ∈ s ∧ x✝ ∈ t
state_after: no goals
tactic: rw [Classical.not_imp, not_not]
Theorem: CoxeterMatrix.reindex_relationsSet
File: Mathlib/GroupTheory/Coxeter/Basic.lean

Proof steps:
state_before: B : Type u_1
B' : Type u_2
M : CoxeterMatrix B
e : B ≃ B'
M' : CoxeterMatrix B' := CoxeterMatrix.reindex e M
⊢ Set.range (uncurry M'.relation) = Set.range (uncurry M'.relation ∘ Prod.map ⇑e ⇑e)
state_after: no goals
tactic: simp [Set.range_comp]
state_before: B : Type u_1
B' : Type u_2
M : CoxeterMatrix B
e : B ≃ B'
M' : CoxeterMatrix B' := CoxeterMatrix.reindex e M
⊢ Set.range (uncurry M'.relation ∘ Prod.map ⇑e ⇑e) = Set.range (⇑(FreeGroup.freeGroupCongr e) ∘ uncurry M.relation)
state_after: B : Type u_1
B' : Type u_2
M : CoxeterMatrix B
e : B ≃ B'
M' : CoxeterMatrix B' := CoxeterMatrix.reindex e M
⊢ uncurry M'.relation ∘ Prod.map ⇑e ⇑e = ⇑(FreeGroup.freeGroupCongr e) ∘ uncurry M.relation
tactic: apply congrArg Set.range
state_before: B : Type u_1
B' : Type u_2
M : CoxeterMatrix B
e : B ≃ B'
M' : CoxeterMatrix B' := CoxeterMatrix.reindex e M
⊢ uncurry M'.relation ∘ Prod.map ⇑e ⇑e = ⇑(FreeGroup.freeGroupCongr e) ∘ uncurry M.relation
state_after: case h.mk
B : Type u_1
B' : Type u_2
M : CoxeterMatrix B
e : B ≃ B'
M' : CoxeterMatrix B' := CoxeterMatrix.reindex e M
i i' : B
⊢ (uncurry M'.relation ∘ Prod.map ⇑e ⇑e) (i, i') = (⇑(FreeGroup.freeGroupCongr e) ∘ uncurry M.relation) (i, i')
tactic: ext ⟨i, i'⟩
state_before: case h.mk
B : Type u_1
B' : Type u_2
M : CoxeterMatrix B
e : B ≃ B'
M' : CoxeterMatrix B' := CoxeterMatrix.reindex e M
i i' : B
⊢ (uncurry M'.relation ∘ Prod.map ⇑e ⇑e) (i, i') = (⇑(FreeGroup.freeGroupCongr e) ∘ uncurry M.relation) (i, i')
state_after: no goals
tactic: simp [relation, reindex_apply, M']
state_before: B : Type u_1
B' : Type u_2
M : CoxeterMatrix B
e : B ≃ B'
M' : CoxeterMatrix B' := CoxeterMatrix.reindex e M
⊢ Set.range (⇑(FreeGroup.freeGroupCongr e) ∘ uncurry M.relation) = ⇑(FreeGroup.freeGroupCongr e) '' M.relationsSet
state_after: no goals
tactic: simp [Set.range_comp, relationsSet]
Theorem: Set.diff_iUnion
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
inst✝ : Nonempty ι
s : Set β
t : ι → Set β
⊢ s \ ⋃ i, t i = ⋂ i, s \ t i
state_after: α : 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
inst✝ : Nonempty ι
s : Set β
t : ι → Set β
⊢ ⋂ i, s ∩ (t i)ᶜ = ⋂ i, s \ t i
tactic: rw [diff_eq, compl_iUnion, inter_iInter]
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
inst✝ : Nonempty ι
s : Set β
t : ι → Set β
⊢ ⋂ i, s ∩ (t i)ᶜ = ⋂ i, s \ t i
state_after: no goals
tactic: rfl
Theorem: norm_add_le
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✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s : Set E
a✝ a₁ a₂ b✝ b₁ b₂ : E
r r₁ r₂ : ℝ
a b : E
⊢ ‖a * b‖ ≤ ‖a‖ + ‖b‖
state_after: no goals
tactic: simpa [dist_eq_norm_div] using dist_triangle a 1 b⁻¹
Theorem: DFinsupp.mk_smul
File: Mathlib/Data/DFinsupp/Basic.lean

Proof steps:
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝³ : DecidableEq ι
inst✝² : Monoid γ
inst✝¹ : (i : ι) → AddMonoid (β i)
inst✝ : (i : ι) → DistribMulAction γ (β i)
s : Finset ι
c : γ
x : (i : ↑↑s) → β ↑i
i : ι
⊢ (mk s (c • x)) i = (c • mk s x) i
state_after: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝³ : DecidableEq ι
inst✝² : Monoid γ
inst✝¹ : (i : ι) → AddMonoid (β i)
inst✝ : (i : ι) → DistribMulAction γ (β i)
s : Finset ι
c : γ
x : (i : ↑↑s) → β ↑i
i : ι
⊢ (if H : i ∈ s then (c • x) ⟨i, H⟩ else 0) = c • if H : i ∈ s then x ⟨i, H⟩ else 0
tactic: simp only [smul_apply, mk_apply]
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝³ : DecidableEq ι
inst✝² : Monoid γ
inst✝¹ : (i : ι) → AddMonoid (β i)
inst✝ : (i : ι) → DistribMulAction γ (β i)
s : Finset ι
c : γ
x : (i : ↑↑s) → β ↑i
i : ι
⊢ (if H : i ∈ s then (c • x) ⟨i, H⟩ else 0) = c • if H : i ∈ s then x ⟨i, H⟩ else 0
state_after: no goals
tactic: split_ifs <;> [rfl; rw [smul_zero]]
Theorem: MvPowerSeries.coeff_index_single_X
File: Mathlib/RingTheory/MvPowerSeries/Basic.lean

Proof steps:
state_before: σ : Type u_1
R : Type u_2
inst✝¹ : Semiring R
inst✝ : DecidableEq σ
s t : σ
⊢ (coeff R (single t 1)) (X s) = if t = s then 1 else 0
state_after: no goals
tactic: simp only [coeff_X, single_left_inj (one_ne_zero : (1 : ℕ) ≠ 0)]
Theorem: WeierstrassCurve.Jacobian.polynomialX_eq
File: Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean

Proof steps:
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
⊢ W'.polynomialX = C W'.a₁ * X y * X z - (C 3 * X x ^ 2 + C (2 * W'.a₂) * X x * X z ^ 2 + C W'.a₄ * X z ^ 4)
state_after: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
⊢ (pderiv x)
      (X y ^ 2 + C W'.a₁ * X x * X y * X z + C W'.a₃ * X y * X z ^ 3 -
        (X x ^ 3 + C W'.a₂ * X x ^ 2 * X z ^ 2 + C W'.a₄ * X x * X z ^ 4 + C W'.a₆ * X z ^ 6)) =
    C W'.a₁ * X y * X z - (C 3 * X x ^ 2 + C (2 * W'.a₂) * X x * X z ^ 2 + C W'.a₄ * X z ^ 4)
tactic: rw [polynomialX, polynomial]
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
⊢ (pderiv x)
      (X y ^ 2 + C W'.a₁ * X x * X y * X z + C W'.a₃ * X y * X z ^ 3 -
        (X x ^ 3 + C W'.a₂ * X x ^ 2 * X z ^ 2 + C W'.a₄ * X x * X z ^ 4 + C W'.a₆ * X z ^ 6)) =
    C W'.a₁ * X y * X z - (C 3 * X x ^ 2 + C (2 * W'.a₂) * X x * X z ^ 2 + C W'.a₄ * X z ^ 4)
state_after: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
⊢ ↑2 * X y ^ (2 - 1) * 0 + (((0 * X x + C W'.a₁ * 1) * X y + C W'.a₁ * X x * 0) * X z + C W'.a₁ * X x * X y * 0) +
        ((0 * X y + C W'.a₃ * 0) * X z ^ 3 + C W'.a₃ * X y * (↑3 * X z ^ (3 - 1) * 0)) -
      (↑3 * X x ^ (3 - 1) * 1 +
            ((0 * X x ^ 2 + C W'.a₂ * (↑2 * X x ^ (2 - 1) * 1)) * X z ^ 2 +
              C W'.a₂ * X x ^ 2 * (↑2 * X z ^ (2 - 1) * 0)) +
          ((0 * X x + C W'.a₄ * 1) * X z ^ 4 + C W'.a₄ * X x * (↑4 * X z ^ (4 - 1) * 0)) +
        (0 * X z ^ 6 + C W'.a₆ * (↑6 * X z ^ (6 - 1) * 0))) =
    C W'.a₁ * X y * X z - (3 * X x ^ 2 + 2 * C W'.a₂ * X x * X z ^ 2 + C W'.a₄ * X z ^ 4)
tactic: pderiv_simp
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
⊢ ↑2 * X y ^ (2 - 1) * 0 + (((0 * X x + C W'.a₁ * 1) * X y + C W'.a₁ * X x * 0) * X z + C W'.a₁ * X x * X y * 0) +
        ((0 * X y + C W'.a₃ * 0) * X z ^ 3 + C W'.a₃ * X y * (↑3 * X z ^ (3 - 1) * 0)) -
      (↑3 * X x ^ (3 - 1) * 1 +
            ((0 * X x ^ 2 + C W'.a₂ * (↑2 * X x ^ (2 - 1) * 1)) * X z ^ 2 +
              C W'.a₂ * X x ^ 2 * (↑2 * X z ^ (2 - 1) * 0)) +
          ((0 * X x + C W'.a₄ * 1) * X z ^ 4 + C W'.a₄ * X x * (↑4 * X z ^ (4 - 1) * 0)) +
        (0 * X z ^ 6 + C W'.a₆ * (↑6 * X z ^ (6 - 1) * 0))) =
    C W'.a₁ * X y * X z - (3 * X x ^ 2 + 2 * C W'.a₂ * X x * X z ^ 2 + C W'.a₄ * X z ^ 4)
state_after: no goals
tactic: ring1
Theorem: MeasureTheory.setIntegral_eq_integral_of_ae_compl_eq_zero
File: Mathlib/MeasureTheory/Integral/SetIntegral.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace X
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f g : X → E
s t : Set X
μ ν : Measure X
l l' : Filter X
h : ∀ᵐ (x : X) ∂μ, x ∉ s → f x = 0
⊢ ∫ (x : X) in s, f x ∂μ = ∫ (x : X), f x ∂μ
state_after: X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace X
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f g : X → E
s t : Set X
μ ν : Measure X
l l' : Filter X
h : ∀ᵐ (x : X) ∂μ, x ∉ s → f x = 0
⊢ ∫ (x : X), f x ∂μ = ∫ (x : X) in s, f x ∂μ
tactic: symm
state_before: X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace X
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f g : X → E
s t : Set X
μ ν : Measure X
l l' : Filter X
h : ∀ᵐ (x : X) ∂μ, x ∉ s → f x = 0
⊢ ∫ (x : X), f x ∂μ = ∫ (x : X) in s, f x ∂μ
state_after: X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace X
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f g : X → E
s t : Set X
μ ν : Measure X
l l' : Filter X
h : ∀ᵐ (x : X) ∂μ, x ∉ s → f x = 0
⊢ ∫ (x : X) in univ, f x ∂μ = ∫ (x : X) in s, f x ∂μ
tactic: nth_rw 1 [← integral_univ]
state_before: X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace X
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f g : X → E
s t : Set X
μ ν : Measure X
l l' : Filter X
h : ∀ᵐ (x : X) ∂μ, x ∉ s → f x = 0
⊢ ∫ (x : X) in univ, f x ∂μ = ∫ (x : X) in s, f x ∂μ
state_after: X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace X
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f g : X → E
s t : Set X
μ ν : Measure X
l l' : Filter X
h : ∀ᵐ (x : X) ∂μ, x ∉ s → f x = 0
⊢ ∀ᵐ (x : X) ∂μ, x ∈ univ \ s → f x = 0
tactic: apply setIntegral_eq_of_subset_of_ae_diff_eq_zero nullMeasurableSet_univ (subset_univ _)
state_before: X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace X
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f g : X → E
s t : Set X
μ ν : Measure X
l l' : Filter X
h : ∀ᵐ (x : X) ∂μ, x ∉ s → f x = 0
⊢ ∀ᵐ (x : X) ∂μ, x ∈ univ \ s → f x = 0
state_after: no goals
tactic: filter_upwards [h] with x hx h'x using hx h'x.2
Theorem: eq_neg_vadd_iff
File: Mathlib/Algebra/Group/Action/Defs.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
G : Type u_3
H : Type u_4
A : Type u_5
B : Type u_6
α : Type u_7
β : Type u_8
γ : Type u_9
δ : Type u_10
inst✝³ : Monoid M
inst✝² : MulAction M α
inst✝¹ : Group G
inst✝ : MulAction G α
g : G
a b : α
h : a = g⁻¹ • b
⊢ g • a = b
state_after: no goals
tactic: rw [h, smul_inv_smul]
state_before: M : Type u_1
N : Type u_2
G : Type u_3
H : Type u_4
A : Type u_5
B : Type u_6
α : Type u_7
β : Type u_8
γ : Type u_9
δ : Type u_10
inst✝³ : Monoid M
inst✝² : MulAction M α
inst✝¹ : Group G
inst✝ : MulAction G α
g : G
a b : α
h : g • a = b
⊢ a = g⁻¹ • b
state_after: no goals
tactic: rw [← h, inv_smul_smul]
Theorem: Int.bitwise_xor
File: Mathlib/Data/Int/Bitwise.lean

Proof steps:
state_before: ⊢ bitwise xor = Int.xor
state_after: case h.h
m n : ℤ
⊢ bitwise xor m n = m.xor n
tactic: funext m n
state_before: case h.h
m n : ℤ
⊢ bitwise xor m n = m.xor n
state_after: case h.h.ofNat.negSucc
m n : ℕ
⊢ Nat.bitwise (fun x y => !xor x !y) m n = Nat.bitwise xor m n

case h.h.negSucc.ofNat
m n : ℕ
⊢ Nat.bitwise (fun x y => !xor (!x) y) m n = Nat.bitwise xor m n

case h.h.negSucc.negSucc
m n : ℕ
⊢ ↑(Nat.bitwise (fun x y => xor (!x) !y) m n) = ↑(Nat.bitwise xor m n)
tactic: cases' m with m m <;> cases' n with n n <;> try {rfl}
    <;> simp only [bitwise, natBitwise, Bool.not_false, Bool.or_true, Bool.bne_eq_xor,
      cond_false, cond_true, lor, Nat.ldiff, Bool.and_true, negSucc.injEq, Bool.false_xor,
      Bool.true_xor, Bool.and_false, Nat.land, Bool.not_true, ldiff,
      HOr.hOr, OrOp.or, Nat.lor, Int.xor, HXor.hXor, Xor.xor, Nat.xor]