ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: DFinsupp.mapRange_neLocus_eq
File: Mathlib/Data/DFinsupp/NeLocus.lean

Proof steps:
state_before: α : Type u_1
N : α → Type u_2
inst✝⁵ : DecidableEq α
M : α → Type u_3
P : α → Type u_4
inst✝⁴ : (a : α) → Zero (N a)
inst✝³ : (a : α) → Zero (M a)
inst✝² : (a : α) → Zero (P a)
inst✝¹ : (a : α) → DecidableEq (N a)
inst✝ : (a : α) → DecidableEq (M a)
f g : Π₀ (a : α), N a
F : (a : α) → N a → M a
F0 : ∀ (a : α), F a 0 = 0
hF : ∀ (a : α), Function.Injective (F a)
⊢ (mapRange F F0 f).neLocus (mapRange F F0 g) = f.neLocus g
state_after: case a
α : Type u_1
N : α → Type u_2
inst✝⁵ : DecidableEq α
M : α → Type u_3
P : α → Type u_4
inst✝⁴ : (a : α) → Zero (N a)
inst✝³ : (a : α) → Zero (M a)
inst✝² : (a : α) → Zero (P a)
inst✝¹ : (a : α) → DecidableEq (N a)
inst✝ : (a : α) → DecidableEq (M a)
f g : Π₀ (a : α), N a
F : (a : α) → N a → M a
F0 : ∀ (a : α), F a 0 = 0
hF : ∀ (a : α), Function.Injective (F a)
a : α
⊢ a ∈ (mapRange F F0 f).neLocus (mapRange F F0 g) ↔ a ∈ f.neLocus g
tactic: ext a
state_before: case a
α : Type u_1
N : α → Type u_2
inst✝⁵ : DecidableEq α
M : α → Type u_3
P : α → Type u_4
inst✝⁴ : (a : α) → Zero (N a)
inst✝³ : (a : α) → Zero (M a)
inst✝² : (a : α) → Zero (P a)
inst✝¹ : (a : α) → DecidableEq (N a)
inst✝ : (a : α) → DecidableEq (M a)
f g : Π₀ (a : α), N a
F : (a : α) → N a → M a
F0 : ∀ (a : α), F a 0 = 0
hF : ∀ (a : α), Function.Injective (F a)
a : α
⊢ a ∈ (mapRange F F0 f).neLocus (mapRange F F0 g) ↔ a ∈ f.neLocus g
state_after: no goals
tactic: simpa only [mem_neLocus] using (hF a).ne_iff
Theorem: Nat.recDiag_succ_zero
File: .lake/packages/batteries/Batteries/Data/Nat/Lemmas.lean

Proof steps:
state_before: motive : Nat → Nat → Sort u_1
zero_zero : motive 0 0
zero_succ : (n : Nat) → motive 0 n → motive 0 (n + 1)
succ_zero : (m : Nat) → motive m 0 → motive (m + 1) 0
succ_succ : (m n : Nat) → motive m n → motive (m + 1) (n + 1)
m : Nat
⊢ Nat.recDiag zero_zero zero_succ succ_zero succ_succ (m + 1) 0 =
    succ_zero m (Nat.recDiag zero_zero zero_succ succ_zero succ_succ m 0)
state_after: motive : Nat → Nat → Sort u_1
zero_zero : motive 0 0
zero_succ : (n : Nat) → motive 0 n → motive 0 (n + 1)
succ_zero : (m : Nat) → motive m 0 → motive (m + 1) 0
succ_succ : (m n : Nat) → motive m n → motive (m + 1) (n + 1)
m : Nat
⊢ Nat.recDiagAux (recDiag.left zero_zero zero_succ) (recDiag.right zero_zero succ_zero) succ_succ (m + 1) 0 =
    succ_zero m (Nat.recDiagAux (recDiag.left zero_zero zero_succ) (recDiag.right zero_zero succ_zero) succ_succ m 0)
