ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CategoryTheory.Sheaf.mono_of_isLocallyInjective
File: Mathlib/CategoryTheory/Sites/LocallyInjective.lean

Proof steps:
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
inst✝² : ConcreteCategory D
J : GrothendieckTopology C
F₁ F₂ : Sheaf J D
φ : F₁ ⟶ F₂
inst✝¹ : J.HasSheafCompose (forget D)
inst✝ : IsLocallyInjective φ
⊢ Mono φ
state_after: case hφ
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
inst✝² : ConcreteCategory D
J : GrothendieckTopology C
F₁ F₂ : Sheaf J D
φ : F₁ ⟶ F₂
inst✝¹ : J.HasSheafCompose (forget D)
inst✝ : IsLocallyInjective φ
⊢ ∀ (X : Cᵒᵖ), Function.Injective ⇑(φ.val.app X)
tactic: apply mono_of_injective
state_before: case hφ
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
inst✝² : ConcreteCategory D
J : GrothendieckTopology C
F₁ F₂ : Sheaf J D
φ : F₁ ⟶ F₂
inst✝¹ : J.HasSheafCompose (forget D)
inst✝ : IsLocallyInjective φ
⊢ ∀ (X : Cᵒᵖ), Function.Injective ⇑(φ.val.app X)
state_after: case hφ
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
inst✝² : ConcreteCategory D
J : GrothendieckTopology C
F₁ F₂ : Sheaf J D
φ : F₁ ⟶ F₂
inst✝¹ : J.HasSheafCompose (forget D)
inst✝ : IsLocallyInjective φ
⊢ IsLocallyInjective φ
tactic: rw [← isLocallyInjective_iff_injective]
state_before: case hφ
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
inst✝² : ConcreteCategory D
J : GrothendieckTopology C
F₁ F₂ : Sheaf J D
φ : F₁ ⟶ F₂
inst✝¹ : J.HasSheafCompose (forget D)
inst✝ : IsLocallyInjective φ
⊢ IsLocallyInjective φ
state_after: no goals
tactic: infer_instance
Theorem: List.sublists_eq_sublistsFast
File: Mathlib/Data/List/Sublists.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
⊢ @sublists = @sublistsFast
state_after: case h.h
α✝ : Type u
β : Type v
γ : Type w
α : Type u_1
l : List α
⊢ l.sublists = l.sublistsFast
tactic: ext α l : 2
state_before: case h.h
α✝ : Type u
β : Type v
γ : Type w
α : Type u_1
l : List α
⊢ l.sublists = l.sublistsFast
state_after: α✝ : Type u
β : Type v
γ : Type w
α : Type u_1
l : List α
⊢ l.sublists = foldr sublistsAux [[]] l

α✝ : Type u
β : Type v
γ : Type w
α : Type u_1
l : List α
⊢ foldr sublistsAux [[]] l = l.sublistsFast
tactic: trans l.foldr sublistsAux [[]]
Theorem: AlgebraicGeometry.Spec.toLocallyRingedSpace_map
File: Mathlib/AlgebraicGeometry/Spec.lean

Proof steps:
state_before: R : CommRingCatᵒᵖ
⊢ { obj := fun R => locallyRingedSpaceObj (unop R), map := fun {X Y} f => locallyRingedSpaceMap f.unop }.map (𝟙 R) =
    𝟙 ({ obj := fun R => locallyRingedSpaceObj (unop R), map := fun {X Y} f => locallyRingedSpaceMap f.unop }.obj R)
state_after: R : CommRingCatᵒᵖ
⊢ locallyRingedSpaceMap (𝟙 (unop R)) = 𝟙 (locallyRingedSpaceObj (unop R))
tactic: dsimp
state_before: R : CommRingCatᵒᵖ
⊢ locallyRingedSpaceMap (𝟙 (unop R)) = 𝟙 (locallyRingedSpaceObj (unop R))
state_after: no goals
tactic: rw [Spec.locallyRingedSpaceMap_id]
state_before: X✝ Y✝ Z✝ : CommRingCatᵒᵖ
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
⊢ { obj := fun R => locallyRingedSpaceObj (unop R), map := fun {X Y} f => locallyRingedSpaceMap f.unop }.map (f ≫ g) =
    { obj := fun R => locallyRingedSpaceObj (unop R), map := fun {X Y} f => locallyRingedSpaceMap f.unop }.map f ≫
      { obj := fun R => locallyRingedSpaceObj (unop R), map := fun {X Y} f => locallyRingedSpaceMap f.unop }.map g
