ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Topology.lawsonClosed_iff_dirSupClosed_of_isLowerSet
File: Mathlib/Topology/Order/LawsonTopology.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : Preorder α
L S : TopologicalSpace α
inst✝¹ : IsLawson α
inst✝ : IsScott α
s : Set α
h : IsLowerSet s
⊢ IsClosed s ↔ DirSupClosed s
state_after: α : Type u_1
β : Type u_2
inst✝² : Preorder α
L S : TopologicalSpace α
inst✝¹ : IsLawson α
inst✝ : IsScott α
s : Set α
h : IsLowerSet s
⊢ IsLowerSet s ∧ DirSupClosed s ↔ DirSupClosed s
tactic: rw [(lawsonClosed_iff_scottClosed_of_isLowerSet L S _ h),
    @IsScott.isClosed_iff_isLowerSet_and_dirSupClosed]
state_before: α : Type u_1
β : Type u_2
inst✝² : Preorder α
L S : TopologicalSpace α
inst✝¹ : IsLawson α
inst✝ : IsScott α
s : Set α
h : IsLowerSet s
⊢ IsLowerSet s ∧ DirSupClosed s ↔ DirSupClosed s
state_after: no goals
tactic: aesop
Theorem: PNat.card_fintype_uIcc
File: Mathlib/Data/PNat/Interval.lean

Proof steps:
state_before: a b : ℕ+
⊢ Fintype.card ↑(Set.uIcc a b) = (↑↑b - ↑↑a).natAbs + 1
state_after: no goals
tactic: rw [← card_uIcc, Fintype.card_ofFinset]
Theorem: List.perm_option_to_list
File: Mathlib/Data/List/Perm.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
l l₁ l₂ : List α
a : α
o₁ o₂ : Option α
⊢ o₁.toList ~ o₂.toList ↔ o₁ = o₂
state_after: α : Type u_1
β : Type u_2
l l₁ l₂ : List α
a : α
o₁ o₂ : Option α
p : o₁.toList ~ o₂.toList
⊢ o₁ = o₂
tactic: refine ⟨fun p => ?_, fun e => e ▸ Perm.refl _⟩
state_before: α : Type u_1
β : Type u_2
l l₁ l₂ : List α
a : α
o₁ o₂ : Option α
p : o₁.toList ~ o₂.toList
⊢ o₁ = o₂
state_after: case none.none
α : Type u_1
β : Type u_2
l l₁ l₂ : List α
a : α
p : none.toList ~ none.toList
⊢ none = none

case none.some
α : Type u_1
β : Type u_2
l l₁ l₂ : List α
a b : α
p : none.toList ~ (some b).toList
⊢ none = some b

case some.none
α : Type u_1
β : Type u_2
l l₁ l₂ : List α
a✝ a : α
p : (some a).toList ~ none.toList
⊢ some a = none

case some.some
α : Type u_1
β : Type u_2
l l₁ l₂ : List α
a✝ a b : α
p : (some a).toList ~ (some b).toList
⊢ some a = some b
tactic: cases' o₁ with a <;> cases' o₂ with b
Theorem: SetTheory.PGame.zero_lt_neg_iff
File: Mathlib/SetTheory/Game/PGame.lean

Proof steps:
state_before: xl xr : Type u
x : PGame
⊢ 0 < -x ↔ x < 0
state_after: no goals
tactic: rw [lt_neg_iff, neg_zero]
Theorem: Hyperreal.st_inv
File: Mathlib/Data/Real/Hyperreal.lean

Proof steps:
state_before: x : ℝ*
⊢ x⁻¹.st = x.st⁻¹
state_after: case pos
x : ℝ*
h0 : x = 0
⊢ x⁻¹.st = x.st⁻¹

case neg
x : ℝ*
h0 : ¬x = 0
⊢ x⁻¹.st = x.st⁻¹
tactic: by_cases h0 : x = 0
state_before: case neg
x : ℝ*
h0 : ¬x = 0
⊢ x⁻¹.st = x.st⁻¹
state_after: case pos
x : ℝ*
h0 : ¬x = 0
h1 : x.Infinitesimal
⊢ x⁻¹.st = x.st⁻¹

