ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CategoryTheory.Functor.compConstIso_inv_app_app
File: Mathlib/CategoryTheory/Functor/Const.lean

Proof steps:
state_before: J : Type u₁
inst✝² : Category.{v₁, u₁} J
C : Type u₂
inst✝¹ : Category.{v₂, u₂} C
D : Type u₃
inst✝ : Category.{v₃, u₃} D
F : C ⥤ D
X : C
⊢ ∀ {X_1 Y : J} (f : X_1 ⟶ Y),
    ((F ⋙ const J).obj X).map f ≫ ((fun j => Iso.refl (((F ⋙ const J).obj X).obj j)) Y).hom =
      ((fun j => Iso.refl (((F ⋙ const J).obj X).obj j)) X_1).hom ≫
        ((const J ⋙ (whiskeringRight J C D).obj F).obj X).map f
state_after: no goals
tactic: aesop_cat
state_before: J : Type u₁
inst✝² : Category.{v₁, u₁} J
C : Type u₂
inst✝¹ : Category.{v₂, u₂} C
D : Type u₃
inst✝ : Category.{v₃, u₃} D
F : C ⥤ D
⊢ ∀ {X Y : C} (f : X ⟶ Y),
    (F ⋙ const J).map f ≫ ((fun X => NatIso.ofComponents (fun j => Iso.refl (((F ⋙ const J).obj X).obj j)) ⋯) Y).hom =
      ((fun X => NatIso.ofComponents (fun j => Iso.refl (((F ⋙ const J).obj X).obj j)) ⋯) X).hom ≫
        (const J ⋙ (whiskeringRight J C D).obj F).map f
state_after: no goals
tactic: aesop_cat
Theorem: Set.Ioc_add_bij
File: Mathlib/Algebra/Order/Interval/Set/Monoid.lean

Proof steps:
state_before: M : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid M
inst✝ : ExistsAddOfLE M
a b c d : M
⊢ BijOn (fun x => x + d) (Ioc a b) (Ioc (a + d) (b + d))
state_after: M : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid M
inst✝ : ExistsAddOfLE M
a b c d : M
⊢ BijOn (fun x => x + d) (Ioi a ∩ Iic b) (Ioi (a + d) ∩ Iic (b + d))
tactic: rw [← Ioi_inter_Iic, ← Ioi_inter_Iic]
state_before: M : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid M
inst✝ : ExistsAddOfLE M
a b c d : M
⊢ BijOn (fun x => x + d) (Ioi a ∩ Iic b) (Ioi (a + d) ∩ Iic (b + d))
state_after: no goals
tactic: exact
    (Ioi_add_bij a d).inter_mapsTo (fun x hx => add_le_add_right hx _) fun x hx =>
      le_of_add_le_add_right hx.2
Theorem: CategoryTheory.NonPreadditiveAbelian.add_zero
File: Mathlib/CategoryTheory/Abelian/NonPreadditive.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : NonPreadditiveAbelian C
X Y : C
a : X ⟶ Y
⊢ a + 0 = a
state_after: no goals
tactic: rw [add_def, neg_def, sub_self, sub_zero]
Theorem: Set.pow_subset_pow
File: Mathlib/Data/Set/Pointwise/Basic.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : Monoid α
s t : Set α
a : α
m n : ℕ
hst : s ⊆ t
⊢ s ^ 0 ⊆ t ^ 0
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : Monoid α
s t : Set α
a : α
m n : ℕ
hst : s ⊆ t
⊢ 1 ⊆ t ^ 0
tactic: rw [pow_zero]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : Monoid α
s t : Set α
a : α
m n : ℕ
hst : s ⊆ t
⊢ 1 ⊆ t ^ 0
state_after: no goals
tactic: exact Subset.rfl
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : Monoid α
s t : Set α
a : α
m n✝ : ℕ
hst : s ⊆ t
n : ℕ
⊢ s ^ (n + 1) ⊆ t ^ (n + 1)
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : Monoid α
s t : Set α
a : α
m n✝ : ℕ
hst : s ⊆ t
n : ℕ
⊢ s ^ n * s ⊆ t ^ (n + 1)
tactic: rw [pow_succ]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : Monoid α
s t : Set α
a : α
m n✝ : ℕ
hst : s ⊆ t
n : ℕ
⊢ s ^ n * s ⊆ t ^ (n + 1)
state_after: no goals
tactic: exact mul_subset_mul (pow_subset_pow hst _) hst
Theorem: Monoid.fg_of_surjective
File: Mathlib/GroupTheory/Finiteness.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
inst✝³ : Monoid M
inst✝² : AddMonoid N
M' : Type u_3
inst✝¹ : Monoid M'
inst✝ : FG M
f : M →* M'
hf : Function.Surjective ⇑f
⊢ FG M'
state_after: no goals
tactic: classical
    obtain ⟨s, hs⟩ := Monoid.fg_def.mp ‹_›
    use s.image f
    rwa [Finset.coe_image, ← MonoidHom.map_mclosure, hs, ← MonoidHom.mrange_eq_map,
      MonoidHom.mrange_top_iff_surjective]
