ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Matroid.basis_restrict_iff'
File: Mathlib/Data/Matroid/Restrict.lean

Proof steps:
state_before: α : Type u_1
M : Matroid α
R I J X Y : Set α
⊢ (M ↾ R).Basis I X ↔ M.Basis I (X ∩ M.E) ∧ X ⊆ R
state_after: α : Type u_1
M : Matroid α
R I J X Y : Set α
⊢ X ⊆ R → (M.Basis' I (X ∩ R) ∧ I ⊆ R ↔ M.Basis' I X)
tactic: rw [basis_iff_basis'_subset_ground, basis'_restrict_iff, restrict_ground_eq, and_congr_left_iff,
    ← basis'_iff_basis_inter_ground]
state_before: α : Type u_1
M : Matroid α
R I J X Y : Set α
⊢ X ⊆ R → (M.Basis' I (X ∩ R) ∧ I ⊆ R ↔ M.Basis' I X)
state_after: α : Type u_1
M : Matroid α
R I J X Y : Set α
hXR : X ⊆ R
⊢ M.Basis' I (X ∩ R) ∧ I ⊆ R ↔ M.Basis' I X
tactic: intro hXR
state_before: α : Type u_1
M : Matroid α
R I J X Y : Set α
hXR : X ⊆ R
⊢ M.Basis' I (X ∩ R) ∧ I ⊆ R ↔ M.Basis' I X
state_after: α : Type u_1
M : Matroid α
R I J X Y : Set α
hXR : X ⊆ R
⊢ M.Basis' I X → I ⊆ R
tactic: rw [inter_eq_self_of_subset_left hXR, and_iff_left_iff_imp]
state_before: α : Type u_1
M : Matroid α
R I J X Y : Set α
hXR : X ⊆ R
⊢ M.Basis' I X → I ⊆ R
state_after: no goals
tactic: exact fun h ↦ h.subset.trans hXR
Theorem: PosNum.cast_to_znum
File: Mathlib/Data/Num/Lemmas.lean

Proof steps:
state_before: α : Type u_1
p : PosNum
⊢ ↑p.bit0 = ZNum.pos p.bit0
state_after: α : Type u_1
p : PosNum
this : (↑p).bit0 = (ZNum.pos p).bit0
⊢ ↑p.bit0 = ZNum.pos p.bit0
tactic: have := congr_arg ZNum.bit0 (cast_to_znum p)
state_before: α : Type u_1
p : PosNum
this : (↑p).bit0 = (ZNum.pos p).bit0
⊢ ↑p.bit0 = ZNum.pos p.bit0
state_after: no goals
tactic: rwa [← ZNum.bit0_of_bit0] at this
state_before: α : Type u_1
p : PosNum
⊢ ↑p.bit1 = ZNum.pos p.bit1
state_after: α : Type u_1
p : PosNum
this : (↑p).bit1 = (ZNum.pos p).bit1
⊢ ↑p.bit1 = ZNum.pos p.bit1
tactic: have := congr_arg ZNum.bit1 (cast_to_znum p)
state_before: α : Type u_1
p : PosNum
this : (↑p).bit1 = (ZNum.pos p).bit1
⊢ ↑p.bit1 = ZNum.pos p.bit1
state_after: no goals
tactic: rwa [← ZNum.bit1_of_bit1] at this
Theorem: MeasureTheory.LocallyIntegrable.integrable_of_isBigO_atBot
File: Mathlib/MeasureTheory/Integral/Asymptotics.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
inst✝⁸ : MeasurableSpace α
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
f : α → E
g : α → F
a b : α
μ : Measure α
l : Filter α
inst✝⁵ : TopologicalSpace α
inst✝⁴ : SecondCountableTopology α
inst✝³ : LinearOrder α
inst✝² : CompactIccSpace α
g' : α → F
inst✝¹ : atBot.IsMeasurablyGenerated
inst✝ : OrderTop α
hf : LocallyIntegrable f μ
ho : f =O[atBot] g
hg : IntegrableAtFilter g atBot μ
⊢ Integrable f μ
state_after: α : Type u_1
E : Type u_2
F : Type u_3
inst✝⁸ : MeasurableSpace α
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
f : α → E
g : α → F
a b : α
μ : Measure α
l : Filter α
inst✝⁵ : TopologicalSpace α
inst✝⁴ : SecondCountableTopology α
inst✝³ : LinearOrder α
inst✝² : CompactIccSpace α
g' : α → F
inst✝¹ : atBot.IsMeasurablyGenerated
inst✝ : OrderTop α
hf : LocallyIntegrable f μ
ho : f =O[atBot] g
hg : IntegrableAtFilter g atBot μ
⊢ StronglyMeasurableAtFilter f atBot μ
tactic: refine integrable_iff_integrableAtFilter_atBot.mpr ⟨ho.integrableAtFilter ?_ hg, hf⟩
state_before: α : Type u_1
E : Type u_2
F : Type u_3
inst✝⁸ : MeasurableSpace α
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
f : α → E
g : α → F
a b : α
μ : Measure α
l : Filter α
inst✝⁵ : TopologicalSpace α
inst✝⁴ : SecondCountableTopology α
inst✝³ : LinearOrder α
inst✝² : CompactIccSpace α
g' : α → F
inst✝¹ : atBot.IsMeasurablyGenerated
inst✝ : OrderTop α
hf : LocallyIntegrable f μ
ho : f =O[atBot] g
hg : IntegrableAtFilter g atBot μ
⊢ StronglyMeasurableAtFilter f atBot μ
state_after: no goals
tactic: exact hf.aestronglyMeasurable.stronglyMeasurableAtFilter
Theorem: Filter.smallSets_comap_eq_comap_image
File: Mathlib/Order/Filter/SmallSets.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Sort u_3
l✝ l' la : Filter α
lb l : Filter β
f : α → β
⊢ (comap f l).smallSets = comap (image f) l.smallSets
state_after: α : Type u_1
β : Type u_2
ι : Sort u_3
l✝ l' la : Filter α
lb l : Filter β
f : α → β
⊢ ∀ (x : Filter (Set α)), map f (x.bind 𝓟) = (map (image f) x).bind 𝓟
tactic: refine (gc_map_comap _).u_comm_of_l_comm (gc_map_comap _) bind_smallSets_gc bind_smallSets_gc ?_
state_before: α : Type u_1
β : Type u_2
ι : Sort u_3
l✝ l' la : Filter α
lb l : Filter β
f : α → β
⊢ ∀ (x : Filter (Set α)), map f (x.bind 𝓟) = (map (image f) x).bind 𝓟
state_after: no goals
tactic: simp [Function.comp, map_bind, bind_map]
Theorem: schnirelmannDensity_congr
File: Mathlib/Combinatorics/Schnirelmann.lean

Proof steps:
state_before: A : Set ℕ
inst✝¹ : DecidablePred fun x => x ∈ A
B : Set ℕ
inst✝ : DecidablePred fun x => x ∈ B
h : A = B
⊢ ∀ n > 0, n ∈ A ↔ n ∈ B
state_after: no goals
tactic: aesop
Theorem: Num.dvd_iff_mod_eq_zero
File: Mathlib/Data/Num/Lemmas.lean

Proof steps:
state_before: m n : Num
⊢ m ∣ n ↔ n % m = 0
state_after: m n : Num
⊢ ↑n % ↑m = 0 ↔ ↑n % ↑m = ↑0
tactic: rw [← dvd_to_nat, Nat.dvd_iff_mod_eq_zero, ← to_nat_inj, mod_to_nat]
state_before: m n : Num
⊢ ↑n % ↑m = 0 ↔ ↑n % ↑m = ↑0
state_after: no goals
tactic: rfl
Theorem: Int.clog_of_right_le_one
File: Mathlib/Data/Int/Log.lean

Proof steps:
state_before: R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b : ℕ
r : R
hr : r ≤ 1
⊢ clog b r = -↑(Nat.log b ⌊r⁻¹⌋₊)
state_after: case inl
R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b : ℕ
hr : 1 ≤ 1
⊢ clog b 1 = -↑(Nat.log b ⌊1⁻¹⌋₊)

case inr
R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b : ℕ
r : R
hr✝ : r ≤ 1
hr : r < 1
⊢ clog b r = -↑(Nat.log b ⌊r⁻¹⌋₊)
tactic: obtain rfl | hr := hr.eq_or_lt
Theorem: Set.disjoint_pi_univ_Ioc_update_left_right
File: Mathlib/Order/Interval/Set/Pi.lean

Proof steps:
state_before: ι : Type u_1
α : ι → Type u_2
inst✝¹ : (i : ι) → Preorder (α i)
x✝ y✝ : (i : ι) → α i
inst✝ : DecidableEq ι
x y : (i : ι) → α i
i₀ : ι
m : α i₀
⊢ Disjoint (univ.pi fun i => Ioc (x i) (update y i₀ m i)) (univ.pi fun i => Ioc (update x i₀ m i) (y i))
state_after: ι : Type u_1
α : ι → Type u_2
inst✝¹ : (i : ι) → Preorder (α i)
x✝ y✝ : (i : ι) → α i
inst✝ : DecidableEq ι
x y : (i : ι) → α i
i₀ : ι
m : α i₀
⊢ ∀ ⦃a : (i : ι) → α i⦄,
    (a ∈ univ.pi fun i => Ioc (x i) (update y i₀ m i)) → a ∉ univ.pi fun i => Ioc (update x i₀ m i) (y i)
tactic: rw [disjoint_left]
state_before: ι : Type u_1
α : ι → Type u_2
inst✝¹ : (i : ι) → Preorder (α i)
x✝ y✝ : (i : ι) → α i
inst✝ : DecidableEq ι
x y : (i : ι) → α i
i₀ : ι
m : α i₀
⊢ ∀ ⦃a : (i : ι) → α i⦄,
    (a ∈ univ.pi fun i => Ioc (x i) (update y i₀ m i)) → a ∉ univ.pi fun i => Ioc (update x i₀ m i) (y i)
state_after: ι : Type u_1
α : ι → Type u_2
inst✝¹ : (i : ι) → Preorder (α i)
x✝ y✝ : (i : ι) → α i
inst✝ : DecidableEq ι
x y : (i : ι) → α i
i₀ : ι
m : α i₀
z : (i : ι) → α i
h₁ : z ∈ univ.pi fun i => Ioc (x i) (update y i₀ m i)
h₂ : z ∈ univ.pi fun i => Ioc (update x i₀ m i) (y i)
⊢ False
tactic: rintro z h₁ h₂
state_before: ι : Type u_1
α : ι → Type u_2
inst✝¹ : (i : ι) → Preorder (α i)
x✝ y✝ : (i : ι) → α i
inst✝ : DecidableEq ι
x y : (i : ι) → α i
i₀ : ι
m : α i₀
z : (i : ι) → α i
h₁ : z ∈ univ.pi fun i => Ioc (x i) (update y i₀ m i)
h₂ : z ∈ univ.pi fun i => Ioc (update x i₀ m i) (y i)
⊢ False
state_after: ι : Type u_1
α : ι → Type u_2
inst✝¹ : (i : ι) → Preorder (α i)
x✝ y✝ : (i : ι) → α i
inst✝ : DecidableEq ι
x y : (i : ι) → α i
i₀ : ι
m : α i₀
z : (i : ι) → α i
h₁ : z ∈ univ.pi fun i => Ioc (x i) (update y i₀ m i)
h₂ : z ∈ univ.pi fun i => Ioc (update x i₀ m i) (y i)
⊢ update y i₀ m i₀ < z i₀
tactic: refine (h₁ i₀ (mem_univ _)).2.not_lt ?_
state_before: ι : Type u_1
α : ι → Type u_2
inst✝¹ : (i : ι) → Preorder (α i)
x✝ y✝ : (i : ι) → α i
inst✝ : DecidableEq ι
x y : (i : ι) → α i
i₀ : ι
m : α i₀
z : (i : ι) → α i
h₁ : z ∈ univ.pi fun i => Ioc (x i) (update y i₀ m i)
h₂ : z ∈ univ.pi fun i => Ioc (update x i₀ m i) (y i)
⊢ update y i₀ m i₀ < z i₀
state_after: no goals
tactic: simpa only [Function.update_same] using (h₂ i₀ (mem_univ _)).1
Theorem: Ordinal.card_eq_nat
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}
n : ℕ
⊢ o.card = ↑n ↔ o = ↑n
state_after: no goals
tactic: simp only [le_antisymm_iff, card_le_nat, nat_le_card]
Theorem: contDiffWithinAt_prod
File: Mathlib/Analysis/Calculus/ContDiff/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁵ : NormedAddCommGroup D
inst✝¹⁴ : NormedSpace 𝕜 D
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type u_2
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : NormedSpace 𝕜 X
s s₁ t✝ u : Set E
f✝ f₁ : E → F
g : F → G
x x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
𝔸 : Type u_3
𝔸' : Type u_4
ι : Type u_5
𝕜' : Type u_6
inst✝⁵ : NormedRing 𝔸
inst✝⁴ : NormedAlgebra 𝕜 𝔸
inst✝³ : NormedCommRing 𝔸'
inst✝² : NormedAlgebra 𝕜 𝔸'
inst✝¹ : NormedField 𝕜'
inst✝ : NormedAlgebra 𝕜 𝕜'
t : Finset ι
f : ι → E → 𝔸'
h : ∀ i ∈ t, ContDiffWithinAt 𝕜 n (f i) s x
⊢ ContDiffWithinAt 𝕜 n (fun y => ∏ i ∈ t, f i y) s x
state_after: no goals
tactic: simpa only [← Finset.prod_apply] using contDiffWithinAt_prod' h
Theorem: Nat.sq_mul_squarefree_of_pos'
File: Mathlib/Data/Nat/Squarefree.lean

