ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: MonotoneOn.sum_le_integral
File: Mathlib/Analysis/SumIntegralComparisons.lean

Proof steps:
state_before: x₀ : ℝ
a b : ℕ
f : ℝ → ℝ
hf : MonotoneOn f (Icc x₀ (x₀ + ↑a))
⊢ ∑ i ∈ Finset.range a, f (x₀ + ↑i) ≤ ∫ (x : ℝ) in x₀..x₀ + ↑a, f x
state_after: x₀ : ℝ
a b : ℕ
f : ℝ → ℝ
hf : MonotoneOn f (Icc x₀ (x₀ + ↑a))
⊢ ∫ (x : ℝ) in x₀..x₀ + ↑a, -f x ≤ ∑ x ∈ Finset.range a, -f (x₀ + ↑x)
tactic: rw [← neg_le_neg_iff, ← Finset.sum_neg_distrib, ← intervalIntegral.integral_neg]
state_before: x₀ : ℝ
a b : ℕ
f : ℝ → ℝ
hf : MonotoneOn f (Icc x₀ (x₀ + ↑a))
⊢ ∫ (x : ℝ) in x₀..x₀ + ↑a, -f x ≤ ∑ x ∈ Finset.range a, -f (x₀ + ↑x)
state_after: no goals
tactic: exact hf.neg.integral_le_sum
Theorem: Polynomial.Monic.sub_of_left
File: Mathlib/Algebra/Polynomial/Monic.lean

Proof steps:
state_before: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Ring R
p✝ p q : R[X]
hp : p.Monic
hpq : q.degree < p.degree
⊢ (p - q).Monic
state_after: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Ring R
p✝ p q : R[X]
hp : p.Monic
hpq : q.degree < p.degree
⊢ (p + -q).Monic
tactic: rw [sub_eq_add_neg]
state_before: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Ring R
p✝ p q : R[X]
hp : p.Monic
hpq : q.degree < p.degree
⊢ (p + -q).Monic
state_after: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Ring R
p✝ p q : R[X]
hp : p.Monic
hpq : q.degree < p.degree
⊢ (-q).degree < p.degree
tactic: apply hp.add_of_left
state_before: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Ring R
p✝ p q : R[X]
hp : p.Monic
hpq : q.degree < p.degree
⊢ (-q).degree < p.degree
state_after: no goals
tactic: rwa [degree_neg]
Theorem: TypeVec.subtypeVal_toSubtype'
File: Mathlib/Data/TypeVec.lean