Theorem: ArithmeticFunction.LSeries_zeta_eq
File: Mathlib/NumberTheory/LSeries/Dirichlet.lean

Proof steps:
state_before: ⊢ (L fun n => ↑(ζ n)) = L 1
state_after: case h
s : ℂ
⊢ L (fun n => ↑(ζ n)) s = L 1 s
tactic: ext s
state_before: case h
s : ℂ
⊢ L (fun n => ↑(ζ n)) s = L 1 s
state_after: no goals
tactic: exact (LSeries_congr s const_one_eq_zeta).symm
Theorem: Finset.Nonempty.eq_univ
File: Mathlib/Data/Fintype/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : Fintype α
s t : Finset α
inst✝ : Subsingleton α
⊢ s.Nonempty → s = univ
state_after: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : Fintype α
s t : Finset α
inst✝ : Subsingleton α
x : α
hx : x ∈ s
⊢ s = univ
tactic: rintro ⟨x, hx⟩
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : Fintype α
s t : Finset α
inst✝ : Subsingleton α
x : α
hx : x ∈ s
⊢ s = univ
state_after: no goals
tactic: exact eq_univ_of_forall fun y => by rwa [Subsingleton.elim y x]
Theorem: SimpleGraph.sum_incMatrix_apply_of_mem_edgeSet
File: Mathlib/Combinatorics/SimpleGraph/IncMatrix.lean

Proof steps:
state_before: R : Type u_1
α : Type u_2
G : SimpleGraph α
inst✝² : Fintype (Sym2 α)
inst✝¹ : NonAssocSemiring R
a b : α
e : Sym2 α
inst✝ : Fintype α
⊢ e ∈ G.edgeSet → ∑ a : α, incMatrix R G a e = 2
state_after: no goals
tactic: classical
    refine e.ind ?_
    intro a b h
    rw [mem_edgeSet] at h
    rw [← Nat.cast_two, ← card_pair h.ne]
    simp only [incMatrix_apply', sum_boole, mk'_mem_incidenceSet_iff, h, true_and_iff]
    congr 2
    ext e
    simp only [mem_filter, mem_univ, true_and_iff, mem_insert, mem_singleton]
Theorem: LiouvilleWith.int_mul_iff
File: Mathlib/NumberTheory/Liouville/LiouvilleWith.lean

Proof steps:
state_before: p q x y : ℝ
r : ℚ
m : ℤ
n : ℕ
hm : m ≠ 0
⊢ LiouvilleWith p (↑m * x) ↔ LiouvilleWith p x
state_after: no goals
tactic: rw [mul_comm, mul_int_iff hm]
Theorem: MeasureTheory.Measure.map_mono
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t : Set α
f✝ f : α → β
h : μ ≤ ν
hf : Measurable f
s : Set β
hs : MeasurableSet s
⊢ (map f μ) s ≤ (map f ν) s
state_after: no goals
tactic: simp [hf.aemeasurable, hs, h _]
Theorem: Cardinal.mk_eq_nat_iff
File: Mathlib/SetTheory/Cardinal/Basic.lean