Proof steps:
state_before: s : Finset ℕ
m n✝ p n : ℕ
h : 0 < n
⊢ ∃ a b, (b + 1) ^ 2 * (a + 1) = n ∧ Squarefree (a + 1)
state_after: case intro.intro.intro.intro.intro
s : Finset ℕ
m n✝ p n : ℕ
h : 0 < n
a₁ b₁ : ℕ
ha₁ : 0 < a₁
hb₁ : 0 < b₁
hab₁ : b₁ ^ 2 * a₁ = n
hab₂ : Squarefree a₁
⊢ ∃ a b, (b + 1) ^ 2 * (a + 1) = n ∧ Squarefree (a + 1)
tactic: obtain ⟨a₁, b₁, ha₁, hb₁, hab₁, hab₂⟩ := sq_mul_squarefree_of_pos h
state_before: case intro.intro.intro.intro.intro
s : Finset ℕ
m n✝ p n : ℕ
h : 0 < n
a₁ b₁ : ℕ
ha₁ : 0 < a₁
hb₁ : 0 < b₁
hab₁ : b₁ ^ 2 * a₁ = n
hab₂ : Squarefree a₁
⊢ ∃ a b, (b + 1) ^ 2 * (a + 1) = n ∧ Squarefree (a + 1)
state_after: no goals
tactic: refine ⟨a₁.pred, b₁.pred, ?_, ?_⟩ <;> simpa only [add_one, succ_pred_eq_of_pos, ha₁, hb₁]
Theorem: SimpleGraph.Walk.support_rotate
File: Mathlib/Combinatorics/SimpleGraph/Walk.lean

