ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: sSup_mem_of_not_isSuccLimit
File: Mathlib/Order/SuccPred/CompleteLinearOrder.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
inst✝ : CompleteLinearOrder α
s : Set α
f : ι → α
x : α
hlim : ¬IsSuccLimit (sSup s)
⊢ sSup s ∈ s
state_after: case intro
ι : Type u_1
α : Type u_2
inst✝ : CompleteLinearOrder α
s : Set α
f : ι → α
x : α
hlim : ¬IsSuccLimit (sSup s)
y : α
hy : y ⋖ sSup s
⊢ sSup s ∈ s
tactic: obtain ⟨y, hy⟩ := not_forall_not.mp hlim
state_before: case intro
ι : Type u_1
α : Type u_2
inst✝ : CompleteLinearOrder α
s : Set α
f : ι → α
x : α
hlim : ¬IsSuccLimit (sSup s)
y : α
hy : y ⋖ sSup s
⊢ sSup s ∈ s
state_after: case intro.intro.intro
ι : Type u_1
α : Type u_2
inst✝ : CompleteLinearOrder α
s : Set α
f : ι → α
x : α
hlim : ¬IsSuccLimit (sSup s)
y : α
hy : y ⋖ sSup s
i : α
his : i ∈ s
hi : y < i
⊢ sSup s ∈ s
tactic: obtain ⟨i, his, hi⟩ := lt_sSup_iff.mp hy.lt
state_before: case intro.intro.intro
ι : Type u_1
α : Type u_2
inst✝ : CompleteLinearOrder α
s : Set α
f : ι → α
x : α
hlim : ¬IsSuccLimit (sSup s)
y : α
hy : y ⋖ sSup s
i : α
his : i ∈ s
hi : y < i
⊢ sSup s ∈ s
state_after: no goals
tactic: exact eq_of_le_of_not_lt (le_sSup his) (hy.2 hi) ▸ his
Theorem: neg_eq_of_add_eq_zero_left
File: Mathlib/Algebra/Group/Defs.lean

Proof steps:
state_before: G : Type u_1
inst✝ : DivisionMonoid G
a b : G
h : a * b = 1
⊢ b⁻¹ = a
state_after: no goals
tactic: rw [← inv_eq_of_mul_eq_one_right h, inv_inv]
Theorem: Finsupp.mem_support_onFinset
File: Mathlib/Data/Finsupp/Defs.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : Zero M
s : Finset α
f : α → M
hf : ∀ (a : α), f a ≠ 0 → a ∈ s
a : α
⊢ a ∈ (onFinset s f hf).support ↔ f a ≠ 0
state_after: no goals
tactic: rw [Finsupp.mem_support_iff, Finsupp.onFinset_apply]
Theorem: Matrix.det_nonsing_inv_mul_det
File: Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean

Proof steps:
state_before: l : Type u_1
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A B : Matrix n n α
h : IsUnit A.det
⊢ A⁻¹.det * A.det = 1
state_after: no goals
tactic: rw [← det_mul, A.nonsing_inv_mul h, det_one]
Theorem: EuclideanGeometry.mul_dist_eq_mul_dist_of_cospherical_of_angle_eq_pi
File: Mathlib/Geometry/Euclidean/Sphere/Power.lean