Proof steps:
state_before: α✝ β α : Type u
n : ℕ
⊢ #α = ↑n ↔ Nonempty (α ≃ Fin n)
state_after: no goals
tactic: rw [← lift_mk_fin, ← lift_uzero #α, lift_mk_eq']
Theorem: Mathlib.Meta.NormNum.isRat_inv_zero
File: Mathlib/Tactic/NormNum/Inv.lean

Proof steps:
state_before: u : Lean.Level
α : Type u_1
inst✝ : DivisionRing α
⊢ (↑0)⁻¹ = ↑0
state_after: no goals
tactic: simp
Theorem: MeasureTheory.Integrable.to_average
File: Mathlib/MeasureTheory/Function/L1Space.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → β
h : Integrable f μ
⊢ Integrable f ((μ univ)⁻¹ • μ)
state_after: case inl
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → β
h : Integrable f 0
⊢ Integrable f ((0 univ)⁻¹ • 0)

case inr
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → β
h : Integrable f μ
hne : μ ≠ 0
⊢ Integrable f ((μ univ)⁻¹ • μ)
tactic: rcases eq_or_ne μ 0 with (rfl | hne)
Theorem: Matrix.nnnorm_col
File: Mathlib/Analysis/Matrix.lean

Proof steps:
state_before: R : Type u_1
l : Type u_2
m : Type u_3
n : Type u_4
α : Type u_5
β : Type u_6
ι : Type u_7
inst✝⁵ : Fintype l
inst✝⁴ : Fintype m
inst✝³ : Fintype n
inst✝² : Unique ι
inst✝¹ : SeminormedAddCommGroup α
inst✝ : SeminormedAddCommGroup β
v : m → α
⊢ ‖col ι v‖₊ = ‖v‖₊
state_after: no goals
tactic: simp [nnnorm_def, Pi.nnnorm_def]
Theorem: Set.sInter_eq_compl_sUnion_compl
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 (Set α)
⊢ ⋂₀ S = (⋃₀ (compl '' S))ᶜ
state_after: no goals
tactic: rw [← compl_compl (⋂₀ S), compl_sInter]
Theorem: WithBot.unbot_le_iff
File: Mathlib/Order/WithBot.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a✝ b✝ : α
inst✝ : LE α
a : WithBot α
h : a ≠ ⊥
b : α
⊢ a.unbot h ≤ b ↔ a ≤ ↑b
state_after: no goals
tactic: match a, h with
  | some _, _ => simp only [unbot_coe, coe_le_coe]
Theorem: Set.image_prod_mk_subset_prod_left
File: Mathlib/Data/Set/Prod.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
hb : b ∈ t
⊢ (fun a => (a, b)) '' s ⊆ s ×ˢ t
state_after: case intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a✝ : α
b : β
hb : b ∈ t
a : α
ha : a ∈ s
⊢ (fun a => (a, b)) a ∈ s ×ˢ t
tactic: rintro _ ⟨a, ha, rfl⟩
state_before: case intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a✝ : α
b : β
hb : b ∈ t
a : α
ha : a ∈ s
⊢ (fun a => (a, b)) a ∈ s ×ˢ t
state_after: no goals
tactic: exact ⟨ha, hb⟩
Theorem: WeierstrassCurve.Jacobian.neg_of_Z_ne_zero
File: Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean

Proof steps:
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : Fin 3 → F
hPz : P z ≠ 0
⊢ W.neg P = P z • ![P x / P z ^ 2, W.toAffine.negY (P x / P z ^ 2) (P y / P z ^ 3), 1]
state_after: no goals
tactic: erw [neg, smul_fin3, mul_div_cancel₀ _ <| pow_ne_zero 2 hPz, ← negY_of_Z_ne_zero hPz,
    mul_div_cancel₀ _ <| pow_ne_zero 3 hPz, mul_one]
Theorem: SimpleGraph.Subgraph.degree_spanningCoe
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

Proof steps:
state_before: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : G.Subgraph
a b : V
G' : G.Subgraph
v : V
inst✝¹ : Fintype ↑(G'.neighborSet v)
inst✝ : Fintype ↑(G'.spanningCoe.neighborSet v)
⊢ G'.spanningCoe.degree v = G'.degree v
state_after: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : G.Subgraph
a b : V
G' : G.Subgraph
v : V
inst✝¹ : Fintype ↑(G'.neighborSet v)
inst✝ : Fintype ↑(G'.spanningCoe.neighborSet v)
⊢ Fintype.card ↑(G'.spanningCoe.neighborSet v) = Fintype.card ↑(G'.neighborSet v)
tactic: rw [← card_neighborSet_eq_degree, Subgraph.degree]
state_before: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : G.Subgraph
a b : V
G' : G.Subgraph
v : V
inst✝¹ : Fintype ↑(G'.neighborSet v)
inst✝ : Fintype ↑(G'.spanningCoe.neighborSet v)
⊢ Fintype.card ↑(G'.spanningCoe.neighborSet v) = Fintype.card ↑(G'.neighborSet v)
state_after: no goals
tactic: congr!
Theorem: ENNReal.le_rpow_one_div_iff
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

Proof steps:
state_before: x y : ℝ≥0∞
z : ℝ
hz : 0 < z
⊢ x ≤ y ^ (1 / z) ↔ x ^ z ≤ y
state_after: x y : ℝ≥0∞
z : ℝ
hz : 0 < z
⊢ x ^ 1 ≤ y ^ (1 / z) ↔ x ^ z ≤ y
tactic: nth_rw 1 [← rpow_one x]
state_before: x y : ℝ≥0∞
z : ℝ
hz : 0 < z
⊢ x ^ 1 ≤ y ^ (1 / z) ↔ x ^ z ≤ y
state_after: x y : ℝ≥0∞
z : ℝ
hz : 0 < z
⊢ x ^ (z * z⁻¹) ≤ y ^ (1 / z) ↔ x ^ z ≤ y
tactic: nth_rw 1 [← @_root_.mul_inv_cancel _ _ z hz.ne']
state_before: x y : ℝ≥0∞
z : ℝ
hz : 0 < z
⊢ x ^ (z * z⁻¹) ≤ y ^ (1 / z) ↔ x ^ z ≤ y
state_after: no goals
tactic: rw [rpow_mul, ← one_div, @rpow_le_rpow_iff _ _ (1 / z) (by simp [hz])]
Theorem: List.rel_perm_imp
File: Mathlib/Data/List/Perm.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
l l₁ l₂ : List α
a✝ : α
γ : Type u_3
δ : Type u_4
r : α → β → Prop
p : γ → δ → Prop
hr : RightUnique r
a : List α
b : List β
h₁ : Forall₂ r a b
c : List α
d : List β
h₂ : Forall₂ r c d
h : a ~ c
this : (flip (Forall₂ r) ∘r Perm ∘r Forall₂ r) b d
⊢ ((flip (Forall₂ r) ∘r Forall₂ r) ∘r Perm) b d
state_after: no goals
tactic: rwa [← forall₂_comp_perm_eq_perm_comp_forall₂, ← Relation.comp_assoc] at this
Theorem: WithTop.map_le_iff
File: Mathlib/Order/WithBot.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : Preorder α
inst✝ : Preorder β
f : α → β
a b : WithTop α
mono_iff : ∀ {a b : α}, f a ≤ f b ↔ a ≤ b
⊢ map f a ≤ map f b ↔ a ≤ b
state_after: case mono_iff
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : Preorder α
inst✝ : Preorder β
f : α → β
a b : WithTop α
mono_iff : ∀ {a b : α}, f a ≤ f b ↔ a ≤ b
⊢ ∀ {a b : αᵒᵈ}, (⇑OrderDual.toDual ∘ f ∘ ⇑OrderDual.ofDual) a ≤ (⇑OrderDual.toDual ∘ f ∘ ⇑OrderDual.ofDual) b ↔ a ≤ b
tactic: erw [← toDual_le_toDual_iff, toDual_map, toDual_map, WithBot.map_le_iff, toDual_le_toDual_iff]
state_before: case mono_iff
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : Preorder α
inst✝ : Preorder β
f : α → β
a b : WithTop α
mono_iff : ∀ {a b : α}, f a ≤ f b ↔ a ≤ b
⊢ ∀ {a b : αᵒᵈ}, (⇑OrderDual.toDual ∘ f ∘ ⇑OrderDual.ofDual) a ≤ (⇑OrderDual.toDual ∘ f ∘ ⇑OrderDual.ofDual) b ↔ a ≤ b
state_after: no goals
tactic: simp [mono_iff]
Theorem: RelSeries.smash_length
File: Mathlib/Order/RelSeries.lean

Proof steps:
state_before: α : Type u_1
r : Rel α α
β : Type u_2
s : Rel β β
p q : RelSeries r
connect : p.last = q.head
i : Fin (p.length + q.length + 1)
H : ¬↑i < p.length
⊢ p.length ≤ ↑i
state_after: no goals
tactic: rwa [not_lt] at H
state_before: α : Type u_1
r : Rel α α
β : Type u_2
s : Rel β β
p q : RelSeries r
connect : p.last = q.head
i : Fin (p.length + q.length + 1)
H : ¬↑i < p.length
⊢ ↑i < p.length + (q.length + 1)
state_after: α : Type u_1
r : Rel α α
β : Type u_2
s : Rel β β
p q : RelSeries r
connect : p.last = q.head
i : Fin (p.length + q.length + 1)
H : ¬↑i < p.length
⊢ ↑i < p.length + q.length + 1
tactic: rw [← add_assoc]
state_before: α : Type u_1
r : Rel α α
β : Type u_2
s : Rel β β
p q : RelSeries r
connect : p.last = q.head
i : Fin (p.length + q.length + 1)
H : ¬↑i < p.length
⊢ ↑i < p.length + q.length + 1
state_after: no goals
tactic: exact i.2
state_before: α : Type u_1
r : Rel α α
β : Type u_2
s : Rel β β
p q : RelSeries r
connect : p.last = q.head
i : Fin (p.length + q.length)
⊢ r ((fun i => if H : ↑i < p.length then p.toFun ⟨↑i, ⋯⟩ else q.toFun ⟨↑i - p.length, ⋯⟩) i.castSucc)
    ((fun i => if H : ↑i < p.length then p.toFun ⟨↑i, ⋯⟩ else q.toFun ⟨↑i - p.length, ⋯⟩) i.succ)
state_after: α : Type u_1
r : Rel α α
β : Type u_2
s : Rel β β
p q : RelSeries r
connect : p.last = q.head
i : Fin (p.length + q.length)
⊢ r (if H : ↑i.castSucc < p.length then p.toFun ⟨↑i.castSucc, ⋯⟩ else q.toFun ⟨↑i.castSucc - p.length, ⋯⟩)
    (if H : ↑i.succ < p.length then p.toFun ⟨↑i.succ, ⋯⟩ else q.toFun ⟨↑i.succ - p.length, ⋯⟩)
tactic: dsimp only
state_before: α : Type u_1
r : Rel α α
β : Type u_2
s : Rel β β
p q : RelSeries r
connect : p.last = q.head
i : Fin (p.length + q.length)
⊢ r (if H : ↑i.castSucc < p.length then p.toFun ⟨↑i.castSucc, ⋯⟩ else q.toFun ⟨↑i.castSucc - p.length, ⋯⟩)
    (if H : ↑i.succ < p.length then p.toFun ⟨↑i.succ, ⋯⟩ else q.toFun ⟨↑i.succ - p.length, ⋯⟩)
state_after: case pos
α : Type u_1
r : Rel α α
β : Type u_2
s : Rel β β
p q : RelSeries r
connect : p.last = q.head
i : Fin (p.length + q.length)
h₂ : ↑i + 1 < p.length
⊢ r (if H : ↑i.castSucc < p.length then p.toFun ⟨↑i.castSucc, ⋯⟩ else q.toFun ⟨↑i.castSucc - p.length, ⋯⟩)
    (if H : ↑i.succ < p.length then p.toFun ⟨↑i.succ, ⋯⟩ else q.toFun ⟨↑i.succ - p.length, ⋯⟩)

case neg
α : Type u_1
r : Rel α α
β : Type u_2
s : Rel β β
p q : RelSeries r
connect : p.last = q.head
i : Fin (p.length + q.length)
h₂ : ¬↑i + 1 < p.length
⊢ r (if H : ↑i.castSucc < p.length then p.toFun ⟨↑i.castSucc, ⋯⟩ else q.toFun ⟨↑i.castSucc - p.length, ⋯⟩)
    (if H : ↑i.succ < p.length then p.toFun ⟨↑i.succ, ⋯⟩ else q.toFun ⟨↑i.succ - p.length, ⋯⟩)
tactic: by_cases h₂ : i.1 + 1 < p.length
Theorem: AlgebraicGeometry.Scheme.mem_basicOpen_top'
File: Mathlib/AlgebraicGeometry/Scheme.lean

Proof steps:
state_before: R : CommRingCat
X : Scheme
V U✝ : X.Opens
f✝ g : ↑Γ(X, U✝)
U : X.Opens
f : ↑Γ(X, U)
x : ↑↑X.toPresheafedSpace
⊢ x ∈ X.basicOpen f ↔ ∃ (m : x ∈ U), IsUnit ((X.presheaf.germ ⟨x, m⟩) f)
state_after: case mp
R : CommRingCat
X : Scheme
V U✝ : X.Opens
f✝ g : ↑Γ(X, U✝)
U : X.Opens
f : ↑Γ(X, U)
x : ↑↑X.toPresheafedSpace
⊢ x ∈ X.basicOpen f → ∃ (m : x ∈ U), IsUnit ((X.presheaf.germ ⟨x, m⟩) f)

case mpr
R : CommRingCat
X : Scheme
V U✝ : X.Opens
f✝ g : ↑Γ(X, U✝)
U : X.Opens
f : ↑Γ(X, U)
x : ↑↑X.toPresheafedSpace
⊢ (∃ (m : x ∈ U), IsUnit ((X.presheaf.germ ⟨x, m⟩) f)) → x ∈ X.basicOpen f
tactic: fconstructor
Theorem: CategoryTheory.Limits.biprod.inl_map
File: Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean

Proof steps:
state_before: J : Type w
C : Type u
inst✝⁵ : Category.{v, u} C
inst✝⁴ : HasZeroMorphisms C
D : Type uD
inst✝³ : Category.{uD', uD} D
inst✝² : HasZeroMorphisms D
P Q W X Y Z : C
inst✝¹ : HasBinaryBiproduct W X
inst✝ : HasBinaryBiproduct Y Z
f : W ⟶ Y
g : X ⟶ Z
⊢ inl ≫ map f g = f ≫ inl
state_after: J : Type w
C : Type u
inst✝⁵ : Category.{v, u} C
inst✝⁴ : HasZeroMorphisms C
D : Type uD
inst✝³ : Category.{uD', uD} D
inst✝² : HasZeroMorphisms D
P Q W X Y Z : C
inst✝¹ : HasBinaryBiproduct W X
inst✝ : HasBinaryBiproduct Y Z
f : W ⟶ Y
g : X ⟶ Z
⊢ inl ≫ map' f g = f ≫ inl
tactic: rw [biprod.map_eq_map']
state_before: J : Type w
C : Type u
inst✝⁵ : Category.{v, u} C
inst✝⁴ : HasZeroMorphisms C
D : Type uD
inst✝³ : Category.{uD', uD} D
inst✝² : HasZeroMorphisms D
P Q W X Y Z : C
inst✝¹ : HasBinaryBiproduct W X
inst✝ : HasBinaryBiproduct Y Z
f : W ⟶ Y
g : X ⟶ Z
⊢ inl ≫ map' f g = f ≫ inl
state_after: no goals
tactic: exact IsColimit.ι_map (BinaryBiproduct.isColimit W X) _ _ ⟨WalkingPair.left⟩
Theorem: HomologicalComplex.homologyIsoSc'_inv_ι
File: Mathlib/Algebra/Homology/ShortComplex/HomologicalComplex.lean

Proof steps:
state_before: C : Type u_1
inst✝³ : Category.{u_3, u_1} C
inst✝² : HasZeroMorphisms C
ι : Type u_2
c : ComplexShape ι
K : HomologicalComplex C c
i j k : ι
hi : c.prev j = i
hk : c.next j = k
inst✝¹ : K.HasHomology j
inst✝ : (K.sc' i j k).HasHomology
⊢ (K.homologyIsoSc' i j k hi hk).inv ≫ K.homologyι j = (K.sc' i j k).homologyι ≫ (K.opcyclesIsoSc' i j k hi hk).inv
state_after: no goals
tactic: apply ShortComplex.homologyι_naturality
Theorem: Int.ModEq.neg
File: Mathlib/Data/Int/ModEq.lean

Proof steps:
state_before: m n a b c d : ℤ
h : a ≡ b [ZMOD n]
⊢ a + -a ≡ b + -b [ZMOD n]
state_after: m n a b c d : ℤ
h : a ≡ b [ZMOD n]
⊢ 0 ≡ 0 [ZMOD n]
tactic: simp_rw [← sub_eq_add_neg, sub_self]
state_before: m n a b c d : ℤ
h : a ≡ b [ZMOD n]
⊢ 0 ≡ 0 [ZMOD n]
state_after: no goals
tactic: rfl
Theorem: Part.mod_mem_mod
File: Mathlib/Data/Part.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : Mod α
a b : Part α
ma mb : α
ha : ma ∈ a
hb : mb ∈ b
⊢ ma % mb ∈ a % b
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : Mod α
a b : Part α
ma mb : α
ha : ma ∈ a
hb : mb ∈ b
⊢ ∃ a_1 ∈ a, ∃ a ∈ b, a_1 % a = ma % mb
tactic: simp [mod_def]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : Mod α
a b : Part α
ma mb : α
ha : ma ∈ a
hb : mb ∈ b
⊢ ∃ a_1 ∈ a, ∃ a ∈ b, a_1 % a = ma % mb
state_after: no goals
tactic: aesop
Theorem: Multiset.powersetCardAux_perm
File: Mathlib/Data/Multiset/Powerset.lean

Proof steps:
state_before: α : Type u_1
n : ℕ
l₁ l₂ : List α
p : l₁ ~ l₂
⊢ powersetCardAux n l₁ ~ powersetCardAux n l₂
state_after: case zero
α : Type u_1
l₁ l₂ : List α
p : l₁ ~ l₂
⊢ powersetCardAux 0 l₁ ~ powersetCardAux 0 l₂

case succ
α : Type u_1
n : ℕ
IHn : ∀ {l₁ l₂ : List α}, l₁ ~ l₂ → powersetCardAux n l₁ ~ powersetCardAux n l₂
l₁ l₂ : List α
p : l₁ ~ l₂
⊢ powersetCardAux (n + 1) l₁ ~ powersetCardAux (n + 1) l₂
tactic: induction' n with n IHn generalizing l₁ l₂
state_before: case succ
α : Type u_1
n : ℕ
IHn : ∀ {l₁ l₂ : List α}, l₁ ~ l₂ → powersetCardAux n l₁ ~ powersetCardAux n l₂
l₁ l₂ : List α
p : l₁ ~ l₂
⊢ powersetCardAux (n + 1) l₁ ~ powersetCardAux (n + 1) l₂
state_after: case succ.nil
α : Type u_1
n : ℕ
IHn : ∀ {l₁ l₂ : List α}, l₁ ~ l₂ → powersetCardAux n l₁ ~ powersetCardAux n l₂
l₁ l₂ : List α
⊢ powersetCardAux (n + 1) [] ~ powersetCardAux (n + 1) []

case succ.cons
α : Type u_1
n : ℕ
IHn : ∀ {l₁ l₂ : List α}, l₁ ~ l₂ → powersetCardAux n l₁ ~ powersetCardAux n l₂
l₁✝ l₂✝ : List α
a : α
l₁ l₂ : List α
p : l₁ ~ l₂
IH : powersetCardAux (n + 1) l₁ ~ powersetCardAux (n + 1) l₂
⊢ powersetCardAux (n + 1) (a :: l₁) ~ powersetCardAux (n + 1) (a :: l₂)

case succ.swap
α : Type u_1
n : ℕ
IHn : ∀ {l₁ l₂ : List α}, l₁ ~ l₂ → powersetCardAux n l₁ ~ powersetCardAux n l₂
l₁ l₂ : List α
a b : α
l : List α
⊢ powersetCardAux (n + 1) (b :: a :: l) ~ powersetCardAux (n + 1) (a :: b :: l)

case succ.trans
α : Type u_1
n : ℕ
IHn : ∀ {l₁ l₂ : List α}, l₁ ~ l₂ → powersetCardAux n l₁ ~ powersetCardAux n l₂
l₁✝ l₂✝ l₁ l₂ l₃ : List α
a✝¹ : l₁ ~ l₂
a✝ : l₂ ~ l₃
IH₁ : powersetCardAux (n + 1) l₁ ~ powersetCardAux (n + 1) l₂
IH₂ : powersetCardAux (n + 1) l₂ ~ powersetCardAux (n + 1) l₃
⊢ powersetCardAux (n + 1) l₁ ~ powersetCardAux (n + 1) l₃
tactic: induction' p with a l₁ l₂ p IH a b l l₁ l₂ l₃ _ _ IH₁ IH₂
Theorem: LinearMap.toSeminorm_ball_zero
File: Mathlib/Analysis/LocallyConvex/WeakDual.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
ι : Type u_4
inst✝⁴ : NormedField 𝕜
inst✝³ : AddCommGroup E
inst✝² : Module 𝕜 E
inst✝¹ : AddCommGroup F
inst✝ : Module 𝕜 F
f : E →ₗ[𝕜] 𝕜
r : ℝ
⊢ f.toSeminorm.ball 0 r = {x | ‖f x‖ < r}
state_after: no goals
tactic: simp only [Seminorm.ball_zero_eq, toSeminorm_apply]
Theorem: Real.LogDeriv_exp
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean

Proof steps:
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : E → ℝ
f' : E →L[ℝ] ℝ
x : E
s : Set E
⊢ logDeriv rexp = 1
state_after: case h
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : E → ℝ
f' : E →L[ℝ] ℝ
x : E
s : Set E
x✝ : ℝ
⊢ logDeriv rexp x✝ = 1 x✝
tactic: ext
state_before: case h
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : E → ℝ
f' : E →L[ℝ] ℝ
x : E
s : Set E
x✝ : ℝ
⊢ logDeriv rexp x✝ = 1 x✝
state_after: no goals
tactic: rw [logDeriv, Real.deriv_exp, Pi.div_apply, ← exp_sub, sub_self, exp_zero, Pi.one_apply]
Theorem: Matroid.sum_base_iff
File: Mathlib/Data/Matroid/Sum.lean

Proof steps:
state_before: α : Type u
β : Type v
M✝ N✝ M : Matroid α
N : Matroid β
B : Set (α ⊕ β)
⊢ (M.sum N).Base B ↔ M.Base (Sum.inl ⁻¹' B) ∧ N.Base (Sum.inr ⁻¹' B)
state_after: α : Type u
β : Type v
M✝ N✝ M : Matroid α
N : Matroid β
B : Set (α ⊕ β)
⊢ M.Base
        ((fun a => a.down) ''
          (Sigma.mk false ⁻¹'
            ((fun a => (Equiv.sumEquivSigmaBool (ULift.{v, u} α) (ULift.{u, v} β)) a) ''
              ((fun a => Sum.map (⇑Equiv.ulift.symm) (⇑Equiv.ulift.symm) a) '' B)))) ∧
      N.Base
        ((fun a => a.down) ''
          (Sigma.mk true ⁻¹'
            ((fun a => (Equiv.sumEquivSigmaBool (ULift.{v, u} α) (ULift.{u, v} β)) a) ''
              ((fun a => Sum.map (⇑Equiv.ulift.symm) (⇑Equiv.ulift.symm) a) '' B)))) ↔
    M.Base (Sum.inl ⁻¹' B) ∧ N.Base (Sum.inr ⁻¹' B)
tactic: simp only [Matroid.sum, mapEquiv_base_iff, Equiv.sumCongr_symm, Equiv.sumCongr_apply,
    Equiv.symm_symm, sigma_base_iff, Bool.forall_bool, Equiv.ulift_apply]
state_before: α : Type u
β : Type v
M✝ N✝ M : Matroid α
N : Matroid β
B : Set (α ⊕ β)
⊢ M.Base
        ((fun a => a.down) ''
          (Sigma.mk false ⁻¹'
            ((fun a => (Equiv.sumEquivSigmaBool (ULift.{v, u} α) (ULift.{u, v} β)) a) ''
              ((fun a => Sum.map (⇑Equiv.ulift.symm) (⇑Equiv.ulift.symm) a) '' B)))) ∧
      N.Base
        ((fun a => a.down) ''
          (Sigma.mk true ⁻¹'
            ((fun a => (Equiv.sumEquivSigmaBool (ULift.{v, u} α) (ULift.{u, v} β)) a) ''
              ((fun a => Sum.map (⇑Equiv.ulift.symm) (⇑Equiv.ulift.symm) a) '' B)))) ↔
    M.Base (Sum.inl ⁻¹' B) ∧ N.Base (Sum.inr ⁻¹' B)
state_after: no goals
tactic: convert Iff.rfl <;>
    simp [Set.ext_iff, Equiv.ulift, Equiv.sumEquivSigmaBool]