Proof steps:
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u✝ v✝ w x y : V
inst✝ : DecidableEq V
u v : V
c : G.Walk v v
h : u ∈ c.support
⊢ (c.rotate h).support.tail ~r c.support.tail
state_after: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u✝ v✝ w x y : V
inst✝ : DecidableEq V
u v : V
c : G.Walk v v
h : u ∈ c.support
⊢ ((c.dropUntil u h).support.tail ++ (c.takeUntil u h).support.tail) ~r c.support.tail
tactic: simp only [rotate, tail_support_append]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u✝ v✝ w x y : V
inst✝ : DecidableEq V
u v : V
c : G.Walk v v
h : u ∈ c.support
⊢ ((c.dropUntil u h).support.tail ++ (c.takeUntil u h).support.tail) ~r c.support.tail
state_after: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u✝ v✝ w x y : V
inst✝ : DecidableEq V
u v : V
c : G.Walk v v
h : u ∈ c.support
⊢ ((c.takeUntil u h).support.tail ++ (c.dropUntil u h).support.tail) ~r c.support.tail
tactic: apply List.IsRotated.trans List.isRotated_append
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u✝ v✝ w x y : V
inst✝ : DecidableEq V
u v : V
c : G.Walk v v
h : u ∈ c.support
⊢ ((c.takeUntil u h).support.tail ++ (c.dropUntil u h).support.tail) ~r c.support.tail
state_after: no goals
tactic: rw [← tail_support_append, take_spec]
Theorem: CategoryTheory.MorphismProperty.IsCompatibleWithShift.shiftFunctor_comp_inverts
File: Mathlib/CategoryTheory/Shift/Localization.lean