state_after: X✝ Y✝ Z✝ : CommRingCatᵒᵖ
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
⊢ locallyRingedSpaceMap (g.unop ≫ f.unop) = locallyRingedSpaceMap f.unop ≫ locallyRingedSpaceMap g.unop
tactic: dsimp
state_before: X✝ Y✝ Z✝ : CommRingCatᵒᵖ
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
⊢ locallyRingedSpaceMap (g.unop ≫ f.unop) = locallyRingedSpaceMap f.unop ≫ locallyRingedSpaceMap g.unop
state_after: no goals
tactic: rw [Spec.locallyRingedSpaceMap_comp]
Theorem: AddCon.sup_eq_addConGen
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✝ c d : Con M
⊢ c ⊔ d = conGen fun x y => c x y ∨ d x y
state_after: M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c✝ c d : Con M
⊢ c ⊔ d = sInf {s | ∀ (x y : M), c x y ∨ d x y → s x y}
tactic: rw [conGen_eq]
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c✝ c d : Con M
⊢ c ⊔ d = sInf {s | ∀ (x y : M), c x y ∨ d x y → s x y}
state_after: M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c✝ c d : Con M
⊢ {x | c ≤ x ∧ d ≤ x} = {s | ∀ (x y : M), c x y ∨ d x y → s x y}
tactic: apply congr_arg sInf
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c✝ c d : Con M
⊢ {x | c ≤ x ∧ d ≤ x} = {s | ∀ (x y : M), c x y ∨ d x y → s x y}
state_after: no goals
tactic: simp only [le_def, or_imp, ← forall_and]
Theorem: compl_mul_closure_one_eq_iff
File: Mathlib/Topology/Algebra/Group/Basic.lean

Proof steps:
state_before: G : Type w
H : Type x
α : Type u
β : Type v
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : TopologicalGroup G
s t✝ t : Set G
h : tᶜ * closure {1} = tᶜ
⊢ t * closure {1} = t
state_after: no goals
tactic: simpa using compl_mul_closure_one_eq h
Theorem: geometric_hahn_banach_closed_compact
File: Mathlib/Analysis/NormedSpace/HahnBanach/Separation.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝⁵ : TopologicalSpace E
inst✝⁴ : AddCommGroup E
inst✝³ : TopologicalAddGroup E
inst✝² : Module ℝ E
inst✝¹ : ContinuousSMul ℝ E
s✝ t✝ : Set E
x y : E
inst✝ : LocallyConvexSpace ℝ E
hs₁ : Convex ℝ s✝
hs₂ : IsClosed s✝
ht₁ : Convex ℝ t✝
ht₂ : IsCompact t✝
disj : Disjoint s✝ t✝
f : E →L[ℝ] ℝ
s t : ℝ
hs : ∀ a ∈ t✝, f a < s
st : s < t
ht : ∀ b ∈ s✝, t < f b
⊢ ∀ a ∈ s✝, (-f) a < -t
state_after: no goals
tactic: simpa using ht
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝⁵ : TopologicalSpace E
inst✝⁴ : AddCommGroup E
inst✝³ : TopologicalAddGroup E
inst✝² : Module ℝ E
inst✝¹ : ContinuousSMul ℝ E
s✝ t✝ : Set E
x y : E
inst✝ : LocallyConvexSpace ℝ E
hs₁ : Convex ℝ s✝
hs₂ : IsClosed s✝
ht₁ : Convex ℝ t✝
ht₂ : IsCompact t✝
disj : Disjoint s✝ t✝
f : E →L[ℝ] ℝ
s t : ℝ
hs : ∀ a ∈ t✝, f a < s
st : s < t
ht : ∀ b ∈ s✝, t < f b
⊢ -t < -s
state_after: no goals
tactic: simpa using st
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝⁵ : TopologicalSpace E
inst✝⁴ : AddCommGroup E
inst✝³ : TopologicalAddGroup E
inst✝² : Module ℝ E
inst✝¹ : ContinuousSMul ℝ E
s✝ t✝ : Set E
x y : E
inst✝ : LocallyConvexSpace ℝ E
hs₁ : Convex ℝ s✝
hs₂ : IsClosed s✝
ht₁ : Convex ℝ t✝
ht₂ : IsCompact t✝
disj : Disjoint s✝ t✝
f : E →L[ℝ] ℝ
s t : ℝ
hs : ∀ a ∈ t✝, f a < s
st : s < t
ht : ∀ b ∈ s✝, t < f b
⊢ ∀ b ∈ t✝, -s < (-f) b
state_after: no goals
tactic: simpa using hs
Theorem: Part.ofOption_dom
File: Mathlib/Data/Part.lean