case neg
x : ℝ*
h0 : ¬x = 0
h1 : ¬x.Infinitesimal
⊢ x⁻¹.st = x.st⁻¹
tactic: by_cases h1 : Infinitesimal x
state_before: case neg
x : ℝ*
h0 : ¬x = 0
h1 : ¬x.Infinitesimal
⊢ x⁻¹.st = x.st⁻¹
state_after: case pos
x : ℝ*
h0 : ¬x = 0
h1 : ¬x.Infinitesimal
h2 : x.Infinite
⊢ x⁻¹.st = x.st⁻¹

case neg
x : ℝ*
h0 : ¬x = 0
h1 : ¬x.Infinitesimal
h2 : ¬x.Infinite
⊢ x⁻¹.st = x.st⁻¹
tactic: by_cases h2 : Infinite x
state_before: case neg
x : ℝ*
h0 : ¬x = 0
h1 : ¬x.Infinitesimal
h2 : ¬x.Infinite
⊢ x⁻¹.st = x.st⁻¹
state_after: no goals
tactic: exact ((isSt_st' h2).inv h1).st_eq
Theorem: Rel.comp_right_top
File: Mathlib/Data/Rel.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r✝ r : Rel α β
⊢ r • ⊤ = fun x x_1 => x ∈ r.dom
state_after: case a.h.a
α : Type u_1
β : Type u_2
γ : Type u_3
r✝ r : Rel α β
x : α
z : γ
⊢ (r • ⊤) x z ↔ x ∈ r.dom
tactic: ext x z
state_before: case a.h.a
α : Type u_1
β : Type u_2
γ : Type u_3
r✝ r : Rel α β
x : α
z : γ
⊢ (r • ⊤) x z ↔ x ∈ r.dom
state_after: no goals
tactic: simp [comp, Top.top, dom]
Theorem: Turing.reaches_eval
File: Mathlib/Computability/TuringMachine.lean

Proof steps:
state_before: σ : Type u_1
f : σ → Option σ
a b : σ
ab : Reaches f a b
⊢ eval f a = eval f b
state_after: case refine_1
σ : Type u_1
f : σ → Option σ
a b : σ
ab : Reaches f a b
x✝ : σ
h : x✝ ∈ eval f a
⊢ x✝ ∈ eval f b

case refine_2
σ : Type u_1
f : σ → Option σ
a b : σ
ab : Reaches f a b
x✝ : σ
h : x✝ ∈ eval f b
⊢ x✝ ∈ eval f a
tactic: refine Part.ext fun _ ↦ ⟨fun h ↦ ?_, fun h ↦ ?_⟩
Theorem: HomologicalComplex.ExactAt.of_iso
File: Mathlib/Algebra/Homology/ShortComplex/HomologicalComplex.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{u_3, u_1} C
inst✝ : HasZeroMorphisms C
ι : Type u_2
c : ComplexShape ι
K L✝ : HomologicalComplex C c
i j k : ι
hK : K.ExactAt i
L : HomologicalComplex C c
e : K ≅ L
⊢ L.ExactAt i
state_after: C : Type u_1
inst✝¹ : Category.{u_3, u_1} C
inst✝ : HasZeroMorphisms C
ι : Type u_2
c : ComplexShape ι
K L✝ : HomologicalComplex C c
i j k : ι
hK : (K.sc i).Exact
L : HomologicalComplex C c
e : K ≅ L
⊢ (L.sc i).Exact
tactic: rw [exactAt_iff] at hK ⊢
state_before: C : Type u_1
inst✝¹ : Category.{u_3, u_1} C
inst✝ : HasZeroMorphisms C
ι : Type u_2
c : ComplexShape ι
K L✝ : HomologicalComplex C c
i j k : ι
hK : (K.sc i).Exact
L : HomologicalComplex C c
e : K ≅ L
⊢ (L.sc i).Exact
state_after: no goals
tactic: exact ShortComplex.exact_of_iso ((shortComplexFunctor C c i).mapIso e) hK
Theorem: Ordinal.lt_sup
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
ι : Type u
f : ι → Ordinal.{max u v}
a : Ordinal.{max u v}
⊢ a < sup f ↔ ∃ i, a < f i
state_after: no goals
tactic: simpa only [not_forall, not_le] using not_congr (@sup_le_iff.{_, v} _ f a)
Theorem: CategoryTheory.Limits.pullbackZeroZeroIso_hom_fst
File: Mathlib/CategoryTheory/Limits/Constructions/ZeroObjects.lean

Proof steps:
state_before: C : Type u_1
inst✝³ : Category.{u_2, u_1} C
inst✝² : HasZeroObject C
inst✝¹ : HasZeroMorphisms C
X Y : C
inst✝ : HasBinaryProduct X Y
⊢ (pullbackZeroZeroIso X Y).hom ≫ prod.fst = pullback.fst 0 0
state_after: no goals
tactic: simp [← Iso.eq_inv_comp]
Theorem: Set.image_preimage_inter
File: Mathlib/Data/Set/Image.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : α → β
s✝ t✝ : Set α
f : α → β
s : Set α
t : Set β
⊢ f '' (f ⁻¹' t ∩ s) = t ∩ f '' s
state_after: no goals
tactic: simp only [inter_comm, image_inter_preimage]
Theorem: _private.Mathlib.RingTheory.MvPolynomial.NewtonIdentities.0.MvPolynomial.NewtonIdentities.pairMap_mem_pairs
File: Mathlib/RingTheory/MvPolynomial/NewtonIdentities.lean

Proof steps:
state_before: σ : Type u_1
inst✝² : Fintype σ
inst✝¹ : DecidableEq σ
R : Type u_2
inst✝ : CommRing R
k : ℕ
t : Finset σ × σ
h : t ∈ MvPolynomial.NewtonIdentities.pairs σ k
⊢ MvPolynomial.NewtonIdentities.pairMap σ t ∈ MvPolynomial.NewtonIdentities.pairs σ k
state_after: σ : Type u_1
inst✝² : Fintype σ
inst✝¹ : DecidableEq σ
R : Type u_2
inst✝ : CommRing R
k : ℕ
t : Finset σ × σ
h : t.1.card ≤ k ∧ (t.1.card = k → t.2 ∈ t.1)
⊢ (MvPolynomial.NewtonIdentities.pairMap σ t).1.card ≤ k ∧
    ((MvPolynomial.NewtonIdentities.pairMap σ t).1.card = k →
      (MvPolynomial.NewtonIdentities.pairMap σ t).2 ∈ (MvPolynomial.NewtonIdentities.pairMap σ t).1)
tactic: rw [mem_pairs] at h ⊢
state_before: σ : Type u_1
inst✝² : Fintype σ
inst✝¹ : DecidableEq σ
R : Type u_2
inst✝ : CommRing R
k : ℕ
t : Finset σ × σ
h : t.1.card ≤ k ∧ (t.1.card = k → t.2 ∈ t.1)
⊢ (MvPolynomial.NewtonIdentities.pairMap σ t).1.card ≤ k ∧
    ((MvPolynomial.NewtonIdentities.pairMap σ t).1.card = k →
      (MvPolynomial.NewtonIdentities.pairMap σ t).2 ∈ (MvPolynomial.NewtonIdentities.pairMap σ t).1)
state_after: case inl
σ : Type u_1
inst✝² : Fintype σ
inst✝¹ : DecidableEq σ
R : Type u_2
inst✝ : CommRing R
k : ℕ
t : Finset σ × σ
h : t.1.card ≤ k ∧ (t.1.card = k → t.2 ∈ t.1)
h1 : t.2 ∈ t.1
⊢ (MvPolynomial.NewtonIdentities.pairMap σ t).1.card ≤ k ∧
    ((MvPolynomial.NewtonIdentities.pairMap σ t).1.card = k →
      (MvPolynomial.NewtonIdentities.pairMap σ t).2 ∈ (MvPolynomial.NewtonIdentities.pairMap σ t).1)

case inr
σ : Type u_1
inst✝² : Fintype σ
inst✝¹ : DecidableEq σ
R : Type u_2
inst✝ : CommRing R
k : ℕ
t : Finset σ × σ
h : t.1.card ≤ k ∧ (t.1.card = k → t.2 ∈ t.1)
h1 : t.2 ∉ t.1
⊢ (MvPolynomial.NewtonIdentities.pairMap σ t).1.card ≤ k ∧
    ((MvPolynomial.NewtonIdentities.pairMap σ t).1.card = k →
      (MvPolynomial.NewtonIdentities.pairMap σ t).2 ∈ (MvPolynomial.NewtonIdentities.pairMap σ t).1)
tactic: rcases (em (t.snd ∈ t.fst)) with h1 | h1
Theorem: Subring.unop_closure
File: Mathlib/Algebra/Ring/Subring/MulOpposite.lean

Proof steps:
state_before: ι : Sort u_1
R : Type u_2
inst✝ : Ring R
s : Set Rᵐᵒᵖ
⊢ (closure s).unop = closure (MulOpposite.op ⁻¹' s)
state_after: ι : Sort u_1
R : Type u_2
inst✝ : Ring R
s : Set Rᵐᵒᵖ
⊢ sInf {a | s ⊆ MulOpposite.unop ⁻¹' ↑a} = sInf {S | MulOpposite.op ⁻¹' s ⊆ ↑S}
tactic: simp_rw [closure, unop_sInf, Set.preimage_setOf_eq, op_coe]
state_before: ι : Sort u_1
R : Type u_2
inst✝ : Ring R
s : Set Rᵐᵒᵖ
⊢ sInf {a | s ⊆ MulOpposite.unop ⁻¹' ↑a} = sInf {S | MulOpposite.op ⁻¹' s ⊆ ↑S}
state_after: case e_a.h
ι : Sort u_1
R : Type u_2
inst✝ : Ring R
s : Set Rᵐᵒᵖ
a : Subring R
⊢ a ∈ {a | s ⊆ MulOpposite.unop ⁻¹' ↑a} ↔ a ∈ {S | MulOpposite.op ⁻¹' s ⊆ ↑S}
tactic: congr with a
state_before: case e_a.h
ι : Sort u_1
R : Type u_2
inst✝ : Ring R
s : Set Rᵐᵒᵖ
a : Subring R
⊢ a ∈ {a | s ⊆ MulOpposite.unop ⁻¹' ↑a} ↔ a ∈ {S | MulOpposite.op ⁻¹' s ⊆ ↑S}
state_after: no goals
tactic: exact MulOpposite.op_surjective.forall
Theorem: Complex.sin_surjective
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Complex.lean

Proof steps:
state_before: ⊢ Function.Surjective sin
state_after: x : ℂ
⊢ ∃ a, sin a = x
tactic: intro x
state_before: x : ℂ
⊢ ∃ a, sin a = x
state_after: case intro
z : ℂ
⊢ ∃ a, sin a = cos z
tactic: rcases cos_surjective x with ⟨z, rfl⟩
state_before: case intro
z : ℂ
⊢ ∃ a, sin a = cos z
state_after: no goals
tactic: exact ⟨z + π / 2, sin_add_pi_div_two z⟩
Theorem: RingEquiv.coe_ringHom_inj_iff
File: Mathlib/Algebra/Ring/Equiv.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
R✝ : Type u_4
S✝ : Type u_5
S' : Type u_6
inst✝⁴ : NonAssocSemiring R✝
inst✝³ : NonAssocSemiring S✝
inst✝² : NonAssocSemiring S'
R : Type u_7
S : Type u_8
inst✝¹ : NonAssocSemiring R
inst✝ : NonAssocSemiring S
f g : R ≃+* S
h : f = g
⊢ ↑f = ↑g
state_after: no goals
tactic: rw [h]
Theorem: lift_nhds_right
File: Mathlib/Topology/UniformSpace/Basic.lean

Proof steps:
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝ : UniformSpace α
x : α
g : Set α → Filter β
hg : Monotone g
⊢ (𝓝 x).lift g = (𝓤 α).lift fun s => g {y | (y, x) ∈ s}
state_after: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝ : UniformSpace α
x : α
g : Set α → Filter β
hg : Monotone g
⊢ (𝓤 α).lift (g ∘ preimage fun y => (y, x)) = (𝓤 α).lift fun s => g {y | (y, x) ∈ s}
tactic: rw [nhds_eq_comap_uniformity', comap_lift_eq2 hg]
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝ : UniformSpace α
x : α
g : Set α → Filter β
hg : Monotone g
⊢ (𝓤 α).lift (g ∘ preimage fun y => (y, x)) = (𝓤 α).lift fun s => g {y | (y, x) ∈ s}
state_after: no goals
tactic: simp_rw [Function.comp, preimage]
Theorem: wittStructureRat_existsUnique
File: Mathlib/RingTheory/WittVector/StructurePolynomial.lean

Proof steps:
state_before: p : ℕ
R : Type u_1
idx : Type u_2
inst✝ : CommRing R
hp : Fact (Nat.Prime p)
Φ : MvPolynomial idx ℚ
⊢ ∃! φ, ∀ (n : ℕ), (bind₁ φ) (W_ ℚ n) = (bind₁ fun i => (rename (Prod.mk i)) (W_ ℚ n)) Φ
state_after: case refine_1
p : ℕ
R : Type u_1
idx : Type u_2
inst✝ : CommRing R
hp : Fact (Nat.Prime p)
Φ : MvPolynomial idx ℚ
⊢ (fun φ => ∀ (n : ℕ), (bind₁ φ) (W_ ℚ n) = (bind₁ fun i => (rename (Prod.mk i)) (W_ ℚ n)) Φ) (wittStructureRat p Φ)

case refine_2
p : ℕ
R : Type u_1
idx : Type u_2
inst✝ : CommRing R
hp : Fact (Nat.Prime p)
Φ : MvPolynomial idx ℚ
⊢ ∀ (y : ℕ → MvPolynomial (idx × ℕ) ℚ),
    (fun φ => ∀ (n : ℕ), (bind₁ φ) (W_ ℚ n) = (bind₁ fun i => (rename (Prod.mk i)) (W_ ℚ n)) Φ) y →
      y = wittStructureRat p Φ
tactic: refine ⟨wittStructureRat p Φ, ?_, ?_⟩
Theorem: eq_mul_of_mul_inv_eq
File: Mathlib/Algebra/Group/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a b c d : G
n : ℤ
h : a * c⁻¹ = b
⊢ a = b * c
state_after: no goals
tactic: simp [h.symm]
Theorem: toIocMod_add_left'
File: Mathlib/Algebra/Order/ToIntervalMod.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ toIocMod hp (p + a) b = p + toIocMod hp a b
state_after: no goals
tactic: rw [add_comm, toIocMod_add_right', add_comm]
Theorem: CategoryTheory.GradedObject.ι_descMapObj
File: Mathlib/CategoryTheory/GradedObject.lean

Proof steps:
state_before: I : Type u_1
J : Type u_2
K : Type u_3
C : Type u_4
inst✝³ : Category.{u_5, u_4} C
X Y Z : GradedObject I C
φ✝ : X ⟶ Y
e : X ≅ Y
ψ : Y ⟶ Z
p : I → J
j✝ : J
inst✝² : X.HasMap p
inst✝¹ : Y.HasMap p
inst✝ : Z.HasMap p
A : C
j : J
φ : (i : I) → p i = j → (X i ⟶ A)
i : I
hi : p i = j
⊢ X.ιMapObj p i j hi ≫ X.descMapObj p φ = φ i hi
state_after: no goals
tactic: apply Cofan.IsColimit.fac
Theorem: Matrix.dotProduct_sub
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✝² : Fintype m
inst✝¹ : Fintype n
inst✝ : NonUnitalNonAssocRing α
u v w : m → α
⊢ u ⬝ᵥ (v - w) = u ⬝ᵥ v - u ⬝ᵥ w
state_after: no goals
tactic: simp [sub_eq_add_neg]
Theorem: AffineSubspace.setOf_sSameSide_eq_image2
File: Mathlib/Analysis/Convex/Side.lean

Proof steps:
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁶ : LinearOrderedField R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x p : P
hx : x ∉ s
hp : p ∈ s
⊢ {y | s.SSameSide x y} = Set.image2 (fun t q => t • (x -ᵥ p) +ᵥ q) (Set.Ioi 0) ↑s
state_after: case h
R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁶ : LinearOrderedField R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x p : P
hx : x ∉ s
hp : p ∈ s
y : P
⊢ y ∈ {y | s.SSameSide x y} ↔ y ∈ Set.image2 (fun t q => t • (x -ᵥ p) +ᵥ q) (Set.Ioi 0) ↑s
tactic: ext y
state_before: case h
R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁶ : LinearOrderedField R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x p : P
hx : x ∉ s
hp : p ∈ s
y : P
⊢ y ∈ {y | s.SSameSide x y} ↔ y ∈ Set.image2 (fun t q => t • (x -ᵥ p) +ᵥ q) (Set.Ioi 0) ↑s
state_after: case h
R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁶ : LinearOrderedField R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x p : P
hx : x ∉ s
hp : p ∈ s
y : P
⊢ s.SSameSide x y ↔ ∃ a, 0 < a ∧ ∃ b ∈ ↑s, a • (x -ᵥ p) +ᵥ b = y
tactic: simp_rw [Set.mem_setOf, Set.mem_image2, Set.mem_Ioi]
state_before: case h
R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁶ : LinearOrderedField R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x p : P
hx : x ∉ s
hp : p ∈ s
y : P
⊢ s.SSameSide x y ↔ ∃ a, 0 < a ∧ ∃ b ∈ ↑s, a • (x -ᵥ p) +ᵥ b = y
state_after: case h.mp
R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁶ : LinearOrderedField R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x p : P
hx : x ∉ s
hp : p ∈ s
y : P
⊢ s.SSameSide x y → ∃ a, 0 < a ∧ ∃ b ∈ ↑s, a • (x -ᵥ p) +ᵥ b = y

case h.mpr
R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁶ : LinearOrderedField R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x p : P
hx : x ∉ s
hp : p ∈ s
y : P
⊢ (∃ a, 0 < a ∧ ∃ b ∈ ↑s, a • (x -ᵥ p) +ᵥ b = y) → s.SSameSide x y
tactic: constructor
Theorem: Mathlib.Tactic.Abel.term_smul
File: Mathlib/Tactic/Abel.lean

Proof steps:
state_before: α : Type u_1
inst✝ : AddCommMonoid α
c n : ℕ
x a : α
n' : ℕ
a' : α
h₁ : c * n = n'
h₂ : smul c a = a'
⊢ smul c (term n x a) = term n' x a'
state_after: no goals
tactic: simp [h₂.symm, h₁.symm, term, smul, nsmul_add, mul_nsmul']
Theorem: TopCat.range_prod_map
File: Mathlib/Topology/Category/TopCat/Limits/Products.lean

Proof steps:
state_before: J : Type v
inst✝ : SmallCategory J
W X Y Z : TopCat
f : W ⟶ Y
g : X ⟶ Z
⊢ Set.range ⇑(prod.map f g) = ⇑prod.fst ⁻¹' Set.range ⇑f ∩ ⇑prod.snd ⁻¹' Set.range ⇑g
state_after: case h
J : Type v
inst✝ : SmallCategory J
W X Y Z : TopCat
f : W ⟶ Y
g : X ⟶ Z
x : ↑(Y ⨯ Z)
⊢ x ∈ Set.range ⇑(prod.map f g) ↔ x ∈ ⇑prod.fst ⁻¹' Set.range ⇑f ∩ ⇑prod.snd ⁻¹' Set.range ⇑g
tactic: ext x
state_before: case h
J : Type v
inst✝ : SmallCategory J
W X Y Z : TopCat
f : W ⟶ Y
g : X ⟶ Z
x : ↑(Y ⨯ Z)
⊢ x ∈ Set.range ⇑(prod.map f g) ↔ x ∈ ⇑prod.fst ⁻¹' Set.range ⇑f ∩ ⇑prod.snd ⁻¹' Set.range ⇑g
state_after: case h.mp
J : Type v
inst✝ : SmallCategory J
W X Y Z : TopCat
f : W ⟶ Y
g : X ⟶ Z
x : ↑(Y ⨯ Z)
⊢ x ∈ Set.range ⇑(prod.map f g) → x ∈ ⇑prod.fst ⁻¹' Set.range ⇑f ∩ ⇑prod.snd ⁻¹' Set.range ⇑g

case h.mpr
J : Type v
inst✝ : SmallCategory J
W X Y Z : TopCat
f : W ⟶ Y
g : X ⟶ Z
x : ↑(Y ⨯ Z)
⊢ x ∈ ⇑prod.fst ⁻¹' Set.range ⇑f ∩ ⇑prod.snd ⁻¹' Set.range ⇑g → x ∈ Set.range ⇑(prod.map f g)
tactic: constructor
Theorem: ProbabilityTheory.lintegral_condKernel
File: Mathlib/Probability/Kernel/Disintegration/Integral.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
Ω : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
inst✝⁴ : MeasurableSpace Ω
inst✝³ : StandardBorelSpace Ω
inst✝² : Nonempty Ω
inst✝¹ : CountableOrCountablyGenerated α β
κ : Kernel α (β × Ω)
inst✝ : IsFiniteKernel κ
f : β × Ω → ℝ≥0∞
hf : Measurable f
a : α
⊢ ∫⁻ (b : β), ∫⁻ (ω : Ω), f (b, ω) ∂κ.condKernel (a, b) ∂κ.fst a = ∫⁻ (x : β × Ω), f x ∂κ a
state_after: α : Type u_1
β : Type u_2
Ω : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
inst✝⁴ : MeasurableSpace Ω
inst✝³ : StandardBorelSpace Ω
inst✝² : Nonempty Ω
inst✝¹ : CountableOrCountablyGenerated α β
κ : Kernel α (β × Ω)
inst✝ : IsFiniteKernel κ
f : β × Ω → ℝ≥0∞
hf : Measurable f
a : α
⊢ ∫⁻ (b : β), ∫⁻ (ω : Ω), f (b, ω) ∂κ.condKernel (a, b) ∂κ.fst a = ∫⁻ (x : β × Ω), f x ∂(κ.fst ⊗ₖ κ.condKernel) a
tactic: conv_rhs => rw [← κ.disintegrate κ.condKernel]
state_before: α : Type u_1
β : Type u_2
Ω : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
inst✝⁴ : MeasurableSpace Ω
inst✝³ : StandardBorelSpace Ω
inst✝² : Nonempty Ω
inst✝¹ : CountableOrCountablyGenerated α β
κ : Kernel α (β × Ω)
inst✝ : IsFiniteKernel κ
f : β × Ω → ℝ≥0∞
hf : Measurable f
a : α
⊢ ∫⁻ (b : β), ∫⁻ (ω : Ω), f (b, ω) ∂κ.condKernel (a, b) ∂κ.fst a = ∫⁻ (x : β × Ω), f x ∂(κ.fst ⊗ₖ κ.condKernel) a
state_after: no goals
tactic: rw [Kernel.lintegral_compProd _ _ _ hf]
Theorem: nhds_nil
File: Mathlib/Topology/List.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
⊢ 𝓝 [] = pure []
state_after: no goals
tactic: rw [nhds_list, List.traverse_nil _]
Theorem: Ideal.map_of_equiv
File: Mathlib/RingTheory/Ideal/Maps.lean

Proof steps:
state_before: R : Type u
S : Type v
F : Type u_1
inst✝³ : Semiring R
inst✝² : Semiring S
inst✝¹ : FunLike F R S
rc : RingHomClass F R S
f✝ : F
I✝ J : Ideal R
K L : Ideal S
G : Type u_2
inst✝ : FunLike G S R
rcg : RingHomClass G S R
ι : Sort u_3
I : Ideal R
f : R ≃+* S
⊢ map (↑f.symm) (map (↑f) I) = I
state_after: no goals
tactic: rw [← RingEquiv.toRingHom_eq_coe, ← RingEquiv.toRingHom_eq_coe, map_map,
    RingEquiv.toRingHom_eq_coe, RingEquiv.toRingHom_eq_coe, RingEquiv.symm_comp, map_id]
Theorem: CategoryTheory.PreGaloisCategory.has_non_trivial_subobject_of_not_isConnected_of_not_initial
File: Mathlib/CategoryTheory/Galois/Basic.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
X : C
hc : ¬IsConnected X
hi : IsInitial X → False
⊢ ∃ Y v, (IsInitial Y → False) ∧ Mono v ∧ ¬IsIso v
state_after: C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
X : C
hi : IsInitial X → False
hc : ∀ (Y : C) (v : Y ⟶ X), (IsInitial Y → False) → Mono v → IsIso v
⊢ IsConnected X
tactic: contrapose! hc
state_before: C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
X : C
hi : IsInitial X → False
hc : ∀ (Y : C) (v : Y ⟶ X), (IsInitial Y → False) → Mono v → IsIso v
⊢ IsConnected X
state_after: no goals
tactic: exact ⟨hi, fun Y i hm hni ↦ hc Y i hni hm⟩
Theorem: CategoryTheory.NatTrans.congr_app
File: Mathlib/CategoryTheory/Functor/Category.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
F G H I : C ⥤ D
α β : F ⟶ G
h : α = β
X : C
⊢ α.app X = β.app X
state_after: no goals
tactic: rw [h]
Theorem: UniformConcaveOn.strictConcaveOn
File: Mathlib/Analysis/Convex/Strong.lean

Proof steps:
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
φ ψ : ℝ → ℝ
s : Set E
a b m : ℝ
x y : E
f g : E → ℝ
hf : UniformConcaveOn s φ f
hφ : ∀ (r : ℝ), r ≠ 0 → 0 < φ r
⊢ StrictConcaveOn ℝ s f
state_after: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
φ ψ : ℝ → ℝ
s : Set E
a✝ b✝ m : ℝ
x✝ y✝ : E
f g : E → ℝ
hf : UniformConcaveOn s φ f
hφ : ∀ (r : ℝ), r ≠ 0 → 0 < φ r
x : E
hx : x ∈ s
y : E
hy : y ∈ s
hxy : x ≠ y
a b : ℝ
ha : 0 < a
hb : 0 < b
hab : a + b = 1
⊢ 0 < a * b * φ ‖x - y‖
tactic: refine ⟨hf.1, fun x hx y hy hxy a b ha hb hab ↦ (hf.2 hx hy ha.le hb.le hab).trans_lt' <|
    lt_add_of_pos_right _ ?_⟩
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
φ ψ : ℝ → ℝ
s : Set E
a✝ b✝ m : ℝ
x✝ y✝ : E
f g : E → ℝ
hf : UniformConcaveOn s φ f
hφ : ∀ (r : ℝ), r ≠ 0 → 0 < φ r
x : E
hx : x ∈ s
y : E
hy : y ∈ s
hxy : x ≠ y
a b : ℝ
ha : 0 < a
hb : 0 < b
hab : a + b = 1
⊢ 0 < a * b * φ ‖x - y‖
state_after: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
φ ψ : ℝ → ℝ
s : Set E
a✝ b✝ m : ℝ
x✝ y✝ : E
f g : E → ℝ
hf : UniformConcaveOn s φ f
hφ : ∀ (r : ℝ), r ≠ 0 → 0 < φ r
x : E
hx : x ∈ s
y : E
hy : y ∈ s
hxy : 0 < ‖x - y‖
a b : ℝ
ha : 0 < a
hb : 0 < b
hab : a + b = 1
⊢ 0 < a * b * φ ‖x - y‖
tactic: rw [← sub_ne_zero, ← norm_pos_iff] at hxy
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
φ ψ : ℝ → ℝ
s : Set E
a✝ b✝ m : ℝ
x✝ y✝ : E
f g : E → ℝ
hf : UniformConcaveOn s φ f
hφ : ∀ (r : ℝ), r ≠ 0 → 0 < φ r
x : E
hx : x ∈ s
y : E
hy : y ∈ s
hxy : 0 < ‖x - y‖
a b : ℝ
ha : 0 < a
hb : 0 < b
hab : a + b = 1
⊢ 0 < a * b * φ ‖x - y‖
state_after: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
φ ψ : ℝ → ℝ
s : Set E
a✝ b✝ m : ℝ
x✝ y✝ : E
f g : E → ℝ
hf : UniformConcaveOn s φ f
hφ : ∀ (r : ℝ), r ≠ 0 → 0 < φ r
x : E
hx : x ∈ s
y : E
hy : y ∈ s
hxy : 0 < ‖x - y‖
a b : ℝ
ha : 0 < a
hb : 0 < b
hab : a + b = 1
this : 0 < φ ‖x - y‖
⊢ 0 < a * b * φ ‖x - y‖
tactic: have := hφ _ hxy.ne'
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
φ ψ : ℝ → ℝ
s : Set E
a✝ b✝ m : ℝ
x✝ y✝ : E
f g : E → ℝ
hf : UniformConcaveOn s φ f
hφ : ∀ (r : ℝ), r ≠ 0 → 0 < φ r
x : E
hx : x ∈ s
y : E
hy : y ∈ s
hxy : 0 < ‖x - y‖
a b : ℝ
ha : 0 < a
hb : 0 < b
hab : a + b = 1
this : 0 < φ ‖x - y‖
⊢ 0 < a * b * φ ‖x - y‖
state_after: no goals
tactic: positivity