Proof steps:
state_before: C : Type u₁
D : Type u₂
inst✝⁶ : Category.{v₁, u₁} C
inst✝⁵ : Category.{v₂, u₂} D
E : Type u₃
inst✝⁴ : Category.{v₃, u₃} E
L : C ⥤ D
W : MorphismProperty C
inst✝³ : L.IsLocalization W
A : Type w
inst✝² : AddMonoid A
inst✝¹ : HasShift C A
inst✝ : W.IsCompatibleWithShift A
a : A
x✝¹ x✝ : C
f : x✝¹ ⟶ x✝
hf : W f
⊢ W ((shiftFunctor C a).map f)
state_after: no goals
tactic: simpa only [iff] using hf
Theorem: PointedCone.toConvexCone_injective
File: Mathlib/Analysis/Convex/Cone/Pointed.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommMonoid E
inst✝ : Module 𝕜 E
x✝¹ x✝ : PointedCone 𝕜 E
⊢ ↑x✝¹ = ↑x✝ → x✝¹ = x✝
state_after: no goals
tactic: simp [toConvexCone]
Theorem: AddCon.lift_funext
File: Mathlib/GroupTheory/Congruence/Basic.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : MulOneClass M
inst✝¹ : MulOneClass N
inst✝ : MulOneClass P
c : Con M
x y : M
f✝ : M →* P
f g : c.Quotient →* P
h : ∀ (a : M), f ↑a = g ↑a
⊢ f = g
state_after: M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : MulOneClass M
inst✝¹ : MulOneClass N
inst✝ : MulOneClass P
c : Con M
x y : M
f✝ : M →* P
f g : c.Quotient →* P
h : ∀ (a : M), f ↑a = g ↑a
⊢ c.lift (f.comp c.mk') ⋯ = c.lift (g.comp c.mk') ⋯
tactic: rw [← lift_apply_mk' f, ← lift_apply_mk' g]
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : MulOneClass M
inst✝¹ : MulOneClass N
inst✝ : MulOneClass P
c : Con M
x y : M
f✝ : M →* P
f g : c.Quotient →* P
h : ∀ (a : M), f ↑a = g ↑a
⊢ c.lift (f.comp c.mk') ⋯ = c.lift (g.comp c.mk') ⋯
state_after: case e_f
M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : MulOneClass M
inst✝¹ : MulOneClass N
inst✝ : MulOneClass P
c : Con M
x y : M
f✝ : M →* P
f g : c.Quotient →* P
h : ∀ (a : M), f ↑a = g ↑a
⊢ f.comp c.mk' = g.comp c.mk'
tactic: congr 1
state_before: case e_f
M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : MulOneClass M
inst✝¹ : MulOneClass N
inst✝ : MulOneClass P
c : Con M
x y : M
f✝ : M →* P
f g : c.Quotient →* P
h : ∀ (a : M), f ↑a = g ↑a
⊢ f.comp c.mk' = g.comp c.mk'
state_after: no goals
tactic: exact DFunLike.ext_iff.2 h
Theorem: List.Nodup.rotate_congr_iff
File: Mathlib/Data/List/Rotate.lean