Proof steps:
state_before: α✝ : Type u_1
β : Type u_2
γ : Type u_3
α : Type u_4
⊢ (↑Option.none).Dom ↔ Option.none.isSome = true
state_after: no goals
tactic: simp [ofOption, none]
state_before: α✝ : Type u_1
β : Type u_2
γ : Type u_3
α : Type u_4
a : α
⊢ (↑(Option.some a)).Dom ↔ (Option.some a).isSome = true
state_after: no goals
tactic: simp [ofOption]
Theorem: Ordinal.nmul_nadd_lt
File: Mathlib/SetTheory/Ordinal/NaturalOps.lean

Proof steps:
state_before: a b c d a' b' : Ordinal.{u}
ha : a' < a
hb : b' < b
⊢ a' ⨳ b ♯ a ⨳ b' < a ⨳ b ♯ a' ⨳ b'
state_after: a b c d a' b' : Ordinal.{u}
ha : a' < a
hb : b' < b
⊢ a' ⨳ b ♯ a ⨳ b' < sInf {c | ∀ a' < a, ∀ b' < b, a' ⨳ b ♯ a ⨳ b' < c ♯ a' ⨳ b'} ♯ a' ⨳ b'
tactic: rw [nmul_def a b]
state_before: a b c d a' b' : Ordinal.{u}
ha : a' < a
hb : b' < b
⊢ a' ⨳ b ♯ a ⨳ b' < sInf {c | ∀ a' < a, ∀ b' < b, a' ⨳ b ♯ a ⨳ b' < c ♯ a' ⨳ b'} ♯ a' ⨳ b'
state_after: no goals
tactic: exact csInf_mem (nmul_nonempty a b) a' ha b' hb
Theorem: LipschitzWith.const_min
File: Mathlib/Topology/MetricSpace/Lipschitz.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : PseudoEMetricSpace α
f g : α → ℝ
Kf Kg : ℝ≥0
hf : LipschitzWith Kf f
a : ℝ
⊢ LipschitzWith Kf fun x => min a (f x)
state_after: no goals
tactic: simpa only [min_comm] using hf.min_const a
Theorem: Real.isTopologicalBasis_Ioo_rat
File: Mathlib/Topology/Instances/Real.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
⊢ ∀ u ∈ ⋃ a, ⋃ b, ⋃ (_ : a < b), {Ioo ↑a ↑b}, IsOpen u
state_after: no goals
tactic: simp (config := { contextual := true }) [isOpen_Ioo]
state_before: α : Type u
β : Type v
γ : Type w
a : ℝ
v : Set ℝ
hav : a ∈ v
hv : IsOpen v
l u : ℝ
hl : l < a
hu : a < u
h : Ioo l u ⊆ v
q : ℚ
hlq : l < ↑q
hqa : ↑q < a
p : ℚ
hap : a < ↑p
hpu : ↑p < u
⊢ Ioo ↑q ↑p ∈ ⋃ a, ⋃ b, ⋃ (_ : a < b), {Ioo ↑a ↑b}
state_after: α : Type u
β : Type v
γ : Type w
a : ℝ
v : Set ℝ
hav : a ∈ v
hv : IsOpen v
l u : ℝ
hl : l < a
hu : a < u
h : Ioo l u ⊆ v
q : ℚ
hlq : l < ↑q
hqa : ↑q < a
p : ℚ
hap : a < ↑p
hpu : ↑p < u
⊢ ∃ i i_1, ∃ (_ : i < i_1), Ioo ↑q ↑p ∈ {Ioo ↑i ↑i_1}
tactic: simp only [mem_iUnion]
state_before: α : Type u
β : Type v
γ : Type w
a : ℝ
v : Set ℝ
hav : a ∈ v
hv : IsOpen v
l u : ℝ
hl : l < a
hu : a < u
h : Ioo l u ⊆ v
q : ℚ
hlq : l < ↑q
hqa : ↑q < a
p : ℚ
hap : a < ↑p
hpu : ↑p < u
⊢ ∃ i i_1, ∃ (_ : i < i_1), Ioo ↑q ↑p ∈ {Ioo ↑i ↑i_1}
state_after: no goals
tactic: exact ⟨q, p, Rat.cast_lt.1 <| hqa.trans hap, rfl⟩
Theorem: MeasureTheory.Submartingale.bddAbove_iff_exists_tendsto_aux
File: Mathlib/Probability/Martingale/BorelCantelli.lean