Proof steps:
state_before: n : ℕ
α : TypeVec.{u_1} n
r : α ⊗ α ⟹ repeat n Prop
⊢ subtypeVal r ⊚ toSubtype' r = fun i x => prod.mk i (↑x).1 (↑x).2
state_after: case a.h
n : ℕ
α : TypeVec.{u_1} n
r : α ⊗ α ⟹ repeat n Prop
i : Fin2 n
x : (fun i => { x // ofRepeat (r i (prod.mk i x.1 x.2)) }) i
⊢ (subtypeVal r ⊚ toSubtype' r) i x = prod.mk i (↑x).1 (↑x).2
tactic: ext i x
state_before: case a.h
n : ℕ
α : TypeVec.{u_1} n
r : α ⊗ α ⟹ repeat n Prop
i : Fin2 n
x : (fun i => { x // ofRepeat (r i (prod.mk i x.1 x.2)) }) i
⊢ (subtypeVal r ⊚ toSubtype' r) i x = prod.mk i (↑x).1 (↑x).2
state_after: case a.h.fs
n n✝ : ℕ
a✝ : Fin2 n✝
a_ih✝ :
  ∀ {α : TypeVec.{u_1} n✝} (r : α ⊗ α ⟹ repeat n✝ Prop) (x : { x // ofRepeat (r a✝ (prod.mk a✝ x.1 x.2)) }),
    subtypeVal r a✝ (toSubtype' r a✝ x) = prod.mk a✝ (↑x).1 (↑x).2
α : TypeVec.{u_1} (n✝ + 1)
r : α ⊗ α ⟹ repeat (n✝ + 1) Prop
x : { x // ofRepeat (r a✝.fs (prod.mk a✝.fs x.1 x.2)) }
⊢ subtypeVal (dropFun r) a✝ (toSubtype' (dropFun r) a✝ x) = prod.mk a✝ (↑x).1 (↑x).2
tactic: induction i <;> dsimp only [id, toSubtype', comp, subtypeVal, prod.mk] at *
state_before: case a.h.fs
n n✝ : ℕ
a✝ : Fin2 n✝
a_ih✝ :
  ∀ {α : TypeVec.{u_1} n✝} (r : α ⊗ α ⟹ repeat n✝ Prop) (x : { x // ofRepeat (r a✝ (prod.mk a✝ x.1 x.2)) }),
    subtypeVal r a✝ (toSubtype' r a✝ x) = prod.mk a✝ (↑x).1 (↑x).2
α : TypeVec.{u_1} (n✝ + 1)
r : α ⊗ α ⟹ repeat (n✝ + 1) Prop
x : { x // ofRepeat (r a✝.fs (prod.mk a✝.fs x.1 x.2)) }
⊢ subtypeVal (dropFun r) a✝ (toSubtype' (dropFun r) a✝ x) = prod.mk a✝ (↑x).1 (↑x).2
state_after: no goals
tactic: simp [*]
Theorem: CategoryTheory.PreGaloisCategory.fiberEqualizerEquiv_symm_ι_apply
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 Y : C
f g : X ⟶ Y
x : ↑(F.obj X)
h : F.map f x = F.map g x
⊢ F.map (equalizer.ι f g) ((fiberEqualizerEquiv F f g).symm ⟨x, h⟩) = x
state_after: C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
X Y : C
f g : X ⟶ Y
x : ↑(F.obj X)
h : F.map f x = F.map g x
⊢ F.map (equalizer.ι f g)
      ((PreservesEqualizer.iso (F ⋙ FintypeCat.incl) f g).inv ((Types.equalizerIso (F.map f) (F.map g)).inv ⟨x, h⟩)) =
    x
tactic: simp [fiberEqualizerEquiv]
state_before: C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
X Y : C
f g : X ⟶ Y
x : ↑(F.obj X)
h : F.map f x = F.map g x
⊢ F.map (equalizer.ι f g)
      ((PreservesEqualizer.iso (F ⋙ FintypeCat.incl) f g).inv ((Types.equalizerIso (F.map f) (F.map g)).inv ⟨x, h⟩)) =
    x
state_after: C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
X Y : C
f g : X ⟶ Y
x : ↑(F.obj X)
h : F.map f x = F.map g x
⊢ ((Types.equalizerIso (F.map f) (F.map g)).inv ≫
        (PreservesEqualizer.iso (F ⋙ FintypeCat.incl) f g).inv ≫ (F ⋙ FintypeCat.incl).map (equalizer.ι f g))
      ⟨x, h⟩ =
    x
tactic: change ((Types.equalizerIso _ _).inv ≫ _ ≫ (F ⋙ FintypeCat.incl).map (equalizer.ι f g)) _ = _
state_before: C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
X Y : C
f g : X ⟶ Y
x : ↑(F.obj X)
h : F.map f x = F.map g x
⊢ ((Types.equalizerIso (F.map f) (F.map g)).inv ≫
        (PreservesEqualizer.iso (F ⋙ FintypeCat.incl) f g).inv ≫ (F ⋙ FintypeCat.incl).map (equalizer.ι f g))
      ⟨x, h⟩ =
    x
state_after: no goals
tactic: erw [PreservesEqualizer.iso_inv_ι, Types.equalizerIso_inv_comp_ι]
Theorem: NumberField.fractionalIdeal_rank
File: Mathlib/NumberTheory/NumberField/FractionalIdeal.lean

Proof steps:
state_before: K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
I : (FractionalIdeal (𝓞 K)⁰ K)ˣ
⊢ finrank ℤ ↥↑↑I = finrank ℤ (𝓞 K)
state_after: no goals
tactic: rw [finrank_eq_card_chooseBasisIndex, RingOfIntegers.rank,
    finrank_eq_card_basis (basisOfFractionalIdeal K I)]
Theorem: Matrix.det_mvPolynomialX_ne_zero
File: Mathlib/LinearAlgebra/Matrix/MvPolynomial.lean

Proof steps:
state_before: m : Type u_1
n : Type u_2
R : Type u_3
S : Type u_4
inst✝³ : DecidableEq m
inst✝² : Fintype m
inst✝¹ : CommRing R
inst✝ : Nontrivial R
⊢ (mvPolynomialX m m R).det ≠ 0
state_after: m : Type u_1
n : Type u_2
R : Type u_3
S : Type u_4
inst✝³ : DecidableEq m
inst✝² : Fintype m
inst✝¹ : CommRing R
inst✝ : Nontrivial R
h_det : (mvPolynomialX m m R).det = 0
⊢ False
tactic: intro h_det
state_before: m : Type u_1
n : Type u_2
R : Type u_3
S : Type u_4
inst✝³ : DecidableEq m
inst✝² : Fintype m
inst✝¹ : CommRing R
inst✝ : Nontrivial R
h_det : (mvPolynomialX m m R).det = 0
⊢ False
state_after: m : Type u_1
n : Type u_2
R : Type u_3
S : Type u_4
inst✝³ : DecidableEq m
inst✝² : Fintype m
inst✝¹ : CommRing R
inst✝ : Nontrivial R
h_det : (mvPolynomialX m m R).det = 0
this : ((MvPolynomial.eval fun p => 1 p.1 p.2).mapMatrix (mvPolynomialX m m R)).det = det 1
⊢ False
tactic: have := congr_arg Matrix.det (mvPolynomialX_mapMatrix_eval (1 : Matrix m m R))
state_before: m : Type u_1
n : Type u_2
R : Type u_3
S : Type u_4
inst✝³ : DecidableEq m
inst✝² : Fintype m
inst✝¹ : CommRing R
inst✝ : Nontrivial R
h_det : (mvPolynomialX m m R).det = 0
this : ((MvPolynomial.eval fun p => 1 p.1 p.2).mapMatrix (mvPolynomialX m m R)).det = det 1
⊢ False
state_after: m : Type u_1
n : Type u_2
R : Type u_3
S : Type u_4
inst✝³ : DecidableEq m
inst✝² : Fintype m
inst✝¹ : CommRing R
inst✝ : Nontrivial R
h_det : (mvPolynomialX m m R).det = 0
this : 0 = 1
⊢ False
tactic: rw [det_one, ← RingHom.map_det, h_det, RingHom.map_zero] at this
state_before: m : Type u_1
n : Type u_2
R : Type u_3
S : Type u_4
inst✝³ : DecidableEq m
inst✝² : Fintype m
inst✝¹ : CommRing R
inst✝ : Nontrivial R
h_det : (mvPolynomialX m m R).det = 0
this : 0 = 1
⊢ False
state_after: no goals
tactic: exact zero_ne_one this
Theorem: IsLindelof.compl_mem_sets_of_nhdsWithin
File: Mathlib/Topology/Compactness/Lindelof.lean

Proof steps:
state_before: X : Type u
Y : Type v
ι : Type u_1
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
s t : Set X
hs : IsLindelof s
f : Filter X
inst✝ : CountableInterFilter f
hf : ∀ x ∈ s, ∃ t ∈ 𝓝[s] x, tᶜ ∈ f
⊢ sᶜ ∈ f
state_after: X : Type u
Y : Type v
ι : Type u_1
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
s t : Set X
hs : IsLindelof s
f : Filter X
inst✝ : CountableInterFilter f
hf : ∀ x ∈ s, ∃ t ∈ 𝓝[s] x, tᶜ ∈ f
x : X
hx : x ∈ s
⊢ sᶜ ∈ 𝓝 x ⊓ f
tactic: refine hs.compl_mem_sets fun x hx ↦ ?_
state_before: X : Type u
Y : Type v
ι : Type u_1
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
s t : Set X
hs : IsLindelof s
f : Filter X
inst✝ : CountableInterFilter f
hf : ∀ x ∈ s, ∃ t ∈ 𝓝[s] x, tᶜ ∈ f
x : X
hx : x ∈ s
⊢ sᶜ ∈ 𝓝 x ⊓ f
state_after: X : Type u
Y : Type v
ι : Type u_1
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
s t : Set X
hs : IsLindelof s
f : Filter X
inst✝ : CountableInterFilter f
hf : ∀ x ∈ s, ∃ t ∈ 𝓝[s] x, tᶜ ∈ f
x : X
hx : x ∈ s
⊢ ∃ i ∈ 𝓝 x ⊓ 𝓟 s, (id i)ᶜ ∈ f
tactic: rw [← disjoint_principal_right, disjoint_right_comm, (basis_sets _).disjoint_iff_left]
state_before: X : Type u
Y : Type v
ι : Type u_1
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
s t : Set X
hs : IsLindelof s
f : Filter X
inst✝ : CountableInterFilter f
hf : ∀ x ∈ s, ∃ t ∈ 𝓝[s] x, tᶜ ∈ f
x : X
hx : x ∈ s
⊢ ∃ i ∈ 𝓝 x ⊓ 𝓟 s, (id i)ᶜ ∈ f
state_after: no goals
tactic: exact hf x hx
Theorem: AddChar.mulShift_spec'
File: Mathlib/Algebra/Group/AddChar.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝¹ : Ring R
inst✝ : CommMonoid M
ψ : AddChar R M
n : ℕ
x : R
⊢ (ψ.mulShift ↑n) x = ψ x ^ n
state_after: no goals
tactic: rw [mulShift_apply, ← nsmul_eq_mul, map_nsmul_eq_pow]
Theorem: Filter.exists_antitone_seq
File: Mathlib/Order/Filter/Bases.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Sort u_5
f : Filter α
inst✝ : f.IsCountablyGenerated
x : ℕ → Set α
hx : f.HasAntitoneBasis x
⊢ ∀ {s : Set α}, s ∈ f ↔ ∃ i, x i ⊆ s
state_after: no goals
tactic: simp [hx.1.mem_iff]
Theorem: Submonoid.LocalizationMap.ofMulEquivOfDom_id
File: Mathlib/GroupTheory/MonoidLocalization/Basic.lean

Proof steps:
state_before: M : Type u_1
inst✝³ : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝² : CommMonoid N
P : Type u_3
inst✝¹ : CommMonoid P
f : S.LocalizationMap N
g : M →* P
hg : ∀ (y : ↥S), IsUnit (g ↑y)
T : Submonoid P
Q : Type u_4
inst✝ : CommMonoid Q
⊢ f.ofMulEquivOfDom ⋯ = f
state_after: case h
M : Type u_1
inst✝³ : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝² : CommMonoid N
P : Type u_3
inst✝¹ : CommMonoid P
f : S.LocalizationMap N
g : M →* P
hg : ∀ (y : ↥S), IsUnit (g ↑y)
T : Submonoid P
Q : Type u_4
inst✝ : CommMonoid Q
x✝ : M
⊢ (f.ofMulEquivOfDom ⋯).toMap x✝ = f.toMap x✝
tactic: ext
state_before: case h
M : Type u_1
inst✝³ : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝² : CommMonoid N
P : Type u_3
inst✝¹ : CommMonoid P
f : S.LocalizationMap N
g : M →* P
hg : ∀ (y : ↥S), IsUnit (g ↑y)
T : Submonoid P
Q : Type u_4
inst✝ : CommMonoid Q
x✝ : M
⊢ (f.ofMulEquivOfDom ⋯).toMap x✝ = f.toMap x✝
state_after: no goals
tactic: rfl
Theorem: ProbabilityTheory.Kernel.IsSFiniteKernel.withDensity
File: Mathlib/Probability/Kernel/WithDensity.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ✝ : Kernel α β
f : α → β → ℝ≥0∞
κ : Kernel α β
inst✝ : IsSFiniteKernel κ
hf_ne_top : ∀ (a : α) (b : β), f a b ≠ ⊤
⊢ IsSFiniteKernel (κ.withDensity f)
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ✝ : Kernel α β
f : α → β → ℝ≥0∞
κ : Kernel α β
inst✝ : IsSFiniteKernel κ
hf_ne_top : ∀ (a : α) (b : β), f a b ≠ ⊤
h_eq_sum : κ.withDensity f = Kernel.sum fun i => (κ.seq i).withDensity f
⊢ IsSFiniteKernel (κ.withDensity f)
tactic: have h_eq_sum : withDensity κ f = Kernel.sum fun i => withDensity (seq κ i) f := by
    rw [← withDensity_kernel_sum _ _]
    congr
    exact (kernel_sum_seq κ).symm
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ✝ : Kernel α β
f : α → β → ℝ≥0∞
κ : Kernel α β
inst✝ : IsSFiniteKernel κ
hf_ne_top : ∀ (a : α) (b : β), f a b ≠ ⊤
h_eq_sum : κ.withDensity f = Kernel.sum fun i => (κ.seq i).withDensity f
⊢ IsSFiniteKernel (κ.withDensity f)
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ✝ : Kernel α β
f : α → β → ℝ≥0∞
κ : Kernel α β
inst✝ : IsSFiniteKernel κ
hf_ne_top : ∀ (a : α) (b : β), f a b ≠ ⊤
h_eq_sum : κ.withDensity f = Kernel.sum fun i => (κ.seq i).withDensity f
⊢ IsSFiniteKernel (Kernel.sum fun i => (κ.seq i).withDensity f)
tactic: rw [h_eq_sum]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ✝ : Kernel α β
f : α → β → ℝ≥0∞
κ : Kernel α β
inst✝ : IsSFiniteKernel κ
hf_ne_top : ∀ (a : α) (b : β), f a b ≠ ⊤
h_eq_sum : κ.withDensity f = Kernel.sum fun i => (κ.seq i).withDensity f
⊢ IsSFiniteKernel (Kernel.sum fun i => (κ.seq i).withDensity f)
state_after: no goals
tactic: exact isSFiniteKernel_sum fun n =>
    isSFiniteKernel_withDensity_of_isFiniteKernel (seq κ n) hf_ne_top
Theorem: NormedAddCommGroup.uniformity_basis_dist
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₂ : ℝ
⊢ (𝓤 E).HasBasis (fun ε => 0 < ε) fun ε => {p | ‖p.1 / p.2‖ < ε}
state_after: case h.e'_5
𝓕 : 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₂ : ℝ
⊢ (fun ε => {p | ‖p.1 / p.2‖ < ε}) = fun ε => {p | dist p.1 p.2 < ε}
tactic: convert Metric.uniformity_basis_dist (α := E) using 1
state_before: case h.e'_5
𝓕 : 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₂ : ℝ
⊢ (fun ε => {p | ‖p.1 / p.2‖ < ε}) = fun ε => {p | dist p.1 p.2 < ε}
state_after: no goals
tactic: simp [dist_eq_norm_div]
Theorem: convexHull_sub
File: Mathlib/Analysis/Convex/Combination.lean

Proof steps:
state_before: R : Type u_1
R' : Type u_2
E : Type u_3
F : Type u_4
ι : Type u_5
ι' : Type u_6
α : Type u_7
inst✝⁸ : LinearOrderedField R
inst✝⁷ : LinearOrderedField R'
inst✝⁶ : AddCommGroup E
inst✝⁵ : AddCommGroup F
inst✝⁴ : LinearOrderedAddCommGroup α
inst✝³ : Module R E
inst✝² : Module R F
inst✝¹ : Module R α
inst✝ : OrderedSMul R α
s✝ : Set E
i j : ι
c : R
t✝ : Finset ι
w : ι → R
z : ι → E
s t : Set E
⊢ (convexHull R) (s - t) = (convexHull R) s - (convexHull R) t
state_after: no goals
tactic: simp_rw [sub_eq_add_neg, convexHull_add, ← convexHull_neg]
Theorem: AlgebraicGeometry.isomorphisms_eq_stalkwise
File: Mathlib/AlgebraicGeometry/Morphisms/IsIso.lean

Proof steps:
state_before: ⊢ isomorphisms Scheme =
    (isomorphisms TopCat).inverseImage Scheme.forgetToTop ⊓
      stalkwise fun {R S} [CommRing R] [CommRing S] f => Function.Bijective ⇑f
state_after: ⊢ (((topologically fun {α β} [TopologicalSpace α] [TopologicalSpace β] => OpenEmbedding) ⊓
        topologically fun {α β} [TopologicalSpace α] [TopologicalSpace β] => Function.Surjective) ⊓
      stalkwise fun {R S} [CommRing R] [CommRing S] f => Function.Bijective ⇑f) =
    (isomorphisms TopCat).inverseImage Scheme.forgetToTop ⊓
      stalkwise fun {R S} [CommRing R] [CommRing S] f => Function.Bijective ⇑f
tactic: rw [isomorphisms_eq_isOpenImmersion_inf_surjective, isOpenImmersion_eq_inf,
    surjective_eq_topologically, inf_right_comm]
state_before: ⊢ (((topologically fun {α β} [TopologicalSpace α] [TopologicalSpace β] => OpenEmbedding) ⊓
        topologically fun {α β} [TopologicalSpace α] [TopologicalSpace β] => Function.Surjective) ⊓
      stalkwise fun {R S} [CommRing R] [CommRing S] f => Function.Bijective ⇑f) =
    (isomorphisms TopCat).inverseImage Scheme.forgetToTop ⊓
      stalkwise fun {R S} [CommRing R] [CommRing S] f => Function.Bijective ⇑f
state_after: case e_a

⊢ ((topologically fun {α β} [TopologicalSpace α] [TopologicalSpace β] => OpenEmbedding) ⊓
      topologically fun {α β} [TopologicalSpace α] [TopologicalSpace β] => Function.Surjective) =
    (isomorphisms TopCat).inverseImage Scheme.forgetToTop
tactic: congr 1
state_before: case e_a

⊢ ((topologically fun {α β} [TopologicalSpace α] [TopologicalSpace β] => OpenEmbedding) ⊓
      topologically fun {α β} [TopologicalSpace α] [TopologicalSpace β] => Function.Surjective) =
    (isomorphisms TopCat).inverseImage Scheme.forgetToTop
state_after: case e_a.h
X Y : Scheme
f : X ⟶ Y
⊢ ((topologically fun {α β} [TopologicalSpace α] [TopologicalSpace β] => OpenEmbedding) ⊓
        topologically fun {α β} [TopologicalSpace α] [TopologicalSpace β] => Function.Surjective)
      f ↔
    (isomorphisms TopCat).inverseImage Scheme.forgetToTop f
tactic: ext X Y f
state_before: case e_a.h
X Y : Scheme
f : X ⟶ Y
⊢ ((topologically fun {α β} [TopologicalSpace α] [TopologicalSpace β] => OpenEmbedding) ⊓
        topologically fun {α β} [TopologicalSpace α] [TopologicalSpace β] => Function.Surjective)
      f ↔
    (isomorphisms TopCat).inverseImage Scheme.forgetToTop f
state_after: no goals
tactic: exact ⟨fun H ↦ inferInstanceAs (IsIso (TopCat.isoOfHomeo
    (H.1.1.toHomeomeomorph_of_surjective H.2)).hom), fun (_ : IsIso f.1.base) ↦
    let e := (TopCat.homeoOfIso <| asIso f.1.base); ⟨e.openEmbedding, e.surjective⟩⟩
Theorem: uniqueDiffOn_Ioc
File: Mathlib/Analysis/Calculus/TangentCone.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
F : Type u_3
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
G : Type u_4
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace ℝ G
x y : E
s t : Set E
a b : ℝ
hab : a < b
⊢ (interior (Ioc a b)).Nonempty
state_after: no goals
tactic: simp only [interior_Ioc, nonempty_Ioo, hab]
state_before: 𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
F : Type u_3
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
G : Type u_4
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace ℝ G
x y : E
s t : Set E
a b : ℝ
hab : ¬a < b
⊢ UniqueDiffOn ℝ (Ioc a b)
state_after: no goals
tactic: simp only [Ioc_eq_empty hab, uniqueDiffOn_empty]
Theorem: List.get?_set_eq_of_lt
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: α : Type u_1
a : α
n : Nat
l : List α
h : n < l.length
⊢ (l.set n a).get? n = some a
state_after: α : Type u_1
a : α
n : Nat
l : List α
h : n < l.length
⊢ (fun x => a) <$> some l[n] = some a
tactic: rw [get?_eq_getElem?, getElem?_set_eq', getElem?_eq_getElem h]
state_before: α : Type u_1
a : α
n : Nat
l : List α
h : n < l.length
⊢ (fun x => a) <$> some l[n] = some a
state_after: no goals
tactic: rfl
Theorem: SetTheory.PGame.Relabelling.numeric_imp
File: Mathlib/SetTheory/Surreal/Basic.lean

Proof steps:
state_before: x y : PGame
r : x ≡r y
ox : x.Numeric
⊢ y.Numeric
state_after: case IH
x : PGame
IHl : ∀ (i : x.LeftMoves) {y : PGame}, x.moveLeft i ≡r y → (x.moveLeft i).Numeric → y.Numeric
IHr : ∀ (j : x.RightMoves) {y : PGame}, x.moveRight j ≡r y → (x.moveRight j).Numeric → y.Numeric
y : PGame
r : x ≡r y
ox : x.Numeric
⊢ y.Numeric
tactic: induction' x using PGame.moveRecOn with x IHl IHr generalizing y
state_before: case IH
x : PGame
IHl : ∀ (i : x.LeftMoves) {y : PGame}, x.moveLeft i ≡r y → (x.moveLeft i).Numeric → y.Numeric
IHr : ∀ (j : x.RightMoves) {y : PGame}, x.moveRight j ≡r y → (x.moveRight j).Numeric → y.Numeric
y : PGame
r : x ≡r y
ox : x.Numeric
⊢ y.Numeric
state_after: x : PGame
IHl : ∀ (i : x.LeftMoves) {y : PGame}, x.moveLeft i ≡r y → (x.moveLeft i).Numeric → y.Numeric
IHr : ∀ (j : x.RightMoves) {y : PGame}, x.moveRight j ≡r y → (x.moveRight j).Numeric → y.Numeric
y : PGame
r : x ≡r y
ox : x.Numeric
i : y.LeftMoves
j : y.RightMoves
⊢ y.moveLeft i < y.moveRight j

x : PGame
IHl : ∀ (i : x.LeftMoves) {y : PGame}, x.moveLeft i ≡r y → (x.moveLeft i).Numeric → y.Numeric
IHr : ∀ (j : x.RightMoves) {y : PGame}, x.moveRight j ≡r y → (x.moveRight j).Numeric → y.Numeric
y : PGame
r : x ≡r y
ox : x.Numeric
i : y.LeftMoves
⊢ (y.moveLeft i).Numeric

x : PGame
IHl : ∀ (i : x.LeftMoves) {y : PGame}, x.moveLeft i ≡r y → (x.moveLeft i).Numeric → y.Numeric
IHr : ∀ (j : x.RightMoves) {y : PGame}, x.moveRight j ≡r y → (x.moveRight j).Numeric → y.Numeric
y : PGame
r : x ≡r y
ox : x.Numeric
j : y.RightMoves
⊢ (y.moveRight j).Numeric
tactic: apply Numeric.mk (fun i j => ?_) (fun i => ?_) fun j => ?_
Theorem: prod_dvd_iff
File: Mathlib/Algebra/Divisibility/Prod.lean

Proof steps:
state_before: ι : Type u_1
G₁ : Type u_2
G₂ : Type u_3
G : ι → Type u_4
inst✝² : Semigroup G₁
inst✝¹ : Semigroup G₂
inst✝ : (i : ι) → Semigroup (G i)
x y : G₁ × G₂
⊢ x ∣ y ↔ x.1 ∣ y.1 ∧ x.2 ∣ y.2
state_after: case mk
ι : Type u_1
G₁ : Type u_2
G₂ : Type u_3
G : ι → Type u_4
inst✝² : Semigroup G₁
inst✝¹ : Semigroup G₂
inst✝ : (i : ι) → Semigroup (G i)
y : G₁ × G₂
fst✝ : G₁
snd✝ : G₂
⊢ (fst✝, snd✝) ∣ y ↔ (fst✝, snd✝).1 ∣ y.1 ∧ (fst✝, snd✝).2 ∣ y.2
tactic: cases x
state_before: case mk
ι : Type u_1
G₁ : Type u_2
G₂ : Type u_3
G : ι → Type u_4
inst✝² : Semigroup G₁
inst✝¹ : Semigroup G₂
inst✝ : (i : ι) → Semigroup (G i)
y : G₁ × G₂
fst✝ : G₁
snd✝ : G₂
⊢ (fst✝, snd✝) ∣ y ↔ (fst✝, snd✝).1 ∣ y.1 ∧ (fst✝, snd✝).2 ∣ y.2
state_after: case mk.mk
ι : Type u_1
G₁ : Type u_2
G₂ : Type u_3
G : ι → Type u_4
inst✝² : Semigroup G₁
inst✝¹ : Semigroup G₂
inst✝ : (i : ι) → Semigroup (G i)
fst✝¹ : G₁
snd✝¹ : G₂
fst✝ : G₁
snd✝ : G₂
⊢ (fst✝¹, snd✝¹) ∣ (fst✝, snd✝) ↔ (fst✝¹, snd✝¹).1 ∣ (fst✝, snd✝).1 ∧ (fst✝¹, snd✝¹).2 ∣ (fst✝, snd✝).2
tactic: cases y
state_before: case mk.mk
ι : Type u_1
G₁ : Type u_2
G₂ : Type u_3
G : ι → Type u_4
inst✝² : Semigroup G₁
inst✝¹ : Semigroup G₂
inst✝ : (i : ι) → Semigroup (G i)
fst✝¹ : G₁
snd✝¹ : G₂
fst✝ : G₁
snd✝ : G₂
⊢ (fst✝¹, snd✝¹) ∣ (fst✝, snd✝) ↔ (fst✝¹, snd✝¹).1 ∣ (fst✝, snd✝).1 ∧ (fst✝¹, snd✝¹).2 ∣ (fst✝, snd✝).2
state_after: no goals
tactic: simp only [dvd_def, Prod.exists, Prod.mk_mul_mk, Prod.mk.injEq,
    exists_and_left, exists_and_right, and_self, true_and]