Proof steps:
state_before: α : Type u
l : List α
hl : l.Nodup
i j : ℕ
⊢ l.rotate i = l.rotate j ↔ i % l.length = j % l.length ∨ l = []
state_after: case inl
α : Type u
i j : ℕ
hl : [].Nodup
⊢ [].rotate i = [].rotate j ↔ i % [].length = j % [].length ∨ [] = []

case inr
α : Type u
l : List α
hl : l.Nodup
i j : ℕ
hn : l ≠ []
⊢ l.rotate i = l.rotate j ↔ i % l.length = j % l.length ∨ l = []
tactic: rcases eq_or_ne l [] with rfl | hn
Theorem: Con.sSup_def
File: Mathlib/GroupTheory/Congruence/Basic.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c : Con M
S : Set (Con M)
⊢ sSup S = conGen (sSup (DFunLike.coe '' S))
state_after: M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c : Con M
S : Set (Con M)
⊢ (conGen fun x y => ∃ c ∈ S, c x y) = conGen (⨆ a ∈ S, ⇑a)
tactic: rw [sSup_eq_conGen, sSup_image]
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c : Con M
S : Set (Con M)
⊢ (conGen fun x y => ∃ c ∈ S, c x y) = conGen (⨆ a ∈ S, ⇑a)
state_after: case e_r.h.h.a
M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c : Con M
S : Set (Con M)
x y : M
⊢ (∃ c ∈ S, c x y) ↔ (⨆ a ∈ S, ⇑a) x y
tactic: congr with (x y)
state_before: case e_r.h.h.a
M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c : Con M
S : Set (Con M)
x y : M
⊢ (∃ c ∈ S, c x y) ↔ (⨆ a ∈ S, ⇑a) x y
state_after: no goals
tactic: simp only [sSup_image, iSup_apply, iSup_Prop_eq, exists_prop, rel_eq_coe]
Theorem: Finset.neg_smul
File: Mathlib/Data/Finset/Pointwise.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝⁴ : Ring α
inst✝³ : AddCommGroup β
inst✝² : Module α β
inst✝¹ : DecidableEq β
s : Finset α
t : Finset β
a : α
inst✝ : DecidableEq α
⊢ -s • t = -(s • t)
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝⁴ : Ring α
inst✝³ : AddCommGroup β
inst✝² : Module α β
inst✝¹ : DecidableEq β
s : Finset α
t : Finset β
a : α
inst✝ : DecidableEq α
⊢ image (fun x => -x) s • t = image (fun x => -x) (s • t)
tactic: simp_rw [← image_neg]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝⁴ : Ring α
inst✝³ : AddCommGroup β
inst✝² : Module α β
inst✝¹ : DecidableEq β
s : Finset α
t : Finset β
a : α
inst✝ : DecidableEq α
⊢ image (fun x => -x) s • t = image (fun x => -x) (s • t)
state_after: no goals
tactic: exact image₂_image_left_comm neg_smul
Theorem: CategoryTheory.GrothendieckTopology.WEqualsLocallyBijective.transport
File: Mathlib/CategoryTheory/Sites/Equivalence.lean