Proof steps:
state_before: Ω : Type u_1
m0 : MeasurableSpace Ω
μ : Measure Ω
ℱ : Filtration ℕ m0
f : ℕ → Ω → ℝ
ω : Ω
r : ℝ
R : ℝ≥0
inst✝ : IsFiniteMeasure μ
hf : Submartingale f ℱ μ
hf0 : f 0 = 0
hbdd : ∀ᵐ (ω : Ω) ∂μ, ∀ (i : ℕ), |f (i + 1) ω - f i ω| ≤ ↑R
⊢ ∀ᵐ (ω : Ω) ∂μ, BddAbove (Set.range fun n => f n ω) ↔ ∃ c, Tendsto (fun n => f n ω) atTop (𝓝 c)
state_after: no goals
tactic: filter_upwards [hf.exists_tendsto_of_abs_bddAbove_aux hf0 hbdd] with ω hω using
    ⟨hω, fun ⟨c, hc⟩ => hc.bddAbove_range⟩
Theorem: Finset.mem_dfinsupp_iff
File: Mathlib/Data/DFinsupp/Interval.lean

Proof steps:
state_before: ι : Type u_1
α : ι → Type u_2
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (α i)
s : Finset ι
f : Π₀ (i : ι), α i
t : (i : ι) → Finset (α i)
inst✝ : (i : ι) → DecidableEq (α i)
⊢ f ∈ s.dfinsupp t ↔ f.support ⊆ s ∧ ∀ i ∈ s, f i ∈ t i
state_after: case refine_1
ι : Type u_1
α : ι → Type u_2
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (α i)
s : Finset ι
f : Π₀ (i : ι), α i
t : (i : ι) → Finset (α i)
inst✝ : (i : ι) → DecidableEq (α i)
⊢ (∃ a ∈ s.pi t, { toFun := fun f => DFinsupp.mk s fun i => f ↑i ⋯, inj' := ⋯ } a = f) →
    f.support ⊆ s ∧ ∀ i ∈ s, f i ∈ t i

case refine_2
ι : Type u_1
α : ι → Type u_2
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (α i)
s : Finset ι
f : Π₀ (i : ι), α i
t : (i : ι) → Finset (α i)
inst✝ : (i : ι) → DecidableEq (α i)
⊢ (f.support ⊆ s ∧ ∀ i ∈ s, f i ∈ t i) →
    ∃ a ∈ s.pi t, { toFun := fun f => DFinsupp.mk s fun i => f ↑i ⋯, inj' := ⋯ } a = f
tactic: refine mem_map.trans ⟨?_, ?_⟩
Theorem: Geometry.SimplicialComplex.vertex_mem_convexHull_iff
File: Mathlib/Analysis/Convex/SimplicialComplex/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
ι : Type u_3
inst✝² : OrderedRing 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
K : SimplicialComplex 𝕜 E
s t : Finset E
x : E
hx : x ∈ K.vertices
hs : s ∈ K.faces
⊢ x ∈ (convexHull 𝕜) ↑s ↔ x ∈ s
state_after: 𝕜 : Type u_1
E : Type u_2
ι : Type u_3
inst✝² : OrderedRing 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
K : SimplicialComplex 𝕜 E
s t : Finset E
x : E
hx : x ∈ K.vertices
hs : s ∈ K.faces
h : x ∈ (convexHull 𝕜) ↑s
⊢ x ∈ s
tactic: refine ⟨fun h => ?_, fun h => subset_convexHull 𝕜 _ h⟩
state_before: 𝕜 : Type u_1
E : Type u_2
ι : Type u_3
inst✝² : OrderedRing 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
K : SimplicialComplex 𝕜 E
s t : Finset E
x : E
hx : x ∈ K.vertices
hs : s ∈ K.faces
h : x ∈ (convexHull 𝕜) ↑s
⊢ x ∈ s
state_after: no goals
tactic: classical
  have h := K.inter_subset_convexHull hx hs ⟨by simp, h⟩
  by_contra H
  rwa [← coe_inter, Finset.disjoint_iff_inter_eq_empty.1 (Finset.disjoint_singleton_right.2 H).symm,
    coe_empty, convexHull_empty] at h
Theorem: SimpleGraph.disjoint_sdiff_neighborFinset_image
File: Mathlib/Combinatorics/SimpleGraph/Operations.lean

Proof steps:
state_before: V : Type u_1
inst✝² : DecidableEq V
G : SimpleGraph V
s t : V
inst✝¹ : Fintype V
inst✝ : DecidableRel G.Adj
⊢ Disjoint (G.edgeFinset \ G.incidenceFinset t) (image (fun x => s(x, t)) (G.neighborFinset s))
state_after: V : Type u_1
inst✝² : DecidableEq V
G : SimpleGraph V
s t : V
inst✝¹ : Fintype V
inst✝ : DecidableRel G.Adj
⊢ ∀ a ∈ G.edgeFinset \ G.incidenceFinset t, ∀ b ∈ image (fun x => s(x, t)) (G.neighborFinset s), a ≠ b
tactic: rw [disjoint_iff_ne]
state_before: V : Type u_1
inst✝² : DecidableEq V
G : SimpleGraph V
s t : V
inst✝¹ : Fintype V
inst✝ : DecidableRel G.Adj
⊢ ∀ a ∈ G.edgeFinset \ G.incidenceFinset t, ∀ b ∈ image (fun x => s(x, t)) (G.neighborFinset s), a ≠ b
state_after: V : Type u_1
inst✝² : DecidableEq V
G : SimpleGraph V
s t : V
inst✝¹ : Fintype V
inst✝ : DecidableRel G.Adj
e : Sym2 V
he : e ∈ G.edgeFinset \ G.incidenceFinset t
⊢ ∀ b ∈ image (fun x => s(x, t)) (G.neighborFinset s), e ≠ b
tactic: intro e he
state_before: V : Type u_1
inst✝² : DecidableEq V
G : SimpleGraph V
s t : V
inst✝¹ : Fintype V
inst✝ : DecidableRel G.Adj
e : Sym2 V
he : e ∈ G.edgeFinset \ G.incidenceFinset t
⊢ ∀ b ∈ image (fun x => s(x, t)) (G.neighborFinset s), e ≠ b
state_after: V : Type u_1
inst✝² : DecidableEq V
G : SimpleGraph V
s t : V
inst✝¹ : Fintype V
inst✝ : DecidableRel G.Adj
e : Sym2 V
he : e ∈ G.edgeFinset \ G.incidenceFinset t
this : t ∉ e
⊢ ∀ b ∈ image (fun x => s(x, t)) (G.neighborFinset s), e ≠ b
tactic: have : t ∉ e := by
    rw [mem_sdiff, mem_incidenceFinset] at he
    obtain ⟨_, h⟩ := he
    contrapose! h
    simp_all [incidenceSet]
state_before: V : Type u_1
inst✝² : DecidableEq V
G : SimpleGraph V
s t : V
inst✝¹ : Fintype V
inst✝ : DecidableRel G.Adj
e : Sym2 V
he : e ∈ G.edgeFinset \ G.incidenceFinset t
this : t ∉ e
⊢ ∀ b ∈ image (fun x => s(x, t)) (G.neighborFinset s), e ≠ b
state_after: no goals
tactic: aesop
Theorem: sameRay_of_mem_segment
File: Mathlib/Analysis/Convex/Segment.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
ι : Type u_5
π : ι → Type u_6
inst✝² : StrictOrderedCommRing 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
x y z : E
h : x ∈ [y-[𝕜]z]
⊢ SameRay 𝕜 (x - y) (z - x)
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
ι : Type u_5
π : ι → Type u_6
inst✝² : StrictOrderedCommRing 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
x y z : E
h : x ∈ (fun θ => y + θ • (z - y)) '' Icc 0 1
⊢ SameRay 𝕜 (x - y) (z - x)
tactic: rw [segment_eq_image'] at h
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
ι : Type u_5
π : ι → Type u_6
inst✝² : StrictOrderedCommRing 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
x y z : E
h : x ∈ (fun θ => y + θ • (z - y)) '' Icc 0 1
⊢ SameRay 𝕜 (x - y) (z - x)
state_after: case intro.intro.intro
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
ι : Type u_5
π : ι → Type u_6
inst✝² : StrictOrderedCommRing 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
y z : E
θ : 𝕜
hθ₀ : 0 ≤ θ
hθ₁ : θ ≤ 1
⊢ SameRay 𝕜 ((fun θ => y + θ • (z - y)) θ - y) (z - (fun θ => y + θ • (z - y)) θ)
tactic: rcases h with ⟨θ, ⟨hθ₀, hθ₁⟩, rfl⟩
state_before: case intro.intro.intro
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
ι : Type u_5
π : ι → Type u_6
inst✝² : StrictOrderedCommRing 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
y z : E
θ : 𝕜
hθ₀ : 0 ≤ θ
hθ₁ : θ ≤ 1
⊢ SameRay 𝕜 ((fun θ => y + θ • (z - y)) θ - y) (z - (fun θ => y + θ • (z - y)) θ)
state_after: no goals
tactic: simpa only [add_sub_cancel_left, ← sub_sub, sub_smul, one_smul] using
    (SameRay.sameRay_nonneg_smul_left (z - y) hθ₀).nonneg_smul_right (sub_nonneg.2 hθ₁)
Theorem: HahnSeries.support_add_subset
File: Mathlib/RingTheory/HahnSeries/Addition.lean

Proof steps:
state_before: Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddMonoid R
x y : HahnSeries Γ R
a : Γ
ha : a ∈ (x + y).support
⊢ a ∈ x.support ∪ y.support
state_after: Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddMonoid R
x y : HahnSeries Γ R
a : Γ
ha : x.coeff a + y.coeff a ≠ 0
⊢ a ∈ x.support ∪ y.support
tactic: rw [mem_support, add_coeff] at ha
state_before: Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddMonoid R
x y : HahnSeries Γ R
a : Γ
ha : x.coeff a + y.coeff a ≠ 0
⊢ a ∈ x.support ∪ y.support
state_after: Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddMonoid R
x y : HahnSeries Γ R
a : Γ
ha : x.coeff a + y.coeff a ≠ 0
⊢ x.coeff a ≠ 0 ∨ y.coeff a ≠ 0
tactic: rw [Set.mem_union, mem_support, mem_support]
state_before: Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddMonoid R
x y : HahnSeries Γ R
a : Γ
ha : x.coeff a + y.coeff a ≠ 0
⊢ x.coeff a ≠ 0 ∨ y.coeff a ≠ 0
state_after: Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddMonoid R
x y : HahnSeries Γ R
a : Γ
ha : x.coeff a = 0 ∧ y.coeff a = 0
⊢ x.coeff a + y.coeff a = 0
tactic: contrapose! ha
state_before: Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddMonoid R
x y : HahnSeries Γ R
a : Γ
ha : x.coeff a = 0 ∧ y.coeff a = 0
⊢ x.coeff a + y.coeff a = 0
state_after: no goals
tactic: rw [ha.1, ha.2, add_zero]
Theorem: List.singleton_disjoint
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: α✝ : Type u_1
a : α✝
l : List α✝
⊢ [a].Disjoint l ↔ ¬a ∈ l
state_after: no goals
tactic: simp [Disjoint]
Theorem: Ordinal.cof_lsub_le_lift
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

Proof steps:
state_before: α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{max u v}
⊢ (lsub f).cof ≤ Cardinal.lift.{v, u} #ι
state_after: α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{max u v}
⊢ (lsub f).cof ≤ #(ULift.{v, u} ι)
tactic: rw [← mk_uLift.{u, v}]
state_before: α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{max u v}
⊢ (lsub f).cof ≤ #(ULift.{v, u} ι)
state_after: case h.e'_3.h.e'_1
α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{max u v}
⊢ lsub f = lsub fun i => f i.down
tactic: convert cof_lsub_le.{max u v} fun i : ULift.{v, u} ι => f i.down
state_before: case h.e'_3.h.e'_1
α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{max u v}
⊢ lsub f = lsub fun i => f i.down
state_after: no goals
tactic: exact
    lsub_eq_of_range_eq.{u, max u v, max u v}
      (Set.ext fun x => ⟨fun ⟨i, hi⟩ => ⟨ULift.up.{v, u} i, hi⟩, fun ⟨i, hi⟩ => ⟨_, hi⟩⟩)
Theorem: Nat.WithBot.lt_one_iff_le_zero
File: Mathlib/Data/Nat/WithBot.lean

Proof steps:
state_before: x : WithBot ℕ
⊢ ¬x < 1 ↔ ¬x ≤ 0
state_after: no goals
tactic: simpa using one_le_iff_zero_lt
Theorem: CliffordAlgebra.contractLeft_algebraMap_mul
File: Mathlib/LinearAlgebra/CliffordAlgebra/Contraction.lean

Proof steps:
state_before: R : Type u1
inst✝² : CommRing R
M : Type u2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
d d' : Module.Dual R M
r : R
b : CliffordAlgebra Q
⊢ (contractLeft d) ((algebraMap R (CliffordAlgebra Q)) r * b) =
    (algebraMap R (CliffordAlgebra Q)) r * (contractLeft d) b
state_after: no goals
tactic: rw [← Algebra.smul_def, map_smul, Algebra.smul_def]
Theorem: Matrix.rank_mul_eq_right_of_isUnit_det
File: Mathlib/Data/Matrix/Rank.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
inst✝⁴ : Fintype n
inst✝³ : Fintype o
inst✝² : CommRing R
inst✝¹ : Fintype m
inst✝ : DecidableEq m
A : Matrix m m R
B : Matrix m n R
hA : IsUnit A.det
⊢ (A * B).rank = B.rank
state_after: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
inst✝⁴ : Fintype n
inst✝³ : Fintype o
inst✝² : CommRing R
inst✝¹ : Fintype m
inst✝ : DecidableEq m
A : Matrix m m R
B : Matrix m n R
hA : IsUnit A.det
b : Basis m R (m → R) := Pi.basisFun R m
⊢ (A * B).rank = B.rank
tactic: let b : Basis m R (m → R) := Pi.basisFun R m
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
inst✝⁴ : Fintype n
inst✝³ : Fintype o
inst✝² : CommRing R
inst✝¹ : Fintype m
inst✝ : DecidableEq m
A : Matrix m m R
B : Matrix m n R
hA : IsUnit A.det
b : Basis m R (m → R) := Pi.basisFun R m
⊢ (A * B).rank = B.rank
state_after: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
inst✝⁴ : Fintype n
inst✝³ : Fintype o
inst✝² : CommRing R
inst✝¹ : Fintype m
inst✝ : DecidableEq m
A : Matrix m m R
B : Matrix m n R
b : Basis m R (m → R) := Pi.basisFun R m
hA : IsUnit ((LinearMap.toMatrix b b) A.mulVecLin).det
⊢ (A * B).rank = B.rank
tactic: replace hA : IsUnit (LinearMap.toMatrix b b A.mulVecLin).det := by
    convert hA; rw [← LinearEquiv.eq_symm_apply]; rfl
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
inst✝⁴ : Fintype n
inst✝³ : Fintype o
inst✝² : CommRing R
inst✝¹ : Fintype m
inst✝ : DecidableEq m
A : Matrix m m R
B : Matrix m n R
b : Basis m R (m → R) := Pi.basisFun R m
hA : IsUnit ((LinearMap.toMatrix b b) A.mulVecLin).det
⊢ (A * B).rank = B.rank
state_after: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
inst✝⁴ : Fintype n
inst✝³ : Fintype o
inst✝² : CommRing R
inst✝¹ : Fintype m
inst✝ : DecidableEq m
A : Matrix m m R
B : Matrix m n R
b : Basis m R (m → R) := Pi.basisFun R m
hA : IsUnit ((LinearMap.toMatrix b b) A.mulVecLin).det
hAB : (A * B).mulVecLin = ↑(LinearEquiv.ofIsUnitDet hA) ∘ₗ B.mulVecLin
⊢ (A * B).rank = B.rank
tactic: have hAB : mulVecLin (A * B) = (LinearEquiv.ofIsUnitDet hA).comp (mulVecLin B) := by ext; simp
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
inst✝⁴ : Fintype n
inst✝³ : Fintype o
inst✝² : CommRing R
inst✝¹ : Fintype m
inst✝ : DecidableEq m
A : Matrix m m R
B : Matrix m n R
b : Basis m R (m → R) := Pi.basisFun R m
hA : IsUnit ((LinearMap.toMatrix b b) A.mulVecLin).det
hAB : (A * B).mulVecLin = ↑(LinearEquiv.ofIsUnitDet hA) ∘ₗ B.mulVecLin
⊢ (A * B).rank = B.rank
state_after: no goals
tactic: rw [rank, rank, hAB, LinearMap.range_comp, LinearEquiv.finrank_map_eq]
Theorem: CategoryTheory.Limits.IsLimit.mkConeMorphism_lift
File: Mathlib/CategoryTheory/Limits/IsLimit.lean

Proof steps:
state_before: J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cone F
lift : (s : Cone F) → s ⟶ t
uniq : ∀ (s : Cone F) (m : s ⟶ t), m = lift s
s : Cone F
m : s.pt ⟶ t.pt
w : ∀ (j : J), m ≫ t.π.app j = s.π.app j
⊢ { hom := m, w := w } = lift s
state_after: no goals
tactic: apply uniq
Theorem: IsUnit.dvd_mul_right
File: Mathlib/Algebra/Divisibility/Units.lean

Proof steps:
state_before: α : Type u_1
inst✝ : Monoid α
a b u : α
hu : IsUnit u
⊢ a ∣ b * u ↔ a ∣ b
state_after: case intro
α : Type u_1
inst✝ : Monoid α
a b : α
u : αˣ
⊢ a ∣ b * ↑u ↔ a ∣ b
tactic: rcases hu with ⟨u, rfl⟩
state_before: case intro
α : Type u_1
inst✝ : Monoid α
a b : α
u : αˣ
⊢ a ∣ b * ↑u ↔ a ∣ b
state_after: no goals
tactic: apply Units.dvd_mul_right
Theorem: List.reduceOption_cons_of_some
File: Mathlib/Data/List/ReduceOption.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
x : α
l : List (Option α)
⊢ (some x :: l).reduceOption = x :: l.reduceOption
state_after: no goals
tactic: simp only [reduceOption, filterMap, id, eq_self_iff_true, and_self_iff]