tactic: simp [Nat.recDiag]
state_before: motive : Nat → Nat → Sort u_1
zero_zero : motive 0 0
zero_succ : (n : Nat) → motive 0 n → motive 0 (n + 1)
succ_zero : (m : Nat) → motive m 0 → motive (m + 1) 0
succ_succ : (m n : Nat) → motive m n → motive (m + 1) (n + 1)
m : Nat
⊢ Nat.recDiagAux (recDiag.left zero_zero zero_succ) (recDiag.right zero_zero succ_zero) succ_succ (m + 1) 0 =
    succ_zero m (Nat.recDiagAux (recDiag.left zero_zero zero_succ) (recDiag.right zero_zero succ_zero) succ_succ m 0)
state_after: no goals
tactic: cases m <;> rfl
Theorem: piecewise_ae_eq_of_ae_eq_set
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
inst✝² : MeasurableSpace α
μ : Measure α
s t : Set α
f g : α → β
inst✝¹ : DecidablePred fun x => x ∈ s
inst✝ : DecidablePred fun x => x ∈ t
hst : s =ᶠ[ae μ] t
x : α
hx : x ∈ s ↔ x ∈ t
⊢ s.piecewise f g x = t.piecewise f g x
state_after: no goals
tactic: simp [piecewise, hx]
Theorem: LipschitzWith.compLp_zero
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
g : E → F
c : ℝ≥0
hg : LipschitzWith c g
g0 : g 0 = 0
⊢ hg.compLp g0 0 = 0
state_after: α : 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
g : E → F
c : ℝ≥0
hg : LipschitzWith c g
g0 : g 0 = 0
⊢ ↑↑(hg.compLp g0 0) =ᶠ[ae μ] 0
tactic: rw [Lp.eq_zero_iff_ae_eq_zero]
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
g : E → F
c : ℝ≥0
hg : LipschitzWith c g
g0 : g 0 = 0
⊢ ↑↑(hg.compLp g0 0) =ᶠ[ae μ] 0
state_after: α : 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
g : E → F
c : ℝ≥0
hg : LipschitzWith c g
g0 : g 0 = 0
⊢ g ∘ ↑↑0 =ᶠ[ae μ] 0
tactic: apply (coeFn_compLp _ _ _).trans
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
g : E → F
c : ℝ≥0
hg : LipschitzWith c g
g0 : g 0 = 0
⊢ g ∘ ↑↑0 =ᶠ[ae μ] 0
state_after: case h
α : 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
g : E → F
c : ℝ≥0
hg : LipschitzWith c g
g0 : g 0 = 0
a✝ : α
ha : ↑↑0 a✝ = 0 a✝
⊢ (g ∘ ↑↑0) a✝ = 0 a✝
tactic: filter_upwards [Lp.coeFn_zero E p μ] with _ ha
state_before: case h
α : 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
g : E → F
c : ℝ≥0
hg : LipschitzWith c g
g0 : g 0 = 0
a✝ : α
ha : ↑↑0 a✝ = 0 a✝
⊢ (g ∘ ↑↑0) a✝ = 0 a✝
state_after: no goals
tactic: simp only [ha, g0, Function.comp_apply, Pi.zero_apply]
Theorem: CategoryTheory.FunctorToTypes.binaryProductEquiv_apply
File: Mathlib/CategoryTheory/Limits/Shapes/FunctorToTypes.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
F G : C ⥤ Type w
a : C
x✝ : (F ⨯ G).obj a
⊢ (fun z => prodMk z.1 z.2)
      ((fun z => (((binaryProductIso F G).hom.app a z).1, ((binaryProductIso F G).hom.app a z).2)) x✝) =
    x✝
state_after: no goals
tactic: simp [prodMk]
state_before: C : Type u
inst✝ : Category.{v, u} C
F G : C ⥤ Type w
a : C
x✝ : F.obj a × G.obj a
⊢ (fun z => (((binaryProductIso F G).hom.app a z).1, ((binaryProductIso F G).hom.app a z).2))
      ((fun z => prodMk z.1 z.2) x✝) =
    x✝