Proof steps:
state_before: C : Type u₁
inst✝¹³ : Category.{v₁, u₁} C
J : GrothendieckTopology C
D : Type u₂
inst✝¹² : Category.{v₂, u₂} D
K : GrothendieckTopology D
e : C ≌ D
G : D ⥤ C
A : Type u₃
inst✝¹¹ : Category.{v₃, u₃} A
inst✝¹⁰ : EssentiallySmall.{w, v₁, u₁} C
B : Type u_1
inst✝⁹ : Category.{?u.115187, u_1} B
F : A ⥤ B
inst✝⁸ : HasSheafify ((equivSmallModel C).inverse.inducedTopology J) A
inst✝⁷ : ((equivSmallModel C).inverse.inducedTopology J).HasSheafCompose F
inst✝⁶ : G.IsCoverDense J
inst✝⁵ : G.IsContinuous K J
inst✝⁴ : G.Full
inst✝³ : (G.sheafPushforwardContinuous A K J).EssSurj
inst✝² : G.IsCocontinuous K J
hG : CoverPreserving K J G
inst✝¹ : ConcreteCategory A
inst✝ : K.WEqualsLocallyBijective A
X✝ Y✝ : Cᵒᵖ ⥤ A
f : X✝ ⟶ Y✝
⊢ J.W f ↔ Presheaf.IsLocallyInjective J f ∧ Presheaf.IsLocallySurjective J f
state_after: no goals
tactic: rw [← W_whiskerLeft_iff J K G f, ← Presheaf.isLocallyInjective_whisker_iff K J G f hG,
      ← Presheaf.isLocallySurjective_whisker_iff K J G f hG, W_iff_isLocallyBijective]
Theorem: Function.periodicOrbit_apply_iterate_eq
File: Mathlib/Dynamics/PeriodicPts.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
f fa : α → α
fb : β → β
x y : α
m n✝ : ℕ
hx : x ∈ periodicPts f
n : ℕ
⊢ ((List.map (fun n => f^[n] x) (List.range (minimalPeriod f x))).rotate n).length =
    (List.map (fun n_1 => f^[n_1] (f^[n] x)) (List.range (minimalPeriod f (f^[n] x)))).length
