ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Algebra.Presentation.localizationAway_dimension_zero
File: Mathlib/RingTheory/Presentation.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝³ : CommRing R
inst✝² : CommRing S
inst✝¹ : Algebra R S
P : Presentation R S
r : R
inst✝ : IsLocalization.Away r S
⊢ (localizationAway r).dimension = 0
state_after: no goals
tactic: simp [Presentation.dimension, localizationAway, Generators.localizationAway_vars]
Theorem: Cardinal.add_one_of_aleph0_le
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

Proof steps:
state_before: c : Cardinal.{u_1}
h : ℵ₀ ≤ c
⊢ c + 1 = c
state_after: c : Cardinal.{u_1}
h : ℵ₀ ≤ c
⊢ ω ≤ c.ord
tactic: rw [add_comm, ← card_ord c, ← card_one, ← card_add, one_add_of_omega_le]
state_before: c : Cardinal.{u_1}
h : ℵ₀ ≤ c
⊢ ω ≤ c.ord
state_after: no goals
tactic: rwa [← ord_aleph0, ord_le_ord]
Theorem: CategoryTheory.Localization.Construction.fac
File: Mathlib/CategoryTheory/Localization/Construction.lean

Proof steps:
state_before: C : Type uC
inst✝¹ : Category.{uC', uC} C
W : MorphismProperty C
D : Type uD
inst✝ : Category.{uD', uD} D
G : C ⥤ D
hG : W.IsInvertedBy G
⊢ ∀ (X Y : C) (f : X ⟶ Y), (W.Q ⋙ lift G hG).map f = eqToHom ⋯ ≫ G.map f ≫ eqToHom ⋯
state_after: C : Type uC
inst✝¹ : Category.{uC', uC} C
W : MorphismProperty C
D : Type uD
inst✝ : Category.{uD', uD} D
G : C ⥤ D
hG : W.IsInvertedBy G
X Y : C
f : X ⟶ Y
⊢ (W.Q ⋙ lift G hG).map f = eqToHom ⋯ ≫ G.map f ≫ eqToHom ⋯
tactic: intro X Y f
state_before: C : Type uC
inst✝¹ : Category.{uC', uC} C
W : MorphismProperty C
D : Type uD
inst✝ : Category.{uD', uD} D
G : C ⥤ D
hG : W.IsInvertedBy G
X Y : C
f : X ⟶ Y
⊢ (W.Q ⋙ lift G hG).map f = eqToHom ⋯ ≫ G.map f ≫ eqToHom ⋯
state_after: C : Type uC
inst✝¹ : Category.{uC', uC} C
W : MorphismProperty C
D : Type uD
inst✝ : Category.{uD', uD} D
G : C ⥤ D
hG : W.IsInvertedBy G
X Y : C
f : X ⟶ Y
⊢ (lift G hG).map (W.Q.map f) = G.map f
tactic: simp only [Functor.comp_map, eqToHom_refl, comp_id, id_comp]
state_before: C : Type uC
inst✝¹ : Category.{uC', uC} C
W : MorphismProperty C
D : Type uD
inst✝ : Category.{uD', uD} D
G : C ⥤ D
hG : W.IsInvertedBy G
X Y : C
f : X ⟶ Y
⊢ (lift G hG).map (W.Q.map f) = G.map f
state_after: C : Type uC
inst✝¹ : Category.{uC', uC} C
W : MorphismProperty C
D : Type uD
inst✝ : Category.{uD', uD} D
G : C ⥤ D
hG : W.IsInvertedBy G
X Y : C
f : X ⟶ Y
⊢ composePath (G.map f).toPath = G.map f
tactic: dsimp [MorphismProperty.Q, Quot.liftOn, Quotient.functor]
state_before: C : Type uC
inst✝¹ : Category.{uC', uC} C
W : MorphismProperty C
D : Type uD
inst✝ : Category.{uD', uD} D
G : C ⥤ D
hG : W.IsInvertedBy G
X Y : C
f : X ⟶ Y
⊢ composePath (G.map f).toPath = G.map f
state_after: no goals
tactic: rw [composePath_toPath]
Theorem: Multiset.mem_product
File: Mathlib/Data/Multiset/Bind.lean

Proof steps:
state_before: α : Type u_1
β : Type v
γ : Type u_2
δ : Type u_3
a✝ : α
b✝ : β
s : Multiset α
t : Multiset β
a : α
b : β
⊢ (a, b) ∈ s.product t ↔ (a, b).1 ∈ s ∧ (a, b).2 ∈ t
state_after: no goals
tactic: simp [product, and_left_comm]
Theorem: Multiset.sum_induction
File: Mathlib/Algebra/BigOperators/Group/Multiset.lean

Proof steps:
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : CommMonoid α
inst✝ : CommMonoid β
s✝ t : Multiset α
a : α
m : Multiset ι
f g : ι → α
p : α → Prop
s : Multiset α
p_mul : ∀ (a b : α), p a → p b → p (a * b)
p_one : p 1
p_s : ∀ a ∈ s, p a
⊢ p s.prod
state_after: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : CommMonoid α
inst✝ : CommMonoid β
s✝ t : Multiset α
a : α
m : Multiset ι
f g : ι → α
p : α → Prop
s : Multiset α
p_mul : ∀ (a b : α), p a → p b → p (a * b)
p_one : p 1
p_s : ∀ a ∈ s, p a
⊢ p (foldr (fun x x_1 => x * x_1) ⋯ 1 s)
tactic: rw [prod_eq_foldr]
Theorem: Mathlib.Vector.head_ofFn
File: Mathlib/Data/Vector/Basic.lean

Proof steps:
state_before: n✝ : ℕ
α : Type u_1
n : ℕ
f : Fin n.succ → α
⊢ (ofFn f).head = f 0
state_after: no goals
tactic: rw [← get_zero, get_ofFn]
Theorem: MonoidHom.noncommPiCoprod_mrange
File: Mathlib/GroupTheory/NoncommPiCoprod.lean

Proof steps:
state_before: M : Type u_1
inst✝³ : Monoid M
ι : Type u_2
inst✝² : DecidableEq ι
inst✝¹ : Fintype ι
N : ι → Type u_3
inst✝ : (i : ι) → Monoid (N i)
ϕ : (i : ι) → N i →* M
hcomm : Pairwise fun i j => ∀ (x : N i) (y : N j), Commute ((ϕ i) x) ((ϕ j) y)
f g : (i : ι) → N i
⊢ mrange (noncommPiCoprod ϕ hcomm) = ⨆ i, mrange (ϕ i)
state_after: M : Type u_1
inst✝³ : Monoid M
ι : Type u_2
inst✝² : DecidableEq ι
inst✝¹ : Fintype ι
N : ι → Type u_3
inst✝ : (i : ι) → Monoid (N i)
ϕ : (i : ι) → N i →* M
hcomm : Pairwise fun i j => ∀ (x : N i) (y : N j), Commute ((ϕ i) x) ((ϕ j) y)
f g : (i : ι) → N i
this : DecidableEq ι := Classical.decEq ι
⊢ mrange (noncommPiCoprod ϕ hcomm) = ⨆ i, mrange (ϕ i)
tactic: letI := Classical.decEq ι
state_before: M : Type u_1
inst✝³ : Monoid M
ι : Type u_2
inst✝² : DecidableEq ι
inst✝¹ : Fintype ι
N : ι → Type u_3
inst✝ : (i : ι) → Monoid (N i)
ϕ : (i : ι) → N i →* M
hcomm : Pairwise fun i j => ∀ (x : N i) (y : N j), Commute ((ϕ i) x) ((ϕ j) y)
f g : (i : ι) → N i
this : DecidableEq ι := Classical.decEq ι
⊢ mrange (noncommPiCoprod ϕ hcomm) = ⨆ i, mrange (ϕ i)
state_after: case a
M : Type u_1
inst✝³ : Monoid M
ι : Type u_2
inst✝² : DecidableEq ι
inst✝¹ : Fintype ι
N : ι → Type u_3
inst✝ : (i : ι) → Monoid (N i)
ϕ : (i : ι) → N i →* M
hcomm : Pairwise fun i j => ∀ (x : N i) (y : N j), Commute ((ϕ i) x) ((ϕ j) y)
f g : (i : ι) → N i
this : DecidableEq ι := Classical.decEq ι
⊢ mrange (noncommPiCoprod ϕ hcomm) ≤ ⨆ i, mrange (ϕ i)

case a
M : Type u_1
inst✝³ : Monoid M
ι : Type u_2
inst✝² : DecidableEq ι
inst✝¹ : Fintype ι
N : ι → Type u_3
inst✝ : (i : ι) → Monoid (N i)
ϕ : (i : ι) → N i →* M
hcomm : Pairwise fun i j => ∀ (x : N i) (y : N j), Commute ((ϕ i) x) ((ϕ j) y)
f g : (i : ι) → N i
this : DecidableEq ι := Classical.decEq ι
⊢ ⨆ i, mrange (ϕ i) ≤ mrange (noncommPiCoprod ϕ hcomm)
tactic: apply le_antisymm
Theorem: IsPicardLindelof.exists_forall_hasDerivWithinAt_Icc_eq
File: Mathlib/Analysis/ODE/PicardLindelof.lean

Proof steps:
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
v : ℝ → E → E
tMin t₀ tMax : ℝ
x₀ : E
C R : ℝ
L : ℝ≥0
hpl : IsPicardLindelof v tMin t₀ tMax x₀ L R C
⊢ ∃ f, f t₀ = x₀ ∧ ∀ t ∈ Icc tMin tMax, HasDerivWithinAt f (v t (f t)) (Icc tMin tMax) t
state_after: case intro
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
v : ℝ → E → E
tMin t₀ tMax : ℝ
x₀ : E
R : ℝ
L C : ℝ≥0
hpl : IsPicardLindelof v tMin t₀ tMax x₀ L R ↑C
⊢ ∃ f, f t₀ = x₀ ∧ ∀ t ∈ Icc tMin tMax, HasDerivWithinAt f (v t (f t)) (Icc tMin tMax) t
tactic: lift C to ℝ≥0 using (norm_nonneg _).trans hpl.norm_le₀
state_before: case intro
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
v : ℝ → E → E
tMin t₀ tMax : ℝ
x₀ : E
R : ℝ
L C : ℝ≥0
hpl : IsPicardLindelof v tMin t₀ tMax x₀ L R ↑C
⊢ ∃ f, f t₀ = x₀ ∧ ∀ t ∈ Icc tMin tMax, HasDerivWithinAt f (v t (f t)) (Icc tMin tMax) t
state_after: case intro.intro
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
v : ℝ → E → E
tMin tMax : ℝ
x₀ : E
R : ℝ
L C : ℝ≥0
t₀ : { x // x ∈ Icc tMin tMax }
hpl : IsPicardLindelof v tMin (↑t₀) tMax x₀ L R ↑C
⊢ ∃ f, f ↑t₀ = x₀ ∧ ∀ t ∈ Icc tMin tMax, HasDerivWithinAt f (v t (f t)) (Icc tMin tMax) t
tactic: lift t₀ to Icc tMin tMax using hpl.ht₀
state_before: case intro.intro
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
v : ℝ → E → E
tMin tMax : ℝ
x₀ : E
R : ℝ
L C : ℝ≥0
t₀ : { x // x ∈ Icc tMin tMax }
hpl : IsPicardLindelof v tMin (↑t₀) tMax x₀ L R ↑C
⊢ ∃ f, f ↑t₀ = x₀ ∧ ∀ t ∈ Icc tMin tMax, HasDerivWithinAt f (v t (f t)) (Icc tMin tMax) t
state_after: no goals
tactic: exact PicardLindelof.exists_solution
    ⟨v, tMin, tMax, t₀, x₀, C, ⟨R, hpl.hR⟩, L, { hpl with ht₀ := t₀.property }⟩
Theorem: Surreal.Multiplication.Args.numeric_P1
File: Mathlib/SetTheory/Surreal/Multiplication.lean

Proof steps:
state_before: x✝ x₁ x₂ x₃ x' y✝ y₁ y₂ y₃ y' : PGame
x y : PGame
⊢ (P1 x y).Numeric ↔ x.Numeric ∧ y.Numeric
state_after: no goals
tactic: simp [Args.Numeric, Args.toMultiset]
Theorem: AddAction.movedBy_mem_fixedBy_of_addCommute
File: Mathlib/GroupTheory/GroupAction/FixedPoints.lean

Proof steps:
state_before: α : Type u_1
G : Type u_2
inst✝³ : Group G
inst✝² : MulAction G α
M : Type u_3
inst✝¹ : Monoid M
inst✝ : MulAction M α
g h : G
comm : Commute g h
⊢ (fixedBy α g)ᶜ ∈ fixedBy (Set α) h
state_after: no goals
tactic: rw [mem_fixedBy, Set.smul_set_compl, fixedBy_mem_fixedBy_of_commute comm]
Theorem: PicardLindelof.FunSpace.mem_closedBall
File: Mathlib/Analysis/ODE/PicardLindelof.lean

Proof steps:
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
v : PicardLindelof E
f : v.FunSpace
t : ↑(Icc v.tMin v.tMax)
⊢ dist (f.toFun t) v.x₀ = dist (f.toFun t) (f.toFun v.t₀)
state_after: no goals
tactic: rw [f.map_t₀']
Theorem: AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion.lift_fac
File: Mathlib/Geometry/RingedSpace/OpenImmersion.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y Z : LocallyRingedSpace
f : X ⟶ Z
g : Y ⟶ Z
H : IsOpenImmersion f
H' : Set.range ⇑g.val.base ⊆ Set.range ⇑f.val.base
⊢ lift f g H' ≫ f = g
state_after: C : Type u
inst✝ : Category.{v, u} C
X Y Z : LocallyRingedSpace
f : X ⟶ Z
g : Y ⟶ Z
H : IsOpenImmersion f
H' : Set.range ⇑g.val.base ⊆ Set.range ⇑f.val.base
⊢ inv (pullback.snd f g) ≫ pullback.fst f g ≫ f = g
tactic: erw [Category.assoc]
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y Z : LocallyRingedSpace
f : X ⟶ Z
g : Y ⟶ Z
H : IsOpenImmersion f
H' : Set.range ⇑g.val.base ⊆ Set.range ⇑f.val.base
⊢ inv (pullback.snd f g) ≫ pullback.fst f g ≫ f = g
state_after: C : Type u
inst✝ : Category.{v, u} C
X Y Z : LocallyRingedSpace
f : X ⟶ Z
g : Y ⟶ Z
H : IsOpenImmersion f
H' : Set.range ⇑g.val.base ⊆ Set.range ⇑f.val.base
⊢ pullback.fst f g ≫ f = pullback.snd f g ≫ g
tactic: rw [IsIso.inv_comp_eq]
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y Z : LocallyRingedSpace
f : X ⟶ Z
g : Y ⟶ Z
H : IsOpenImmersion f
H' : Set.range ⇑g.val.base ⊆ Set.range ⇑f.val.base
⊢ pullback.fst f g ≫ f = pullback.snd f g ≫ g
state_after: no goals
tactic: exact pullback.condition
Theorem: Set.seq_seq
File: Mathlib/Data/Set/Lattice.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
s : Set (β → γ)
t : Set (α → β)
u : Set α
⊢ s.seq (t.seq u) = (((fun x x_1 => x ∘ x_1) '' s).seq t).seq u
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
s : Set (β → γ)
t : Set (α → β)
u : Set α
⊢ image2 (fun f a => f a) s (image2 (fun f a => f a) t u) =
    image2 (fun f a => f a) (image2 (fun x x_1 => x ∘ x_1) s t) u
tactic: simp only [seq_eq_image2, image2_image_left]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
s : Set (β → γ)
t : Set (α → β)
u : Set α
⊢ image2 (fun f a => f a) s (image2 (fun f a => f a) t u) =
    image2 (fun f a => f a) (image2 (fun x x_1 => x ∘ x_1) s t) u
state_after: no goals
tactic: exact .symm <| image2_assoc fun _ _ _ ↦ rfl
Theorem: Pell.dz_val
File: Mathlib/NumberTheory/PellMatiyasevic.lean

Proof steps:
state_before: a : ℕ
a1 : 1 < a
this : 1 ≤ a * a
⊢ ↑(Pell.d a1) = az a * az a - 1
state_after: a : ℕ
a1 : 1 < a
this : 1 ≤ a * a
⊢ ↑(a * a) - ↑1 = az a * az a - 1
tactic: rw [Pell.d, Int.ofNat_sub this]
state_before: a : ℕ
a1 : 1 < a
this : 1 ≤ a * a
⊢ ↑(a * a) - ↑1 = az a * az a - 1
state_after: no goals
tactic: rfl
Theorem: IsSelfAdjoint.coe_selfAdjointPart_apply
File: Mathlib/Algebra/Star/Module.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
inst✝⁷ : Semiring R
inst✝⁶ : StarMul R
inst✝⁵ : TrivialStar R
inst✝⁴ : AddCommGroup A
inst✝³ : Module R A
inst✝² : StarAddMonoid A
inst✝¹ : StarModule R A
inst✝ : Invertible 2
x : A
hx : IsSelfAdjoint x
⊢ ↑((selfAdjointPart R) x) = x
state_after: no goals
tactic: rw [selfAdjointPart_apply_coe, hx.star_eq, smul_add, invOf_two_smul_add_invOf_two_smul]
Theorem: Finset.offDiag_filter_lt_eq_filter_le
File: Mathlib/Data/Finset/Prod.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝⁴ : DecidableEq α
s✝ t : Finset α
x : α × α
a : α
ι : Type u_4
inst✝³ : PartialOrder ι
inst✝² : DecidableEq ι
inst✝¹ : DecidableRel LE.le
inst✝ : DecidableRel LT.lt
s : Finset ι
⊢ filter (fun i => i.1 < i.2) s.offDiag = filter (fun i => i.1 ≤ i.2) s.offDiag
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝⁴ : DecidableEq α
s✝ t : Finset α
x : α × α
a : α
ι : Type u_4
inst✝³ : PartialOrder ι
inst✝² : DecidableEq ι
inst✝¹ : DecidableRel LE.le
inst✝ : DecidableRel LT.lt
s : Finset ι
⊢ ∀ ⦃a : ι × ι⦄, a ∈ s.offDiag → (a.1 < a.2 ↔ a.1 ≤ a.2)
tactic: rw [Finset.filter_inj']
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝⁴ : DecidableEq α
s✝ t : Finset α
x : α × α
a : α
ι : Type u_4
inst✝³ : PartialOrder ι
inst✝² : DecidableEq ι
inst✝¹ : DecidableRel LE.le
inst✝ : DecidableRel LT.lt
s : Finset ι
⊢ ∀ ⦃a : ι × ι⦄, a ∈ s.offDiag → (a.1 < a.2 ↔ a.1 ≤ a.2)
state_after: case mk
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝⁴ : DecidableEq α
s✝ t : Finset α
x : α × α
a : α
ι : Type u_4
inst✝³ : PartialOrder ι
inst✝² : DecidableEq ι
inst✝¹ : DecidableRel LE.le
inst✝ : DecidableRel LT.lt
s : Finset ι
i j : ι
⊢ (i, j) ∈ s.offDiag → ((i, j).1 < (i, j).2 ↔ (i, j).1 ≤ (i, j).2)
tactic: rintro ⟨i, j⟩
state_before: case mk
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝⁴ : DecidableEq α
s✝ t : Finset α
x : α × α
a : α
ι : Type u_4
inst✝³ : PartialOrder ι
inst✝² : DecidableEq ι
inst✝¹ : DecidableRel LE.le
inst✝ : DecidableRel LT.lt
s : Finset ι
i j : ι
⊢ (i, j) ∈ s.offDiag → ((i, j).1 < (i, j).2 ↔ (i, j).1 ≤ (i, j).2)
state_after: case mk
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝⁴ : DecidableEq α
s✝ t : Finset α
x : α × α
a : α
ι : Type u_4
inst✝³ : PartialOrder ι
inst✝² : DecidableEq ι
inst✝¹ : DecidableRel LE.le
inst✝ : DecidableRel LT.lt
s : Finset ι
i j : ι
⊢ i ∈ s → j ∈ s → i ≠ j → (i < j ↔ i ≤ j)
tactic: simp_rw [mem_offDiag, and_imp]
state_before: case mk
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝⁴ : DecidableEq α
s✝ t : Finset α
x : α × α
a : α
ι : Type u_4
inst✝³ : PartialOrder ι
inst✝² : DecidableEq ι
inst✝¹ : DecidableRel LE.le
inst✝ : DecidableRel LT.lt
s : Finset ι
i j : ι
⊢ i ∈ s → j ∈ s → i ≠ j → (i < j ↔ i ≤ j)
state_after: case mk
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝⁴ : DecidableEq α
s✝ t : Finset α
x : α × α
a : α
ι : Type u_4
inst✝³ : PartialOrder ι
inst✝² : DecidableEq ι
inst✝¹ : DecidableRel LE.le
inst✝ : DecidableRel LT.lt
s : Finset ι
i j : ι
a✝¹ : i ∈ s
a✝ : j ∈ s
h : i ≠ j
⊢ i < j ↔ i ≤ j
tactic: rintro _ _ h
state_before: case mk
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝⁴ : DecidableEq α
s✝ t : Finset α
x : α × α
a : α
ι : Type u_4
inst✝³ : PartialOrder ι
inst✝² : DecidableEq ι
inst✝¹ : DecidableRel LE.le
inst✝ : DecidableRel LT.lt
s : Finset ι
i j : ι
a✝¹ : i ∈ s
a✝ : j ∈ s
h : i ≠ j
⊢ i < j ↔ i ≤ j
state_after: no goals
tactic: rw [Ne.le_iff_lt h]
Theorem: Bool.bne_eq_xor
File: Mathlib/Data/Bool/Basic.lean

Proof steps:
state_before: ⊢ bne = xor
state_after: case h.h
a b : Bool
⊢ (a != b) = xor a b
tactic: funext a b
state_before: case h.h
a b : Bool
⊢ (a != b) = xor a b
state_after: case h.h

⊢ ∀ (a b : Bool), (a != b) = xor a b
tactic: revert a b
state_before: case h.h

⊢ ∀ (a b : Bool), (a != b) = xor a b
state_after: no goals
tactic: decide
Theorem: CochainComplex.XIsoOfEq_shift
File: Mathlib/Algebra/Homology/HomotopyCategory/Shift.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : Preadditive D
K : CochainComplex C ℤ
n p q : ℤ
hpq : p = q
⊢ p + n = q + n
state_after: no goals
tactic: rw [hpq]
Theorem: List.merge_loop
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: α : Type u_1
s : α → α → Bool
l r t : List α
⊢ merge.loop s l r t = t.reverseAux (merge s l r)
state_after: α : Type u_1
s : α → α → Bool
l r t : List α
⊢ merge.loop s l r t = t.reverseAux (merge.loop s l r [])
tactic: rw [merge]
state_before: α : Type u_1
s : α → α → Bool
l r t : List α
⊢ merge.loop s l r t = t.reverseAux (merge.loop s l r [])
state_after: α : Type u_1
s : α → α → Bool
l r t : List α
n : Nat
hn : l.length + r.length = n
⊢ merge.loop s l r t = t.reverseAux (merge.loop s l r [])
tactic: generalize hn : l.length + r.length = n
Theorem: HasSum.even_add_odd
File: Mathlib/Topology/Algebra/InfiniteSum/NatInt.lean

Proof steps:
state_before: M : Type u_1
inst✝³ : CommMonoid M
inst✝² : TopologicalSpace M
m m' : M
G : Type u_2
inst✝¹ : CommGroup G
g g' : G
inst✝ : ContinuousMul M
f : ℕ → M
he : HasProd (fun k => f (2 * k)) m
ho : HasProd (fun k => f (2 * k + 1)) m'
⊢ HasProd f (m * m')
state_after: M : Type u_1
inst✝³ : CommMonoid M
inst✝² : TopologicalSpace M
m m' : M
G : Type u_2
inst✝¹ : CommGroup G
g g' : G
inst✝ : ContinuousMul M
f : ℕ → M
he : HasProd (fun k => f (2 * k)) m
ho : HasProd (fun k => f (2 * k + 1)) m'
this : Injective fun x => 2 * x
⊢ HasProd f (m * m')
tactic: have := mul_right_injective₀ (two_ne_zero' ℕ)
state_before: M : Type u_1
inst✝³ : CommMonoid M
inst✝² : TopologicalSpace M
m m' : M
G : Type u_2
inst✝¹ : CommGroup G
g g' : G
inst✝ : ContinuousMul M
f : ℕ → M
he : HasProd (fun k => f (2 * k)) m
ho : HasProd (fun k => f (2 * k + 1)) m'
this : Injective fun x => 2 * x
⊢ HasProd f (m * m')
state_after: M : Type u_1
inst✝³ : CommMonoid M
inst✝² : TopologicalSpace M
m m' : M
G : Type u_2
inst✝¹ : CommGroup G
g g' : G
inst✝ : ContinuousMul M
f : ℕ → M
he : HasProd (fun k => f (2 * k)) m
this : Injective fun x => 2 * x
ho : HasProd (fun x => f ↑x) m'
⊢ HasProd f (m * m')
tactic: replace ho := ((add_left_injective 1).comp this).hasProd_range_iff.2 ho
state_before: M : Type u_1
inst✝³ : CommMonoid M
inst✝² : TopologicalSpace M
m m' : M
G : Type u_2
inst✝¹ : CommGroup G
g g' : G
inst✝ : ContinuousMul M
f : ℕ → M
he : HasProd (fun k => f (2 * k)) m
this : Injective fun x => 2 * x
ho : HasProd (fun x => f ↑x) m'
⊢ HasProd f (m * m')
state_after: M : Type u_1
inst✝³ : CommMonoid M
inst✝² : TopologicalSpace M
m m' : M
G : Type u_2
inst✝¹ : CommGroup G
g g' : G
inst✝ : ContinuousMul M
f : ℕ → M
he : HasProd (fun k => f (2 * k)) m
this : Injective fun x => 2 * x
ho : HasProd (fun x => f ↑x) m'
⊢ IsCompl (Set.range fun x => 2 * x) (Set.range ((fun x => x + 1) ∘ fun x => 2 * x))
tactic: refine (this.hasProd_range_iff.2 he).mul_isCompl ?_ ho
Theorem: collinear_insert_of_mem_affineSpan_pair
File: Mathlib/LinearAlgebra/AffineSpace/FiniteDimensional.lean

Proof steps:
state_before: k : Type u_1
V : Type u_2
P : Type u_3
ι : Type u_4
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p₁ p₂ p₃ : P
h : p₁ ∈ affineSpan k {p₂, p₃}
⊢ Collinear k {p₁, p₂, p₃}
state_after: k : Type u_1
V : Type u_2
P : Type u_3
ι : Type u_4
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p₁ p₂ p₃ : P
h : p₁ ∈ affineSpan k {p₂, p₃}
⊢ Collinear k {p₂, p₃}
tactic: rw [collinear_insert_iff_of_mem_affineSpan h]
state_before: k : Type u_1
V : Type u_2
P : Type u_3
ι : Type u_4
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p₁ p₂ p₃ : P
h : p₁ ∈ affineSpan k {p₂, p₃}
⊢ Collinear k {p₂, p₃}
state_after: no goals
tactic: exact collinear_pair _ _ _
Theorem: gauge_add_le
File: Mathlib/Analysis/Convex/Gauge.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
s t : Set E
x✝ : E
a : ℝ
hs : Convex ℝ s
absorbs : Absorbent ℝ s
x y : E
⊢ gauge s (x + y) ≤ gauge s x + gauge s y
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
s t : Set E
x✝ : E
a : ℝ
hs : Convex ℝ s
absorbs : Absorbent ℝ s
x y : E
ε : ℝ
hε : 0 < ε
⊢ gauge s (x + y) < gauge s x + gauge s y + ε
tactic: refine le_of_forall_pos_lt_add fun ε hε => ?_
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
s t : Set E
x✝ : E
a : ℝ
hs : Convex ℝ s
absorbs : Absorbent ℝ s
x y : E
ε : ℝ
hε : 0 < ε
⊢ gauge s (x + y) < gauge s x + gauge s y + ε
state_after: case intro.intro.intro.intro.intro
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
s t : Set E
x✝ : E
a✝ : ℝ
hs : Convex ℝ s
absorbs : Absorbent ℝ s
y : E
ε : ℝ
hε : 0 < ε
a : ℝ
ha : 0 < a
x : E
hx : x ∈ s
ha' : a < gauge s ((fun x => a • x) x) + ε / 2
⊢ gauge s ((fun x => a • x) x + y) < gauge s ((fun x => a • x) x) + gauge s y + ε
tactic: obtain ⟨a, ha, ha', x, hx, rfl⟩ :=
    exists_lt_of_gauge_lt absorbs (lt_add_of_pos_right (gauge s x) (half_pos hε))
state_before: case intro.intro.intro.intro.intro
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
s t : Set E
x✝ : E
a✝ : ℝ
hs : Convex ℝ s
absorbs : Absorbent ℝ s
y : E
ε : ℝ
hε : 0 < ε
a : ℝ
ha : 0 < a
x : E
hx : x ∈ s
ha' : a < gauge s ((fun x => a • x) x) + ε / 2
⊢ gauge s ((fun x => a • x) x + y) < gauge s ((fun x => a • x) x) + gauge s y + ε
state_after: case intro.intro.intro.intro.intro.intro.intro.intro.intro.intro
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
s t : Set E
x✝ : E
a✝ : ℝ
hs : Convex ℝ s
absorbs : Absorbent ℝ s
ε : ℝ
hε : 0 < ε
a : ℝ
ha : 0 < a
x : E
hx : x ∈ s
ha' : a < gauge s ((fun x => a • x) x) + ε / 2
b : ℝ
hb : 0 < b
y : E
hy : y ∈ s
hb' : b < gauge s ((fun x => b • x) y) + ε / 2
⊢ gauge s ((fun x => a • x) x + (fun x => b • x) y) < gauge s ((fun x => a • x) x) + gauge s ((fun x => b • x) y) + ε
tactic: obtain ⟨b, hb, hb', y, hy, rfl⟩ :=
    exists_lt_of_gauge_lt absorbs (lt_add_of_pos_right (gauge s y) (half_pos hε))
state_before: case intro.intro.intro.intro.intro.intro.intro.intro.intro.intro
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
s t : Set E
x✝ : E
a✝ : ℝ
hs : Convex ℝ s
absorbs : Absorbent ℝ s
ε : ℝ
hε : 0 < ε
a : ℝ
ha : 0 < a
x : E
hx : x ∈ s
ha' : a < gauge s ((fun x => a • x) x) + ε / 2
b : ℝ
hb : 0 < b
y : E
hy : y ∈ s
hb' : b < gauge s ((fun x => b • x) y) + ε / 2
⊢ gauge s ((fun x => a • x) x + (fun x => b • x) y) < gauge s ((fun x => a • x) x) + gauge s ((fun x => b • x) y) + ε
state_after: no goals
tactic: calc
    gauge s (a • x + b • y) ≤ a + b := gauge_le_of_mem (by positivity) <| by
      rw [hs.add_smul ha.le hb.le]
      exact add_mem_add (smul_mem_smul_set hx) (smul_mem_smul_set hy)
    _ < gauge s (a • x) + gauge s (b • y) + ε := by linarith
Theorem: Finset.ofDual_min'
File: Mathlib/Data/Finset/Lattice.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : LinearOrder α
s✝ : Finset α
H : s✝.Nonempty
x : α
s : Finset αᵒᵈ
hs : s.Nonempty
⊢ ofDual (s.min' hs) = (image (⇑ofDual) s).max' ⋯
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : LinearOrder α
s✝ : Finset α
H : s✝.Nonempty
x : α
s : Finset αᵒᵈ
hs : s.Nonempty
⊢ ↑(ofDual (s.min' hs)) = ↑((image (⇑ofDual) s).max' ⋯)
tactic: rw [← WithBot.coe_eq_coe]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : LinearOrder α
s✝ : Finset α
H : s✝.Nonempty
x : α
s : Finset αᵒᵈ
hs : s.Nonempty
⊢ ↑(ofDual (s.min' hs)) = ↑((image (⇑ofDual) s).max' ⋯)
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : LinearOrder α
s✝ : Finset α
H : s✝.Nonempty
x : α
s : Finset αᵒᵈ
hs : s.Nonempty
⊢ s.sup (WithBot.some ∘ fun x => ofDual x) = s.sup ((WithBot.some ∘ fun x => x) ∘ ⇑ofDual)
tactic: simp only [min'_eq_inf', id_eq, ofDual_inf', Function.comp_apply, coe_sup', max'_eq_sup',
    sup_image]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : LinearOrder α
s✝ : Finset α
H : s✝.Nonempty
x : α
s : Finset αᵒᵈ
hs : s.Nonempty
⊢ s.sup (WithBot.some ∘ fun x => ofDual x) = s.sup ((WithBot.some ∘ fun x => x) ∘ ⇑ofDual)
state_after: no goals
tactic: rfl