Proof steps:
state_before: V : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
P : Type u_2
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
a b c d p : P
h : Cospherical {a, b, c, d}
hapb : ∠ a p b = π
hcpd : ∠ c p d = π
⊢ dist a p * dist b p = dist c p * dist d p
state_after: case intro.intro.intro
V : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
P : Type u_2
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
a b c d p : P
h : Cospherical {a, b, c, d}
hapb : ∠ a p b = π
hcpd : ∠ c p d = π
k₁ : ℝ
left✝ : k₁ < 0
hab : b -ᵥ p = k₁ • (a -ᵥ p)
⊢ dist a p * dist b p = dist c p * dist d p
tactic: obtain ⟨-, k₁, _, hab⟩ := angle_eq_pi_iff.mp hapb
state_before: case intro.intro.intro
V : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
P : Type u_2
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
a b c d p : P
h : Cospherical {a, b, c, d}
hapb : ∠ a p b = π
hcpd : ∠ c p d = π
k₁ : ℝ
left✝ : k₁ < 0
hab : b -ᵥ p = k₁ • (a -ᵥ p)
⊢ dist a p * dist b p = dist c p * dist d p
state_after: case intro.intro.intro.intro.intro.intro
V : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
P : Type u_2
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
a b c d p : P
h : Cospherical {a, b, c, d}
hapb : ∠ a p b = π
hcpd : ∠ c p d = π
k₁ : ℝ
left✝¹ : k₁ < 0
hab : b -ᵥ p = k₁ • (a -ᵥ p)
k₂ : ℝ
left✝ : k₂ < 0
hcd : d -ᵥ p = k₂ • (c -ᵥ p)
⊢ dist a p * dist b p = dist c p * dist d p
tactic: obtain ⟨-, k₂, _, hcd⟩ := angle_eq_pi_iff.mp hcpd
state_before: case intro.intro.intro.intro.intro.intro
V : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
P : Type u_2
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
a b c d p : P
h : Cospherical {a, b, c, d}
hapb : ∠ a p b = π
hcpd : ∠ c p d = π
k₁ : ℝ
left✝¹ : k₁ < 0
hab : b -ᵥ p = k₁ • (a -ᵥ p)
k₂ : ℝ
left✝ : k₂ < 0
hcd : d -ᵥ p = k₂ • (c -ᵥ p)
⊢ dist a p * dist b p = dist c p * dist d p
state_after: no goals
tactic: exact mul_dist_eq_mul_dist_of_cospherical h ⟨k₁, by linarith, hab⟩ ⟨k₂, by linarith, hcd⟩
Theorem: CochainComplex.mappingCone.triangleRotateShortComplexSplitting_s
File: Mathlib/Algebra/Homology/HomotopyCategory/DegreewiseSplit.lean

Proof steps:
state_before: C : Type u_1
inst✝² : Category.{?u.284157, u_1} C
inst✝¹ : Preadditive C
S : ShortComplex (CochainComplex C ℤ)
σ : (n : ℤ) → (S.map (eval C (ComplexShape.up ℤ) n)).Splitting
inst✝ : HasBinaryBiproducts C
K L : CochainComplex C ℤ
φ : K ⟶ L
n : ℤ
⊢ n + 1 + -1 = n
state_after: no goals
tactic: omega
state_before: C : Type u_1
inst✝² : Category.{?u.284157, u_1} C
inst✝¹ : Preadditive C
S : ShortComplex (CochainComplex C ℤ)
σ : (n : ℤ) → (S.map (eval C (ComplexShape.up ℤ) n)).Splitting
inst✝ : HasBinaryBiproducts C
K L : CochainComplex C ℤ
φ : K ⟶ L
n : ℤ
⊢ (snd φ).v n n ⋯ ≫ ((triangleRotateShortComplex φ).map (eval C (ComplexShape.up ℤ) n)).f +
      ((triangleRotateShortComplex φ).map (eval C (ComplexShape.up ℤ) n)).g ≫ (-(inl φ).v (n + 1) n ⋯) =
    𝟙 ((triangleRotateShortComplex φ).map (eval C (ComplexShape.up ℤ) n)).X₂