state_after: no goals
tactic: simp [minimalPeriod_apply_iterate hx]
state_before: α : Type u_1
β : Type u_2
f fa : α → α
fb : β → β
x y : α
m✝ n✝ : ℕ
hx : x ∈ periodicPts f
n m : ℕ
x✝¹ : m < ((List.map (fun n => f^[n] x) (List.range (minimalPeriod f x))).rotate n).length
x✝ : m < (List.map (fun n_1 => f^[n_1] (f^[n] x)) (List.range (minimalPeriod f (f^[n] x)))).length
⊢ ((List.map (fun n => f^[n] x) (List.range (minimalPeriod f x))).rotate n).get ⟨m, x✝¹⟩ =
    (List.map (fun n_1 => f^[n_1] (f^[n] x)) (List.range (minimalPeriod f (f^[n] x)))).get ⟨m, x✝⟩
state_after: no goals
tactic: simp [List.getElem_rotate, iterate_add_apply]
Theorem: span_gramSchmidtNormed_range
File: Mathlib/Analysis/InnerProductSpace/GramSchmidtOrtho.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝⁵ : RCLike 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : InnerProductSpace 𝕜 E
ι : Type u_3
inst✝² : LinearOrder ι
inst✝¹ : LocallyFiniteOrderBot ι
inst✝ : IsWellOrder ι fun x x_1 => x < x_1
f : ι → E
⊢ span 𝕜 (Set.range (gramSchmidtNormed 𝕜 f)) = span 𝕜 (Set.range (gramSchmidt 𝕜 f))
state_after: no goals
tactic: simpa only [image_univ.symm] using span_gramSchmidtNormed f univ
Theorem: Submodule.exists_fg_le_eq_rTensor_inclusion
File: Mathlib/RingTheory/Finiteness.lean

Proof steps:
state_before: R✝ : Type u_1
M✝ : Type u_2
inst✝⁹ : Semiring R✝
inst✝⁸ : AddCommMonoid M✝
inst✝⁷ : Module R✝ M✝
P : Type u_3
inst✝⁶ : AddCommMonoid P
inst✝⁵ : Module R✝ P
f : M✝ →ₗ[R✝] P
R : Type u_4
M : Type u_5
N : Type u_6
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : AddCommGroup N
inst✝¹ : Module R M
inst✝ : Module R N
I : Submodule R N
x : ↥I ⊗[R] M
⊢ ∃ J, ∃ (_ : J.FG) (hle : J ≤ I), ∃ y, x = (rTensor M (inclusion hle)) y
state_after: no goals
tactic: induction x with
  | zero => exact ⟨⊥, fg_bot, zero_le _, 0, rfl⟩
  | tmul i m => exact ⟨R ∙ i.val, fg_span_singleton i.val,
      (span_singleton_le_iff_mem _ _).mpr i.property,
      ⟨i.val, mem_span_singleton_self _⟩ ⊗ₜ[R] m, rfl⟩
  | add x₁ x₂ ihx₁ ihx₂ =>
    obtain ⟨J₁, hfg₁, hle₁, y₁, rfl⟩ := ihx₁
    obtain ⟨J₂, hfg₂, hle₂, y₂, rfl⟩ := ihx₂
    refine ⟨J₁ ⊔ J₂, hfg₁.sup hfg₂, sup_le hle₁ hle₂,
      rTensor M (J₁.inclusion (le_sup_left : J₁ ≤ J₁ ⊔ J₂)) y₁ +
        rTensor M (J₂.inclusion (le_sup_right : J₂ ≤ J₁ ⊔ J₂)) y₂, ?_⟩
    rewrite [map_add, ← rTensor_comp_apply, ← rTensor_comp_apply]
    rfl
Theorem: MeasureTheory.inter_mem_measurableCylinders
File: Mathlib/MeasureTheory/Constructions/Cylinders.lean