state_after: no goals
tactic: simp [prodMk]
Theorem: MeasureTheory.mutuallySingular_dirac
File: Mathlib/MeasureTheory/Measure/Dirac.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
δ : Type u_3
inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
s : Set α
a : α
inst✝¹ : MeasurableSingletonClass α
x : α
μ : Measure α
inst✝ : NoAtoms μ
⊢ (dirac x) {x}ᶜ = 0
state_after: no goals
tactic: simp
state_before: α : Type u_1
β : Type u_2
δ : Type u_3
inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
s : Set α
a : α
inst✝¹ : MeasurableSingletonClass α
x : α
μ : Measure α
inst✝ : NoAtoms μ
⊢ μ {x}ᶜᶜ = 0
state_after: no goals
tactic: simp
Theorem: MonotoneOn.union_right
File: Mathlib/Order/Monotone/Union.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : Preorder β
a : α
f : α → β
s t : Set α
c : α
h₁ : MonotoneOn f s
h₂ : MonotoneOn f t
hs : IsGreatest s c
ht : IsLeast t c
A : ∀ x ∈ s ∪ t, x ≤ c → x ∈ s
B : ∀ x ∈ s ∪ t, c ≤ x → x ∈ t
⊢ MonotoneOn f (s ∪ t)
state_after: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : Preorder β
a : α
f : α → β
s t : Set α
c : α
h₁ : MonotoneOn f s
h₂ : MonotoneOn f t
hs : IsGreatest s c
ht : IsLeast t c
A : ∀ x ∈ s ∪ t, x ≤ c → x ∈ s
B : ∀ x ∈ s ∪ t, c ≤ x → x ∈ t
x : α
hx : x ∈ s ∪ t
y : α
hy : y ∈ s ∪ t
hxy : x ≤ y
⊢ f x ≤ f y
tactic: intro x hx y hy hxy
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : Preorder β
a : α
f : α → β
s t : Set α
c : α
h₁ : MonotoneOn f s
h₂ : MonotoneOn f t
hs : IsGreatest s c
ht : IsLeast t c
A : ∀ x ∈ s ∪ t, x ≤ c → x ∈ s
B : ∀ x ∈ s ∪ t, c ≤ x → x ∈ t
x : α
hx : x ∈ s ∪ t
y : α
hy : y ∈ s ∪ t
hxy : x ≤ y
⊢ f x ≤ f y
state_after: case inl
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : Preorder β
a : α
f : α → β
s t : Set α
c : α
h₁ : MonotoneOn f s
h₂ : MonotoneOn f t
hs : IsGreatest s c
ht : IsLeast t c
A : ∀ x ∈ s ∪ t, x ≤ c → x ∈ s
B : ∀ x ∈ s ∪ t, c ≤ x → x ∈ t
x : α
hx : x ∈ s ∪ t
y : α
hy : y ∈ s ∪ t
hxy : x ≤ y
hxc : x < c
⊢ f x ≤ f y

case inr
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : Preorder β
a : α
f : α → β
s t : Set α
c : α
h₁ : MonotoneOn f s
h₂ : MonotoneOn f t
hs : IsGreatest s c
ht : IsLeast t c
A : ∀ x ∈ s ∪ t, x ≤ c → x ∈ s
B : ∀ x ∈ s ∪ t, c ≤ x → x ∈ t
x : α
hx : x ∈ s ∪ t
y : α
hy : y ∈ s ∪ t
hxy : x ≤ y
hcx : c ≤ x
⊢ f x ≤ f y
tactic: rcases lt_or_le x c with (hxc | hcx)
Theorem: skewAdjointPart_apply_coe
File: Mathlib/Algebra/Star/Module.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
inst✝⁷ : Semiring R
inst✝⁶ : StarMul R
inst✝⁵ : TrivialStar R
inst✝⁴ : AddCommGroup A
inst✝³ : Module R A
inst✝² : StarAddMonoid A
inst✝¹ : StarModule R A
inst✝ : Invertible 2
x : A
⊢ ⅟2 • (x - star x) ∈ skewAdjoint A
state_after: no goals
tactic: simp only [skewAdjoint.mem_iff, star_smul, star_sub, star_star, star_trivial, ← smul_neg,
        neg_sub]