state_after: no goals
tactic: simp [ext_from_iff φ _ _ rfl]
Theorem: Algebra.adjoin.powerBasis'_gen
File: Mathlib/FieldTheory/Minpoly/IsIntegrallyClosed.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
inst✝⁶ : CommRing R
inst✝⁵ : CommRing S
inst✝⁴ : IsDomain R
inst✝³ : Algebra R S
inst✝² : IsDomain S
inst✝¹ : NoZeroSMulDivisors R S
inst✝ : IsIntegrallyClosed R
x : S
hx : IsIntegral R x
⊢ (adjoin.powerBasis' hx).gen = ⟨x, ⋯⟩
state_after: no goals
tactic: rw [Algebra.adjoin.powerBasis', PowerBasis.map_gen, AdjoinRoot.powerBasis'_gen, equivAdjoin,
    AlgEquiv.ofBijective_apply, Minpoly.toAdjoin, liftHom_root]
Theorem: CategoryTheory.μ_inv_naturalityₗ
File: Mathlib/CategoryTheory/Monoidal/End.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
M : Type u_1
inst✝¹ : Category.{u_2, u_1} M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
m n m' : M
f : m ⟶ m'
X : C
⊢ (F.μIso m n).inv.app X ≫ (F.obj n).map ((F.map f).app X) = (F.map (f ▷ n)).app X ≫ (F.μIso m' n).inv.app X
state_after: C : Type u
inst✝² : Category.{v, u} C
M : Type u_1
inst✝¹ : Category.{u_2, u_1} M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
m n m' : M
f : m ⟶ m'
X : C
⊢ (F.obj n).map ((F.map f).app X) ≫ inv ((F.μIso m' n).inv.app X) = inv ((F.μIso m n).inv.app X) ≫ (F.map (f ▷ n)).app X
tactic: rw [← IsIso.comp_inv_eq, Category.assoc, ← IsIso.eq_inv_comp]
state_before: C : Type u
inst✝² : Category.{v, u} C
M : Type u_1
inst✝¹ : Category.{u_2, u_1} M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
m n m' : M
f : m ⟶ m'
X : C
⊢ (F.obj n).map ((F.map f).app X) ≫ inv ((F.μIso m' n).inv.app X) = inv ((F.μIso m n).inv.app X) ≫ (F.map (f ▷ n)).app X
state_after: no goals
tactic: simp
Theorem: SimpleGraph.Subgraph.map_sup
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

Proof steps:
state_before: ι : Sort u_1
V : Type u
W : Type v
G✝ : SimpleGraph V
G₁ G₂ : G✝.Subgraph
a b : V
G : SimpleGraph V
G' : SimpleGraph W
f : G →g G'
H H' : G.Subgraph
⊢ Subgraph.map f (H ⊔ H') = Subgraph.map f H ⊔ Subgraph.map f H'
state_after: case verts
ι : Sort u_1
V : Type u
W : Type v
G✝ : SimpleGraph V
G₁ G₂ : G✝.Subgraph
a b : V
G : SimpleGraph V
G' : SimpleGraph W
f : G →g G'
H H' : G.Subgraph
⊢ (Subgraph.map f (H ⊔ H')).verts = (Subgraph.map f H ⊔ Subgraph.map f H').verts

case Adj
ι : Sort u_1
V : Type u
W : Type v
G✝ : SimpleGraph V
G₁ G₂ : G✝.Subgraph
a b : V
G : SimpleGraph V
G' : SimpleGraph W
f : G →g G'
H H' : G.Subgraph
⊢ (Subgraph.map f (H ⊔ H')).Adj = (Subgraph.map f H ⊔ Subgraph.map f H').Adj
tactic: ext1
Theorem: isRelPrime_mul_unit_right_right
File: Mathlib/Algebra/Divisibility/Units.lean

Proof steps:
state_before: α : Type u_1
inst✝ : CommMonoid α
x y z : α
hu : IsUnit x
⊢ IsRelPrime y (z * x) ↔ IsRelPrime y z
state_after: no goals
tactic: rw [mul_comm, isRelPrime_mul_unit_left_right hu]
Theorem: isExtreme_singleton
File: Mathlib/Analysis/Convex/Extreme.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
ι : Type u_4
π : ι → Type u_5
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommMonoid E
inst✝ : SMul 𝕜 E
A B C : Set E
x : E
⊢ IsExtreme 𝕜 A {x} ↔ x ∈ extremePoints 𝕜 A
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
ι : Type u_4
π : ι → Type u_5
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommMonoid E
inst✝ : SMul 𝕜 E
A B C : Set E
x : E
⊢ x ∈ extremePoints 𝕜 A → IsExtreme 𝕜 A {x}
tactic: refine ⟨fun hx ↦ ⟨singleton_subset_iff.1 hx.1, fun x₁ hx₁ x₂ hx₂ ↦ hx.2 hx₁ hx₂ rfl⟩, ?_⟩
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
ι : Type u_4
π : ι → Type u_5
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommMonoid E
inst✝ : SMul 𝕜 E
A B C : Set E
x : E
⊢ x ∈ extremePoints 𝕜 A → IsExtreme 𝕜 A {x}
state_after: case intro
𝕜 : Type u_1
E : Type u_2
F : Type u_3
ι : Type u_4
π : ι → Type u_5
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommMonoid E
inst✝ : SMul 𝕜 E
A B C : Set E
x : E
hxA : x ∈ A
hAx : ∀ ⦃x₁ : E⦄, x₁ ∈ A → ∀ ⦃x₂ : E⦄, x₂ ∈ A → x ∈ openSegment 𝕜 x₁ x₂ → x₁ = x ∧ x₂ = x
⊢ IsExtreme 𝕜 A {x}
tactic: rintro ⟨hxA, hAx⟩
state_before: case intro
𝕜 : Type u_1
E : Type u_2
F : Type u_3
ι : Type u_4
π : ι → Type u_5
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommMonoid E
inst✝ : SMul 𝕜 E
A B C : Set E
x : E
hxA : x ∈ A
hAx : ∀ ⦃x₁ : E⦄, x₁ ∈ A → ∀ ⦃x₂ : E⦄, x₂ ∈ A → x ∈ openSegment 𝕜 x₁ x₂ → x₁ = x ∧ x₂ = x
⊢ IsExtreme 𝕜 A {x}
state_after: case right
𝕜 : Type u_1
E : Type u_2
F : Type u_3
ι : Type u_4
π : ι → Type u_5
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommMonoid E
inst✝ : SMul 𝕜 E
A B C : Set E
x : E
hxA : x ∈ A
hAx : ∀ ⦃x₁ : E⦄, x₁ ∈ A → ∀ ⦃x₂ : E⦄, x₂ ∈ A → x ∈ openSegment 𝕜 x₁ x₂ → x₁ = x ∧ x₂ = x
⊢ ∀ ⦃x₁ : E⦄, x₁ ∈ A → ∀ ⦃x₂ : E⦄, x₂ ∈ A → ∀ ⦃x_1 : E⦄, x_1 ∈ {x} → x_1 ∈ openSegment 𝕜 x₁ x₂ → x₁ ∈ {x} ∧ x₂ ∈ {x}
tactic: use singleton_subset_iff.2 hxA
state_before: case right
𝕜 : Type u_1
E : Type u_2
F : Type u_3
ι : Type u_4
π : ι → Type u_5
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommMonoid E
inst✝ : SMul 𝕜 E
A B C : Set E
x : E
hxA : x ∈ A
hAx : ∀ ⦃x₁ : E⦄, x₁ ∈ A → ∀ ⦃x₂ : E⦄, x₂ ∈ A → x ∈ openSegment 𝕜 x₁ x₂ → x₁ = x ∧ x₂ = x
⊢ ∀ ⦃x₁ : E⦄, x₁ ∈ A → ∀ ⦃x₂ : E⦄, x₂ ∈ A → ∀ ⦃x_1 : E⦄, x_1 ∈ {x} → x_1 ∈ openSegment 𝕜 x₁ x₂ → x₁ ∈ {x} ∧ x₂ ∈ {x}
state_after: case right
𝕜 : Type u_1
E : Type u_2
F : Type u_3
ι : Type u_4
π : ι → Type u_5
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommMonoid E
inst✝ : SMul 𝕜 E
A B C : Set E
x₁ : E
hx₁A : x₁ ∈ A
x₂ : E
hx₂A : x₂ ∈ A
y : E
hxA : y ∈ A
hAx : ∀ ⦃x₁ : E⦄, x₁ ∈ A → ∀ ⦃x₂ : E⦄, x₂ ∈ A → y ∈ openSegment 𝕜 x₁ x₂ → x₁ = y ∧ x₂ = y
⊢ y ∈ openSegment 𝕜 x₁ x₂ → x₁ ∈ {y} ∧ x₂ ∈ {y}
tactic: rintro x₁ hx₁A x₂ hx₂A y (rfl : y = x)
state_before: case right
𝕜 : Type u_1
E : Type u_2
F : Type u_3
ι : Type u_4
π : ι → Type u_5
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommMonoid E
inst✝ : SMul 𝕜 E
A B C : Set E
x₁ : E
hx₁A : x₁ ∈ A
x₂ : E
hx₂A : x₂ ∈ A
y : E
hxA : y ∈ A
hAx : ∀ ⦃x₁ : E⦄, x₁ ∈ A → ∀ ⦃x₂ : E⦄, x₂ ∈ A → y ∈ openSegment 𝕜 x₁ x₂ → x₁ = y ∧ x₂ = y
⊢ y ∈ openSegment 𝕜 x₁ x₂ → x₁ ∈ {y} ∧ x₂ ∈ {y}
state_after: no goals
tactic: exact hAx hx₁A hx₂A
Theorem: cauchySeq_shift
File: Mathlib/Topology/UniformSpace/Cauchy.lean

Proof steps:
state_before: α : Type u
β : Type v
uniformSpace : UniformSpace α
u : ℕ → α
k : ℕ
⊢ (CauchySeq fun n => u (n + k)) ↔ CauchySeq u
state_after: case mp
α : Type u
β : Type v
uniformSpace : UniformSpace α
u : ℕ → α
k : ℕ
h : CauchySeq fun n => u (n + k)
⊢ CauchySeq u

case mpr
α : Type u
β : Type v
uniformSpace : UniformSpace α
u : ℕ → α
k : ℕ
h : CauchySeq u
⊢ CauchySeq fun n => u (n + k)
tactic: constructor <;> intro h
Theorem: MeasureTheory.Conservative.id
File: Mathlib/Dynamics/Ergodic/Conservative.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
inst✝ : MeasurableSpace α
f : α → α
s : Set α
μ✝ μ : Measure α
x✝¹ : Set α
x✝ : MeasurableSet x✝¹
h0 : μ x✝¹ ≠ 0
⊢ ∃ x ∈ x✝¹, ∃ m, m ≠ 0 ∧ id^[m] x ∈ x✝¹
state_after: no goals
tactic: simpa [exists_ne] using nonempty_of_measure_ne_zero h0
Theorem: HasDerivAtFilter.sub_const
File: Mathlib/Analysis/Calculus/Deriv/Add.lean

Proof steps:
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L : Filter 𝕜
hf : HasDerivAtFilter f f' x L
c : F
⊢ HasDerivAtFilter (fun x => f x - c) f' x L
state_after: no goals
tactic: simpa only [sub_eq_add_neg] using hf.add_const (-c)
Theorem: CategoryTheory.eqToHom_map_comp
File: Mathlib/CategoryTheory/EqToHom.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
β : Sort u_1
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
p : X = Y
q : Y = Z
⊢ F.map (eqToHom p) ≫ F.map (eqToHom q) = F.map (eqToHom ⋯)
state_after: no goals
tactic: aesop_cat
Theorem: Filter.nhds_top
File: Mathlib/Topology/Filter.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
X : Type u_4
Y : Type u_5
⊢ 𝓝 ⊤ = ⊤
state_after: no goals
tactic: simp [nhds_eq]
Theorem: Set.offDiag_insert
File: Mathlib/Data/Set/Prod.lean

Proof steps:
state_before: α : Type u_1
s t : Set α
x : α × α
a : α
ha : a ∉ s
⊢ (insert a s).offDiag = s.offDiag ∪ {a} ×ˢ s ∪ s ×ˢ {a}
state_after: α : Type u_1
s t : Set α
x : α × α
a : α
ha : a ∉ s
⊢ Disjoint s {a}
tactic: rw [insert_eq, union_comm, offDiag_union, offDiag_singleton, union_empty, union_right_comm]
state_before: α : Type u_1
s t : Set α
x : α × α
a : α
ha : a ∉ s
⊢ Disjoint s {a}
state_after: α : Type u_1
s t : Set α
x : α × α
a : α
ha : a ∉ s
⊢ ∀ ⦃a_1 : α⦄, a_1 ∈ s → a_1 ∉ {a}
tactic: rw [disjoint_left]
state_before: α : Type u_1
s t : Set α
x : α × α
a : α
ha : a ∉ s
⊢ ∀ ⦃a_1 : α⦄, a_1 ∈ s → a_1 ∉ {a}
state_after: α : Type u_1
s t : Set α
x : α × α
b : α
hb : b ∈ s
ha : b ∉ s
⊢ False
tactic: rintro b hb (rfl : b = a)
state_before: α : Type u_1
s t : Set α
x : α × α
b : α
hb : b ∈ s
ha : b ∉ s
⊢ False
state_after: no goals
tactic: exact ha hb
Theorem: Filter.tendstoIxxClass_principal
File: Mathlib/Order/Filter/Interval.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : Preorder α
s t : Set α
Ixx : α → α → Set α
⊢ Tendsto (fun p => Ixx p.1 p.2) (𝓟 s ×ˢ 𝓟 s) (𝓟 t).smallSets ↔ ∀ x ∈ s, ∀ y ∈ s, Ixx x y ⊆ t
state_after: no goals
tactic: simp only [smallSets_principal, prod_principal_principal, tendsto_principal_principal,
      forall_prod_set, mem_powerset_iff, mem_principal]
Theorem: Mathlib.Tactic.Abel.const_add_termg
File: Mathlib/Tactic/Abel.lean

Proof steps:
state_before: α : Type u_1
inst✝ : AddCommGroup α
k : α
n : ℤ
x a a' : α
h : k + a = a'
⊢ k + termg n x a = termg n x a'
state_after: no goals
tactic: simp [h.symm, termg, add_comm, add_assoc]
Theorem: integral_sin_pow_pos
File: Mathlib/Analysis/SpecialFunctions/Integrals.lean

Proof steps:
state_before: a b : ℝ
n : ℕ
⊢ 0 < ∫ (x : ℝ) in 0 ..π, sin x ^ n
state_after: no goals
tactic: rcases even_or_odd' n with ⟨k, rfl | rfl⟩ <;>
  simp only [integral_sin_pow_even, integral_sin_pow_odd] <;>
  refine mul_pos (by norm_num [pi_pos]) (prod_pos fun n _ => div_pos ?_ ?_) <;>
  norm_cast <;>
  omega
Theorem: strongConcaveOn_iff_convex
File: Mathlib/Analysis/Convex/Strong.lean

Proof steps:
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace ℝ E
φ ψ : ℝ → ℝ
s : Set E
a b m : ℝ
x y : E
f : E → ℝ
⊢ StrongConcaveOn s m f ↔ ConcaveOn ℝ s fun x => f x + m / 2 * ‖x‖ ^ 2
state_after: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace ℝ E
φ ψ : ℝ → ℝ
s : Set E
a✝ b✝ m : ℝ
x✝³ y✝ : E
f : E → ℝ
x✝² : Convex ℝ s
x : E
x✝¹ : x ∈ s
y : E
x✝ : y ∈ s
a b : ℝ
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
⊢ a • f x + b • f y + a * b * (fun r => m / 2 * r ^ 2) ‖x - y‖ ≤ f (a • x + b • y) ↔
    a • (fun x => f x + m / 2 * ‖x‖ ^ 2) x + b • (fun x => f x + m / 2 * ‖x‖ ^ 2) y ≤
      (fun x => f x + m / 2 * ‖x‖ ^ 2) (a • x + b • y)
tactic: refine and_congr_right fun _ ↦ forall₄_congr fun x _ y _ ↦ forall₅_congr fun a b ha hb hab ↦ ?_
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace ℝ E
φ ψ : ℝ → ℝ
s : Set E
a✝ b✝ m : ℝ
x✝³ y✝ : E
f : E → ℝ
x✝² : Convex ℝ s
x : E
x✝¹ : x ∈ s
y : E
x✝ : y ∈ s
a b : ℝ
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
⊢ a • f x + b • f y + a * b * (fun r => m / 2 * r ^ 2) ‖x - y‖ ≤ f (a • x + b • y) ↔
    a • (fun x => f x + m / 2 * ‖x‖ ^ 2) x + b • (fun x => f x + m / 2 * ‖x‖ ^ 2) y ≤
      (fun x => f x + m / 2 * ‖x‖ ^ 2) (a • x + b • y)
state_after: no goals
tactic: simp_rw [← sub_le_iff_le_add, smul_eq_mul, aux_add ha hb hab, mul_assoc, mul_left_comm]
Theorem: List.mem_of_nextOr_ne
File: Mathlib/Data/List/Cycle.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
xs : List α
x d : α
h : xs.nextOr x d ≠ d
⊢ x ∈ xs
state_after: case nil
α : Type u_1
inst✝ : DecidableEq α
x d : α
h : [].nextOr x d ≠ d
⊢ x ∈ []

case cons
α : Type u_1
inst✝ : DecidableEq α
x d y : α
ys : List α
IH : ys.nextOr x d ≠ d → x ∈ ys
h : (y :: ys).nextOr x d ≠ d
⊢ x ∈ y :: ys
tactic: induction' xs with y ys IH
state_before: case cons
α : Type u_1
inst✝ : DecidableEq α
x d y : α
ys : List α
IH : ys.nextOr x d ≠ d → x ∈ ys
h : (y :: ys).nextOr x d ≠ d
⊢ x ∈ y :: ys
state_after: case cons.nil
α : Type u_1
inst✝ : DecidableEq α
x d y : α
IH : [].nextOr x d ≠ d → x ∈ []
h : [y].nextOr x d ≠ d
⊢ x ∈ [y]

case cons.cons
α : Type u_1
inst✝ : DecidableEq α
x d y z : α
zs : List α
IH : (z :: zs).nextOr x d ≠ d → x ∈ z :: zs
h : (y :: z :: zs).nextOr x d ≠ d
⊢ x ∈ y :: z :: zs
tactic: cases' ys with z zs
Theorem: Matrix.J_transpose
File: Mathlib/LinearAlgebra/SymplecticGroup.lean

Proof steps:
state_before: l : Type u_1
R : Type u_2
inst✝¹ : DecidableEq l
inst✝ : CommRing R
⊢ (J l R)ᵀ = -J l R
state_after: l : Type u_1
R : Type u_2
inst✝¹ : DecidableEq l
inst✝ : CommRing R
⊢ fromBlocks 0 1 (-1ᵀ) 0 = fromBlocks (-1 • 0) (-1 • -1) (-1 • 1) (-1 • 0)
tactic: rw [J, fromBlocks_transpose, ← neg_one_smul R (fromBlocks _ _ _ _ : Matrix (l ⊕ l) (l ⊕ l) R),
    fromBlocks_smul, Matrix.transpose_zero, Matrix.transpose_one, transpose_neg]
state_before: l : Type u_1
R : Type u_2
inst✝¹ : DecidableEq l
inst✝ : CommRing R
⊢ fromBlocks 0 1 (-1ᵀ) 0 = fromBlocks (-1 • 0) (-1 • -1) (-1 • 1) (-1 • 0)
state_after: no goals
tactic: simp [fromBlocks]
Theorem: Finset.uIcc_self
File: Mathlib/Order/Interval/Finset/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : Lattice α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
⊢ [[a, a]] = {a}
state_after: no goals
tactic: simp [uIcc]
Theorem: Squarefree.ne_zero
File: Mathlib/Algebra/Squarefree/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝¹ : MonoidWithZero R
inst✝ : Nontrivial R
m : R
hm : Squarefree m
⊢ m ≠ 0
state_after: R : Type u_1
inst✝¹ : MonoidWithZero R
inst✝ : Nontrivial R
hm : Squarefree 0
⊢ False
tactic: rintro rfl
state_before: R : Type u_1
inst✝¹ : MonoidWithZero R
inst✝ : Nontrivial R
hm : Squarefree 0
⊢ False
state_after: no goals
tactic: exact not_squarefree_zero hm
Theorem: Finset.prod_finset_product_right
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

Proof steps:
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝ : CommMonoid β
r : Finset (α × γ)
s : Finset γ
t : γ → Finset α
h : ∀ (p : α × γ), p ∈ r ↔ p.2 ∈ s ∧ p.1 ∈ t p.2
f : α × γ → β
⊢ ∏ p ∈ r, f p = ∏ c ∈ s, ∏ a ∈ t c, f (a, c)
state_after: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝ : CommMonoid β
r : Finset (α × γ)
s : Finset γ
t : γ → Finset α
h : ∀ (p : α × γ), p ∈ r ↔ p.2 ∈ s ∧ p.1 ∈ t p.2
f : α × γ → β
⊢ ∏ p ∈ r, f p = ∏ x ∈ s.sigma t, f (x.snd, x.fst)
tactic: refine Eq.trans ?_ (prod_sigma s t fun p => f (p.2, p.1))
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝ : CommMonoid β
r : Finset (α × γ)
s : Finset γ
t : γ → Finset α
h : ∀ (p : α × γ), p ∈ r ↔ p.2 ∈ s ∧ p.1 ∈ t p.2
f : α × γ → β
⊢ ∏ p ∈ r, f p = ∏ x ∈ s.sigma t, f (x.snd, x.fst)
state_after: no goals
tactic: apply prod_equiv ((Equiv.prodComm _ _).trans (Equiv.sigmaEquivProd _ _).symm) <;> simp [h]
Theorem: GenContFract.exists_s_a_of_partNum
File: Mathlib/Algebra/ContinuedFractions/Translations.lean

Proof steps:
state_before: α : Type u_1
g : GenContFract α
n : ℕ
a : α
nth_partNum_eq : g.partNums.get? n = some a
⊢ ∃ gp, g.s.get? n = some gp ∧ gp.a = a
state_after: no goals
tactic: simpa [partNums, Stream'.Seq.map_get?] using nth_partNum_eq
Theorem: FractionalIdeal.map_inv
File: Mathlib/RingTheory/DedekindDomain/Ideal.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
K : Type u_3
inst✝⁹ : CommRing R
inst✝⁸ : CommRing A
inst✝⁷ : Field K
R₁ : Type u_4
inst✝⁶ : CommRing R₁
inst✝⁵ : IsDomain R₁
inst✝⁴ : Algebra R₁ K
inst✝³ : IsFractionRing R₁ K
I✝ J : FractionalIdeal R₁⁰ K
K' : Type u_5
inst✝² : Field K'
inst✝¹ : Algebra R₁ K'
inst✝ : IsFractionRing R₁ K'
I : FractionalIdeal R₁⁰ K
h : K ≃ₐ[R₁] K'
⊢ map (↑h) I⁻¹ = (map (↑h) I)⁻¹
state_after: no goals
tactic: rw [inv_eq, map_div, map_one, inv_eq]
Theorem: lowerSemicontinuous_iff_le_liminf
File: Mathlib/Topology/Semicontinuous.lean

Proof steps:
state_before: α : Type u_1
inst✝³ : TopologicalSpace α
β : Type u_2
inst✝² : Preorder β
f✝ g : α → β
x : α
s t : Set α
y z : β
γ : Type u_3
inst✝¹ : CompleteLinearOrder γ
inst✝ : DenselyOrdered γ
f : α → γ
⊢ LowerSemicontinuous f ↔ ∀ (x : α), f x ≤ liminf f (𝓝 x)
state_after: no goals
tactic: simp only [← lowerSemicontinuousAt_iff_le_liminf, LowerSemicontinuous]
Theorem: IsLocallyClosed.image
File: Mathlib/Topology/LocallyClosed.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s✝ t : Set X
f✝ : X → Y
s : Set X
hs : IsLocallyClosed s
f : X → Y
hf : Inducing f
hf' : IsLocallyClosed (range f)
⊢ IsLocallyClosed (f '' s)
state_after: case intro.intro
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t✝ : Set X
f✝ f : X → Y
hf : Inducing f
hf' : IsLocallyClosed (range f)
t : Set Y
ht : IsLocallyClosed t
hs : IsLocallyClosed (f ⁻¹' t)
⊢ IsLocallyClosed (f '' (f ⁻¹' t))
tactic: obtain ⟨t, ht, rfl⟩ := hf.isLocallyClosed_iff.mp hs
state_before: case intro.intro
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t✝ : Set X
f✝ f : X → Y
hf : Inducing f
hf' : IsLocallyClosed (range f)
t : Set Y
ht : IsLocallyClosed t
hs : IsLocallyClosed (f ⁻¹' t)
⊢ IsLocallyClosed (f '' (f ⁻¹' t))
state_after: case intro.intro
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t✝ : Set X
f✝ f : X → Y
hf : Inducing f
hf' : IsLocallyClosed (range f)
t : Set Y
ht : IsLocallyClosed t
hs : IsLocallyClosed (f ⁻¹' t)
⊢ IsLocallyClosed (t ∩ range f)
tactic: rw [image_preimage_eq_inter_range]
state_before: case intro.intro
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t✝ : Set X
f✝ f : X → Y
hf : Inducing f
hf' : IsLocallyClosed (range f)
t : Set Y
ht : IsLocallyClosed t
hs : IsLocallyClosed (f ⁻¹' t)
⊢ IsLocallyClosed (t ∩ range f)
state_after: no goals
tactic: exact ht.inter hf'
Theorem: Ordinal.card_eq_one
File: Mathlib/SetTheory/Ordinal/Basic.lean

Proof steps:
state_before: α : Type u
β : Type u_1
γ : Type u_2
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u_3}
⊢ o.card = 1 ↔ o = 1
state_after: no goals
tactic: simpa using card_eq_nat (n := 1)
Theorem: Set.preimage_sub_const_Ico
File: Mathlib/Data/Set/Pointwise/Interval.lean

Proof steps:
state_before: α : Type u_1
inst✝ : OrderedAddCommGroup α
a b c : α
⊢ (fun x => x - a) ⁻¹' Ico b c = Ico (b + a) (c + a)
state_after: no goals
tactic: simp [sub_eq_add_neg]