Proof steps:
state_before: ι : Type u_1
α : ι → Type u_2
inst✝ : (i : ι) → MeasurableSpace (α i)
s t : Set ((i : ι) → α i)
hs : s ∈ measurableCylinders α
ht : t ∈ measurableCylinders α
⊢ s ∩ t ∈ measurableCylinders α
state_after: ι : Type u_1
α : ι → Type u_2
inst✝ : (i : ι) → MeasurableSpace (α i)
s t : Set ((i : ι) → α i)
hs : ∃ s_1 S, MeasurableSet S ∧ s = cylinder s_1 S
ht : ∃ s S, MeasurableSet S ∧ t = cylinder s S
⊢ ∃ s_1 S, MeasurableSet S ∧ s ∩ t = cylinder s_1 S
tactic: rw [mem_measurableCylinders] at *
state_before: ι : Type u_1
α : ι → Type u_2
inst✝ : (i : ι) → MeasurableSpace (α i)
s t : Set ((i : ι) → α i)
hs : ∃ s_1 S, MeasurableSet S ∧ s = cylinder s_1 S
ht : ∃ s S, MeasurableSet S ∧ t = cylinder s S
⊢ ∃ s_1 S, MeasurableSet S ∧ s ∩ t = cylinder s_1 S
state_after: case intro.intro.intro
ι : Type u_1
α : ι → Type u_2
inst✝ : (i : ι) → MeasurableSpace (α i)
t : Set ((i : ι) → α i)
ht : ∃ s S, MeasurableSet S ∧ t = cylinder s S
s₁ : Finset ι
S₁ : Set ((i : { x // x ∈ s₁ }) → α ↑i)
hS₁ : MeasurableSet S₁
⊢ ∃ s S, MeasurableSet S ∧ cylinder s₁ S₁ ∩ t = cylinder s S
tactic: obtain ⟨s₁, S₁, hS₁, rfl⟩ := hs
state_before: case intro.intro.intro
ι : Type u_1
α : ι → Type u_2
inst✝ : (i : ι) → MeasurableSpace (α i)
t : Set ((i : ι) → α i)
ht : ∃ s S, MeasurableSet S ∧ t = cylinder s S
s₁ : Finset ι
S₁ : Set ((i : { x // x ∈ s₁ }) → α ↑i)
hS₁ : MeasurableSet S₁
⊢ ∃ s S, MeasurableSet S ∧ cylinder s₁ S₁ ∩ t = cylinder s S
state_after: case intro.intro.intro.intro.intro.intro
ι : Type u_1
α : ι → Type u_2
inst✝ : (i : ι) → MeasurableSpace (α i)
s₁ : Finset ι
S₁ : Set ((i : { x // x ∈ s₁ }) → α ↑i)
hS₁ : MeasurableSet S₁
s₂ : Finset ι
S₂ : Set ((i : { x // x ∈ s₂ }) → α ↑i)
hS₂ : MeasurableSet S₂
⊢ ∃ s S, MeasurableSet S ∧ cylinder s₁ S₁ ∩ cylinder s₂ S₂ = cylinder s S
tactic: obtain ⟨s₂, S₂, hS₂, rfl⟩ := ht
Theorem: UniformSpace.Completion.uniformity_dist'
File: Mathlib/Topology/MetricSpace/Completion.lean

Proof steps:
state_before: α : Type u
β : Type v
inst✝ : PseudoMetricSpace α
⊢ 𝓤 (Completion α) = ⨅ ε, 𝓟 {p | dist p.1 p.2 < ↑ε}
state_after: case h
α : Type u
β : Type v
inst✝ : PseudoMetricSpace α
s : Set (Completion α × Completion α)
⊢ s ∈ 𝓤 (Completion α) ↔ s ∈ ⨅ ε, 𝓟 {p | dist p.1 p.2 < ↑ε}
tactic: ext s
state_before: case h
α : Type u
β : Type v
inst✝ : PseudoMetricSpace α
s : Set (Completion α × Completion α)
⊢ s ∈ 𝓤 (Completion α) ↔ s ∈ ⨅ ε, 𝓟 {p | dist p.1 p.2 < ↑ε}
state_after: case h
α : Type u
β : Type v
inst✝ : PseudoMetricSpace α
s : Set (Completion α × Completion α)
⊢ s ∈ 𝓤 (Completion α) ↔ ∃ i, s ∈ 𝓟 {p | dist p.1 p.2 < ↑i}

case h.h
α : Type u
β : Type v
inst✝ : PseudoMetricSpace α
s : Set (Completion α × Completion α)
⊢ Directed (fun x x_1 => x ≥ x_1) fun ε => 𝓟 {p | dist p.1 p.2 < ↑ε}
tactic: rw [mem_iInf_of_directed]
Theorem: Polynomial.reverse_X_pow_mul
File: Mathlib/Algebra/Polynomial/Reverse.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Semiring R
f p : R[X]
n : ℕ
⊢ (X ^ n * p).reverse = p.reverse
state_after: no goals
tactic: rw [commute_X_pow p, reverse_mul_X_pow]