state_before: R : Type u_1
A : Type u_2
inst✝⁷ : Semiring R
inst✝⁶ : StarMul R
inst✝⁵ : TrivialStar R
inst✝⁴ : AddCommGroup A
inst✝³ : Module R A
inst✝² : StarAddMonoid A
inst✝¹ : StarModule R A
inst✝ : Invertible 2
x y : A
⊢ (fun x => ⟨⅟2 • (x - star x), ⋯⟩) (x + y) = (fun x => ⟨⅟2 • (x - star x), ⋯⟩) x + (fun x => ⟨⅟2 • (x - star x), ⋯⟩) y
state_after: case a
R : Type u_1
A : Type u_2
inst✝⁷ : Semiring R
inst✝⁶ : StarMul R
inst✝⁵ : TrivialStar R
inst✝⁴ : AddCommGroup A
inst✝³ : Module R A
inst✝² : StarAddMonoid A
inst✝¹ : StarModule R A
inst✝ : Invertible 2
x y : A
⊢ ↑((fun x => ⟨⅟2 • (x - star x), ⋯⟩) (x + y)) =
    ↑((fun x => ⟨⅟2 • (x - star x), ⋯⟩) x + (fun x => ⟨⅟2 • (x - star x), ⋯⟩) y)
tactic: ext
state_before: case a
R : Type u_1
A : Type u_2
inst✝⁷ : Semiring R
inst✝⁶ : StarMul R
inst✝⁵ : TrivialStar R
inst✝⁴ : AddCommGroup A
inst✝³ : Module R A
inst✝² : StarAddMonoid A
inst✝¹ : StarModule R A
inst✝ : Invertible 2
x y : A
⊢ ↑((fun x => ⟨⅟2 • (x - star x), ⋯⟩) (x + y)) =
    ↑((fun x => ⟨⅟2 • (x - star x), ⋯⟩) x + (fun x => ⟨⅟2 • (x - star x), ⋯⟩) y)
state_after: no goals
tactic: simp only [sub_add, ← smul_add, sub_sub_eq_add_sub, star_add, AddSubgroup.coe_mk,
      AddSubgroup.coe_add]
state_before: R : Type u_1
A : Type u_2
inst✝⁷ : Semiring R
inst✝⁶ : StarMul R
inst✝⁵ : TrivialStar R
inst✝⁴ : AddCommGroup A
inst✝³ : Module R A
inst✝² : StarAddMonoid A
inst✝¹ : StarModule R A
inst✝ : Invertible 2
r : R
x : A
⊢ { toFun := fun x => ⟨⅟2 • (x - star x), ⋯⟩, map_add' := ⋯ }.toFun (r • x) =
    (RingHom.id R) r • { toFun := fun x => ⟨⅟2 • (x - star x), ⋯⟩, map_add' := ⋯ }.toFun x
state_after: case a
R : Type u_1
A : Type u_2
inst✝⁷ : Semiring R
inst✝⁶ : StarMul R
inst✝⁵ : TrivialStar R
inst✝⁴ : AddCommGroup A
inst✝³ : Module R A
inst✝² : StarAddMonoid A
inst✝¹ : StarModule R A
inst✝ : Invertible 2
r : R
x : A
⊢ ↑({ toFun := fun x => ⟨⅟2 • (x - star x), ⋯⟩, map_add' := ⋯ }.toFun (r • x)) =
    ↑((RingHom.id R) r • { toFun := fun x => ⟨⅟2 • (x - star x), ⋯⟩, map_add' := ⋯ }.toFun x)
tactic: ext
state_before: case a
R : Type u_1
A : Type u_2
inst✝⁷ : Semiring R
inst✝⁶ : StarMul R
inst✝⁵ : TrivialStar R
inst✝⁴ : AddCommGroup A
inst✝³ : Module R A
inst✝² : StarAddMonoid A
inst✝¹ : StarModule R A
inst✝ : Invertible 2
r : R
x : A
⊢ ↑({ toFun := fun x => ⟨⅟2 • (x - star x), ⋯⟩, map_add' := ⋯ }.toFun (r • x)) =
    ↑((RingHom.id R) r • { toFun := fun x => ⟨⅟2 • (x - star x), ⋯⟩, map_add' := ⋯ }.toFun x)
state_after: no goals
tactic: simp [← mul_smul, ← smul_sub,
      show r * ⅟ 2 = ⅟ 2 * r from Commute.invOf_right <| (2 : ℕ).commute_cast r]
Theorem: OmegaCompletePartialOrder.ContinuousHom.forall_forall_merge
File: Mathlib/Order/OmegaCompletePartialOrder.lean

Proof steps:
state_before: α : Type u
α' : Type u_1
β : Type v
β' : Type u_2
γ : Type u_3
φ : Type u_4
inst✝⁵ : OmegaCompletePartialOrder α
inst✝⁴ : OmegaCompletePartialOrder β
inst✝³ : OmegaCompletePartialOrder γ
inst✝² : OmegaCompletePartialOrder φ
inst✝¹ : OmegaCompletePartialOrder α'
inst✝ : OmegaCompletePartialOrder β'
c₀ : Chain (α →𝒄 β)
c₁ : Chain α
z : β
⊢ (∀ (i j : ℕ), (c₀ i) (c₁ j) ≤ z) ↔ ∀ (i : ℕ), (c₀ i) (c₁ i) ≤ z
state_after: case mp
α : Type u
α' : Type u_1
β : Type v
β' : Type u_2
γ : Type u_3
φ : Type u_4
inst✝⁵ : OmegaCompletePartialOrder α
inst✝⁴ : OmegaCompletePartialOrder β
inst✝³ : OmegaCompletePartialOrder γ
inst✝² : OmegaCompletePartialOrder φ
inst✝¹ : OmegaCompletePartialOrder α'
inst✝ : OmegaCompletePartialOrder β'
c₀ : Chain (α →𝒄 β)
c₁ : Chain α
z : β
h : ∀ (i j : ℕ), (c₀ i) (c₁ j) ≤ z
i : ℕ
⊢ (c₀ i) (c₁ i) ≤ z

case mpr
α : Type u
α' : Type u_1
β : Type v
β' : Type u_2
γ : Type u_3
φ : Type u_4
inst✝⁵ : OmegaCompletePartialOrder α
inst✝⁴ : OmegaCompletePartialOrder β
inst✝³ : OmegaCompletePartialOrder γ
inst✝² : OmegaCompletePartialOrder φ
inst✝¹ : OmegaCompletePartialOrder α'
inst✝ : OmegaCompletePartialOrder β'
c₀ : Chain (α →𝒄 β)
c₁ : Chain α
z : β
h : ∀ (i : ℕ), (c₀ i) (c₁ i) ≤ z
i j : ℕ
⊢ (c₀ i) (c₁ j) ≤ z
tactic: constructor <;> introv h
Theorem: StieltjesFunction.eq_of_measure_of_eq
File: Mathlib/MeasureTheory/Measure/Stieltjes.lean

Proof steps:
state_before: f g : StieltjesFunction
y : ℝ
hfg : f.measure = g.measure
hy : ↑f y = ↑g y
⊢ f = g
state_after: case h
f g : StieltjesFunction
y : ℝ
hfg : f.measure = g.measure
hy : ↑f y = ↑g y
x : ℝ
⊢ ↑f x = ↑g x
tactic: ext x
Theorem: four_functions_theorem_univ
File: Mathlib/Combinatorics/SetFamily/FourFunctions.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝³ : DistribLattice α
inst✝² : LinearOrderedCommSemiring β
inst✝¹ : ExistsAddOfLE β
f f₁ f₂ f₃ f₄ g μ : α → β
inst✝ : Fintype α
h₁ : 0 ≤ f₁
h₂ : 0 ≤ f₂
h₃ : 0 ≤ f₃
h₄ : 0 ≤ f₄
h : ∀ (a b : α), f₁ a * f₂ b ≤ f₃ (a ⊓ b) * f₄ (a ⊔ b)
⊢ (∑ a : α, f₁ a) * ∑ a : α, f₂ a ≤ (∑ a : α, f₃ a) * ∑ a : α, f₄ a
state_after: no goals
tactic: classical simpa using four_functions_theorem f₁ f₂ f₃ f₄ h₁ h₂ h₃ h₄ h univ univ
Theorem: IsLocalizedModule.mk'_sub_mk'
File: Mathlib/Algebra/Module/LocalizedModule.lean

Proof steps:
state_before: R : Type u_1
inst✝¹⁷ : CommSemiring R
S : Submonoid R
M✝ : Type u_2
M'✝ : Type u_3
M'' : Type u_4
inst✝¹⁶ : AddCommMonoid M✝
inst✝¹⁵ : AddCommMonoid M'✝
inst✝¹⁴ : AddCommMonoid M''
A : Type u_5
inst✝¹³ : CommSemiring A
inst✝¹² : Algebra R A
inst✝¹¹ : Module A M'✝
inst✝¹⁰ : IsLocalization S A
inst✝⁹ : Module R M✝
inst✝⁸ : Module R M'✝
inst✝⁷ : Module R M''
inst✝⁶ : IsScalarTower R A M'✝
f✝ : M✝ →ₗ[R] M'✝
g : M✝ →ₗ[R] M''
inst✝⁵ : IsLocalizedModule S f✝
M : Type u_6
M' : Type u_7
inst✝⁴ : AddCommGroup M
inst✝³ : AddCommGroup M'
inst✝² : Module R M
inst✝¹ : Module R M'
f : M →ₗ[R] M'
inst✝ : IsLocalizedModule S f
m₁ m₂ : M
s₁ s₂ : ↥S
⊢ mk' f m₁ s₁ - mk' f m₂ s₂ = mk' f (s₂ • m₁ - s₁ • m₂) (s₁ * s₂)
state_after: no goals
tactic: rw [sub_eq_add_neg, ← mk'_neg, mk'_add_mk', smul_neg, ← sub_eq_add_neg]
Theorem: iUnion_Icc_zsmul
File: Mathlib/Algebra/Order/ToIntervalMod.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : LinearOrderedAddCommGroup α
inst✝ : Archimedean α
p : α
hp : 0 < p
a : α
⊢ ⋃ n, Icc (n • p) ((n + 1) • p) = univ
state_after: no goals
tactic: simpa only [zero_add] using iUnion_Icc_add_zsmul hp 0
Theorem: Real.arcsin_sin'
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean

Proof steps:
state_before: x✝ y x : ℝ
hx : x ∈ Icc (-(π / 2)) (π / 2)
⊢ sin (arcsin (sin x)) = sin x
state_after: no goals
tactic: rw [sin_arcsin (neg_one_le_sin _) (sin_le_one _)]
Theorem: UpperSet.map_refl
File: Mathlib/Order/UpperLower/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
f : α ≃o β
s t : UpperSet α
a : α
b : β
⊢ map (OrderIso.refl α) = OrderIso.refl (UpperSet α)
state_after: case h.h.a.h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
f : α ≃o β
s t : UpperSet α
a : α
b : β
x✝¹ : UpperSet α
x✝ : α
⊢ x✝ ∈ ↑((map (OrderIso.refl α)) x✝¹) ↔ x✝ ∈ ↑((OrderIso.refl (UpperSet α)) x✝¹)
tactic: ext
state_before: case h.h.a.h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
f : α ≃o β
s t : UpperSet α
a : α
b : β
x✝¹ : UpperSet α
x✝ : α
⊢ x✝ ∈ ↑((map (OrderIso.refl α)) x✝¹) ↔ x✝ ∈ ↑((OrderIso.refl (UpperSet α)) x✝¹)
state_after: no goals
tactic: simp
Theorem: Polynomial.card_roots
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]
hp0 : p ≠ 0
⊢ ↑(Multiset.card p.roots) ≤ p.degree
state_after: no goals
tactic: classical
  unfold roots
  rw [dif_neg hp0]
  exact (Classical.choose_spec (exists_multiset_roots hp0)).1
Theorem: Subgroup.iSup_induction
File: Mathlib/Algebra/Group/Subgroup/Pointwise.lean

Proof steps:
state_before: α : Type u_1
G : Type u_2
A : Type u_3
S✝ : Type u_4
inst✝¹ : Group G
inst✝ : AddGroup A
s : Set G
ι : Sort u_5
S : ι → Subgroup G
C : G → Prop
x : G
hx : x ∈ ⨆ i, S i
mem : ∀ (i : ι), ∀ x ∈ S i, C x
one : C 1
mul : ∀ (x y : G), C x → C y → C (x * y)
⊢ C x
state_after: α : Type u_1
G : Type u_2
A : Type u_3
S✝ : Type u_4
inst✝¹ : Group G
inst✝ : AddGroup A
s : Set G
ι : Sort u_5
S : ι → Subgroup G
C : G → Prop
x : G
hx : x ∈ closure (⋃ i, ↑(S i))
mem : ∀ (i : ι), ∀ x ∈ S i, C x
one : C 1
mul : ∀ (x y : G), C x → C y → C (x * y)
⊢ C x
tactic: rw [iSup_eq_closure] at hx
state_before: α : Type u_1
G : Type u_2
A : Type u_3
S✝ : Type u_4
inst✝¹ : Group G
inst✝ : AddGroup A
s : Set G
ι : Sort u_5
S : ι → Subgroup G
C : G → Prop
x : G
hx : x ∈ closure (⋃ i, ↑(S i))
mem : ∀ (i : ι), ∀ x ∈ S i, C x
one : C 1
mul : ∀ (x y : G), C x → C y → C (x * y)
⊢ C x
state_after: no goals
tactic: induction hx using closure_induction'' with
  | one => exact one
  | mem x hx =>
    obtain ⟨i, hi⟩ := Set.mem_iUnion.mp hx
    exact mem _ _ hi
  | inv_mem x hx =>
    obtain ⟨i, hi⟩ := Set.mem_iUnion.mp hx
    exact mem _ _ (inv_mem hi)
  | mul x y _ _ ihx ihy => exact mul x y ihx ihy
Theorem: LipschitzOnWith.comp_eVariationOn_le
File: Mathlib/Analysis/BoundedVariation.lean

Proof steps:
state_before: α : Type u_1
inst✝² : LinearOrder α
E : Type u_2
inst✝¹ : PseudoEMetricSpace E
F : Type u_3
inst✝ : PseudoEMetricSpace F
f : E → F
C : ℝ≥0
t : Set E
h : LipschitzOnWith C f t
g : α → E
s : Set α
hg : MapsTo g s t
⊢ eVariationOn (f ∘ g) s ≤ ↑C * eVariationOn g s
state_after: α : Type u_1
inst✝² : LinearOrder α
E : Type u_2
inst✝¹ : PseudoEMetricSpace E
F : Type u_3
inst✝ : PseudoEMetricSpace F
f : E → F
C : ℝ≥0
t : Set E
h : LipschitzOnWith C f t
g : α → E
s : Set α
hg : MapsTo g s t
⊢ ∀ (i : ℕ × { u // Monotone u ∧ ∀ (i : ℕ), u i ∈ s }),
    ∑ i_1 ∈ Finset.range i.1, edist ((f ∘ g) (↑i.2 (i_1 + 1))) ((f ∘ g) (↑i.2 i_1)) ≤ ↑C * eVariationOn g s
tactic: apply iSup_le _
state_before: α : Type u_1
inst✝² : LinearOrder α
E : Type u_2
inst✝¹ : PseudoEMetricSpace E
F : Type u_3
inst✝ : PseudoEMetricSpace F
f : E → F
C : ℝ≥0
t : Set E
h : LipschitzOnWith C f t
g : α → E
s : Set α
hg : MapsTo g s t
⊢ ∀ (i : ℕ × { u // Monotone u ∧ ∀ (i : ℕ), u i ∈ s }),
    ∑ i_1 ∈ Finset.range i.1, edist ((f ∘ g) (↑i.2 (i_1 + 1))) ((f ∘ g) (↑i.2 i_1)) ≤ ↑C * eVariationOn g s
state_after: case mk.mk.intro
α : Type u_1
inst✝² : LinearOrder α
E : Type u_2
inst✝¹ : PseudoEMetricSpace E
F : Type u_3
inst✝ : PseudoEMetricSpace F
f : E → F
C : ℝ≥0
t : Set E
h : LipschitzOnWith C f t
g : α → E
s : Set α
hg : MapsTo g s t
n : ℕ
u : ℕ → α
hu : Monotone u
us : ∀ (i : ℕ), u i ∈ s
⊢ ∑ i ∈ Finset.range (n, ⟨u, ⋯⟩).1, edist ((f ∘ g) (↑(n, ⟨u, ⋯⟩).2 (i + 1))) ((f ∘ g) (↑(n, ⟨u, ⋯⟩).2 i)) ≤
    ↑C * eVariationOn g s
tactic: rintro ⟨n, ⟨u, hu, us⟩⟩
state_before: case mk.mk.intro
α : Type u_1
inst✝² : LinearOrder α
E : Type u_2
inst✝¹ : PseudoEMetricSpace E
F : Type u_3
inst✝ : PseudoEMetricSpace F
f : E → F
C : ℝ≥0
t : Set E
h : LipschitzOnWith C f t
g : α → E
s : Set α
hg : MapsTo g s t
n : ℕ
u : ℕ → α
hu : Monotone u
us : ∀ (i : ℕ), u i ∈ s
⊢ ∑ i ∈ Finset.range (n, ⟨u, ⋯⟩).1, edist ((f ∘ g) (↑(n, ⟨u, ⋯⟩).2 (i + 1))) ((f ∘ g) (↑(n, ⟨u, ⋯⟩).2 i)) ≤
    ↑C * eVariationOn g s
state_after: no goals
tactic: calc
    (∑ i ∈ Finset.range n, edist (f (g (u (i + 1)))) (f (g (u i)))) ≤
        ∑ i ∈ Finset.range n, C * edist (g (u (i + 1))) (g (u i)) :=
      Finset.sum_le_sum fun i _ => h (hg (us _)) (hg (us _))
    _ = C * ∑ i ∈ Finset.range n, edist (g (u (i + 1))) (g (u i)) := by rw [Finset.mul_sum]
    _ ≤ C * eVariationOn g s := mul_le_mul_left' (eVariationOn.sum_le _ _ hu us) _
Theorem: Finset.map_prodComm_antidiagonal
File: Mathlib/Algebra/Order/Antidiag/Prod.lean

Proof steps:
state_before: A : Type u_1
inst✝¹ : AddCommMonoid A
inst✝ : HasAntidiagonal A
n : A
x✝ : A × A
a b : A
⊢ (a, b) ∈ map (Equiv.prodComm A A).toEmbedding (antidiagonal n) ↔ (a, b) ∈ antidiagonal n
state_after: no goals
tactic: simp [add_comm]
Theorem: AddSubgroup.card_eq_card_quotient_mul_card_addSubgroup
File: Mathlib/GroupTheory/Coset.lean

Proof steps:
state_before: α : Type u_1
inst✝ : Group α
s✝ t s : Subgroup α
⊢ Nat.card α = Nat.card (α ⧸ s) * Nat.card ↥s
state_after: α : Type u_1
inst✝ : Group α
s✝ t s : Subgroup α
⊢ Nat.card α = Nat.card ((α ⧸ s) × ↥s)
tactic: rw [← Nat.card_prod]
state_before: α : Type u_1
inst✝ : Group α
s✝ t s : Subgroup α
⊢ Nat.card α = Nat.card ((α ⧸ s) × ↥s)
state_after: no goals
tactic: exact Nat.card_congr Subgroup.groupEquivQuotientProdSubgroup
Theorem: AffineSubspace.card_pos_of_affineSpan_eq_top
File: Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean

Proof steps:
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
S : AffineSpace V P
p₁ p₂ : P
ι : Type u_4
inst✝ : Fintype ι
p : ι → P
h : affineSpan k (range p) = ⊤
⊢ 0 < Fintype.card ι
state_after: case intro.intro
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
S : AffineSpace V P
p₁ p₂ : P
ι : Type u_4
inst✝ : Fintype ι
p : ι → P
h : affineSpan k (range p) = ⊤
i : ι
⊢ 0 < Fintype.card ι
tactic: obtain ⟨-, ⟨i, -⟩⟩ := nonempty_of_affineSpan_eq_top k V P h
state_before: case intro.intro
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
S : AffineSpace V P
p₁ p₂ : P
ι : Type u_4
inst✝ : Fintype ι
p : ι → P
h : affineSpan k (range p) = ⊤
i : ι
⊢ 0 < Fintype.card ι
state_after: no goals
tactic: exact Fintype.card_pos_iff.mpr ⟨i⟩